Hi,

That's not a specific generic-problem. The following (without generics)
wouldn't work, either:

 void Object foo (Object arg) {
    arg.bar();
 }

Try the following instead:

 void <T extends Barable> foo (T arg) {
    arg.bar();
 }

Ciao,
Ingo

"Matthias Kaeppler" wrote...

Of course it will, if you somehow tell it that T is of a type that has the
method bar implemented. Otherwise your example would be just the same as:

 void foo (Object arg) {
    arg.bar();
 }

...and to my knowledge, Object doesn't have bar implemented.

So you need to read up on the syntax for using generics.

Here's a small example that might clarify things for you:

class TY<T extends Y>
{

  public void foo (T arg)
  {
      arg.bar();
  }
}

interface Y
{
  public void bar();
}

class X implements Y
{
  public void bar()
  {
     System.out.println("bar");
  }
}

public class TGen
{
  public static void main (String[] args)
  {
      X     x  = new X();

      TY<Y> tt = new TY<Y>();

      tt.foo(x);
  }
}

// Bjorn A

You are thinking that Java's generics are similar to C++'s templates.  Which is
understandable but, unfortunately, completely wrong.  There is no significant
similarity -- they do rather different things, and do them in /completely/
different ways.  In particular, Java's generics are /not/ a templating
facility, the compiler does not "instantiate" a template by "substituting in"
the parameter class(es).

I suggest that you:
   a) forget about templates when you are working in
       Java -- they'll just confuse you.
   b) read (several times, unless you are quicker on the
       uptake than me) Gilad Bracha's generics tutorial.

I think the tutorial is here:
   http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

   -- chris