Generics and ? symbol

[Jean-Luc Thirion]

Hello,

why has the symbol <?> be added to Java 1.5 (for generics)

Given that scenario (extracted from K&B's book):

abstract class Animal {
    public void checkup() { System.out.println("Animal checkup");}
}
class Dog extends Animal {
    public void checkup() { System.out.println("Dog checkup");}
}
class Cat extends Animal {
    public void checkup() { System.out.println("Cat checkup");}
}
 
class AnimalDoctor {
   //solution to the problem of working on a List<Cat> or List<Dog>
   //is using a List<? extends Animal> instead of a List<Animal>
   //But the List will be read only
   public void checkupAll(List<? extends Animal> animals) {
       for(Animal a: animals) {
           a.checkup();  
        }
   }
}
 

public class MainClass {
    public static void main(String[] args) {
        AnimalDoctor doctor = new AnimalDoctor();
        List<Cat> cats = new ArrayList<Cat>();
        //fill the list with cats here
        List<Dog> dogs = new ArrayList<Dog>();
        //fill the list with dogs here
         doctor.checkupAll(cats); //ok
         doctor.checkupAll(dogs); //ok
    }
}
 

But it seems to me that the checkupAll implementation could be replaced by:

public <T extends Animal>void checkupAll(List<T> animals) {
       for(Animal a: animals) {
           a.checkup();  
        }
}

In this second implementation of "checkAll" is the List also read-only (probably it is)?

So what is the need for the <?> symbol in the language? I don't totally understand.

Thanks in advance for your help!

[Campbell Ritchie]

have you read the Java Tutorial? Look particularly at the two sections about wildcards. It means you want the class to be generic for a particualr type, but haven't specified what yet, as a gross oversimplification.

[Jean-Luc Thirion]

So what's the difference between:

public void checkupAll(List<? extends Animal> animals) {
       for(Animal a: animals) {
           a.checkup();  
        }
}

and

public <T extends Animal>void checkupAll(List<T> animals) {
       for(Animal a: animals) {
           a.checkup();  
        }
}

Is the second declaration not legal ? (I will try it later when i can do it)

[Jean-Luc Thirion]

Ok the answer to my previous post is: There is NO DIFFERENCE
i.e.:
- The compilers checks are the same
- The generated bytecode is the same


I compiled this piece of code:

import java.util.*;
 
abstract class Animal {
    public void checkup() { System.out.println("Animal checkup");}
}
class Dog extends Animal {
    public void checkup() { System.out.println("Dog checkup");}
}
class Cat extends Animal {
    public void checkup() { System.out.println("Cat checkup");}
}
 
class AnimalDoctor {
   //solution to the problem of working on a List<Cat> or List<Dog>
   //is using a List<? extends Animal> instead of a List<Animal>
   //But the List will be read only
   public void checkupAll(List<? extends Animal> animals) {
       for(Animal a: animals) {
           a.checkup();  
        }
        //animals.add(new Cat());Forbidden !      //#1
        //animals.remove(0);                       //#2
   }
 
   public <T extends Animal> void checkupAll2(List<T> animals) {
        for(Animal a: animals) {
           a.checkup();  
        }
        //animals.add(new Cat()); Forbidden !  //#3
        //animals.remove(0);                      //#4
        
   }
 
}
 
 
public class GenericsDiff {
    public static void main(String[] args) {
        AnimalDoctor doctor = new AnimalDoctor();
        List<Cat> cats = new ArrayList<Cat>();
        cats.add(new Cat());cats.add(new Cat());
        List<Dog> dogs = new ArrayList<Dog>();
        dogs.add(new Dog());
         doctor.checkupAll2(cats); //ok
         doctor.checkupAll2(dogs); //ok
    }
}

Now
1�) If i decompile the bytecode with jad, I get the exact same code,
i.e, there is no difference after type erasure:

// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: <a href="http://www.geocities.com/kpdus/jad.html" target="_blank" rel="nofollow">http://www.geocities.com/kpdus/jad.html</a>
// Decompiler options: packimports(3) 
// Source File Name:   GenericsDiff.java
 
import java.util.Iterator;
import java.util.List;
 
class AnimalDoctor
{
 
    AnimalDoctor()
    {
    }
 
    public void checkupAll(List list)
    {
        Animal animal;
        for(Iterator iterator = list.iterator(); iterator.hasNext(); animal.checkup())
            animal = (Animal)iterator.next();
 
    }
 
    public void checkupAll2(List list)
    {
        Animal animal;
        for(Iterator iterator = list.iterator(); iterator.hasNext(); animal.checkup())
            animal = (Animal)iterator.next();
 
    }
}

That proves there is no difference at runtime (it was quite obvious because of type erasure)

2�) Now a comile time. If I uncomment line #1
the code does not compile anymore, and I get the error:

jlinho@gaston:~/Bureau/SCJP tests$ javac GenericsDiff.java 
GenericsDiff.java:21: cannot find symbol
symbol  : method add(Cat)
location: interface java.util.List<capture of ? extends Animal>
        animals.add(new Cat());
               ^
1 error
 

if I comment line #1 and I uncomment line #3, the compiler prevents me from doing that and I get the following compiler error (which is very similar to the previous one):

jlinho@gaston:~/Bureau/SCJP tests$ javac GenericsDiff.java 
GenericsDiff.java:27: cannot find symbol
symbol  : method add(Cat)
location: interface java.util.List<T>
        animals.add(new Cat());
               ^
1 error

If I re-comment the lines marked #1 and #3, and I uncomment the lines marked #2 and #4, the code compiles and runs fine.


As a first conclusion, I don't see a difference between both declarations because the behaviour is similar at both, compile-time and runtime. So I really don't understand the need of the <?> symbol in the language. Please tell me !

[Campbell Ritchie]

Not sure, maybe somebody else can answer better.

But what you see at runtime can vary from what is written as code. Remember that erasure means the generics information is lost from the bytecode. I think it means that a class Foo<? extends Bar> can be a subclass of Foo<Bar>, whereas a Foo<T extends Bar> isn't a subclass of Foo<Bar>. That is something you would only notice at compile time; by the time the bytecode is created the difference has vanished.

As I said, maybe somebody else can answer better.

[Jean-Luc Thirion]

Ok...
One thing you can't do without wildcards:

List<Dog> dogList = new List<Dog>()
// ... add some dogs to the list
Collection<? extends Serializable> finalCopy = dogList;

So... "List<Dog>� IS-A "List<? extends Serializable>"

Source: today.java.net
[ February 07, 2008: Message edited by: Jean-Luc Thirion ]