generic question

[Mike Mitchell]

Howdy ranchers. What would you say is the difference between:

public <T extends Animal> void addAnimal(List<T> animals) { }

and

public void addAnimal(List<? extends Animal> animals) { }

Having trouble sorting out when exactly it's cool to use ?, and when it's not.

Thanks in advance.

Mike

[Ireneusz Kordal]

There is almost no difference ... but the first declaration allows you to use generic type T to, for example, declare variable inside the method or something other:

 
public <T extends Animal> void addAnimal(List<T> animals) { 
  T var;
  List <T> list = new ArrayList<T>();
}   

and the second does not allow this.
[ July 24, 2008: Message edited by: Ireneusz Kordal ]

[Justin Smith]

From K&B Chapter 7: Page number 604:

One of the most common mistakes programmers make when creating
generic classes or methods is to use a <?> in the wildcard syntax rather than a type variable <T>, <E>, and so on. This code might look right, but isn�t:

public class NumberHolder<? extends Number> { }

While the question mark works when declaring a reference for a variable,
it does NOT work for generic class and method declarations. This code is not legal:

public class NumberHolder<?> { ? aNum; } // NO!

But if you replace the <?> with a legal identifier, you�re good:

public class NumberHolder<T> { T aNum; } // Yes


Hope this clarfies your doubt !!!

[doug rosenberg]

Justin we are talking about generic methods and not generic classes.
I originally thought they were basically the same but I came up some code which allows you to add to the method paramterized with the T.
It is not possible to add to the other methods List.



class Animal{
public String toString(){
return ddd;
}
String ddd = "howdy";
<T extends Animal> void addAnimal(List<T> animals) {
T myAnimal=(T)new Animal();
animals.add(myAnimal);
}}

[ July 24, 2008: Message edited by: doug rosenberg ]
[ July 24, 2008: Message edited by: doug rosenberg ]

[Mike Mitchell]

Thanks guys. I think Doug's identified a key difference: with the ?, an attempt to add won't compile. With the T and a cast, we get a compiler warning, but we're able to get away with the add. Maybe the conclusion is it's better form to use the wildcard.

    
      1 import java.util.*;
      2 class Animal {
      3 
      4     <T extends Animal> void addAnimal(List<T> animals) {
      5         T myAnimal=(T)new Animal();
      6         animals.add(myAnimal);
      7     }
      8 
      9     void addAnimal2(List<? extends Animal> animals) {
     10         //animals.add(new Animal());
     11     }
     12 
     13     public static void main (String... args) {
     14         List<Animal> animalList = new ArrayList<Animal>();
     15         Animal a = new Animal();
     16         a.addAnimal(animalList);
     17         a.addAnimal2(animalList);
     18     }
     19 }