generic question

[Edmen Tay]

Hi all,
I had try compile this,

     List<? super Integer> list = new ArrayList <Integer>(); 
   list.add((Integer) new Object());   //will compile
           list.add(new Object());   //will not compile

But when i cast the (Integer) new Object(). then it work fine.

My question is, reference type is "? super Integer", then it should be able to accept Object, as Object is a super type of Integer? Am I correct?

Please help.

Regards,
Edmen

[Harvinder Thakur]

My question is, reference type is "? super Integer", then it should be able to accept Object, as Object is a super type of Integer?

The wild card notations of *? super someclass/interface* and *? extends someclass/interface* are used to define the generic parameter type of a Collection.
If i define a collection of as List<? super Dog>; listDogs
then i am telling the compiler that *listDogs* can be assigned any reference of a generic collection which contains objects of type Dog or super type of Dog. So, if i have the following classes:

class God{}
class Animal extends God{}
class Dog extends Animal{}
class Puppy extends Dog{}

then i can say,
List <? super Dog> listDogs = new ArrayList<Animal>();
or
List <? super Dog> listDogs = new ArrayList<Object>();

list.add(new Dog());
list.add(new Puppy());

I am free to add any Dog or a subclass of Dog object to it because the compiler knows that no matter what, the Dog or its subclass object is going to pass the IS-A test for the type (actually a supertype of Dog) of objects stored in the actual collection ( which i am actually modifying i.e. the ArrayList of Animals or Objects in this case).

But, i cannot add a super type of Dog into *listDogs* the reason being the following scenario:

List <? super Dog> listDogs = new ArrayList<Animal>();
 
listDogs.add(new Dog());
//fine
 
listDogs.add(new Puppy());
//fine as Puppy is subclass of Dog
 
listDogs.add(new God());
//blows up because you are actually referring to a collection of Animal 
//objects and now you are inadvertently adding God object to it. This is 
//the situation the compiler tries to prevent by allowing you to add only 
//Dog or its subtypes to the collection because a Dog or its subtype will 
//always pass the IS-A test for the collection type actually assigned to 
//listDogs.

If i say,
List <? extends Dog>; listDogs = new ArrayList<Animal>(); //Compiler error then, the compiler will not allow as the extends keyword means Dog or its subclass type can be assigned to the listDogs collection.
So, List<? extends Dog> listDogs = new ArrayList<Puppy>();is a valid assignment.

listDogs.add(new Dog());// compiler error
listDogs.add(new Puppy());// compiler error

I can't add to *listDogs* as the compiler is not sure as to which type of collection may be assigned to *listDogs*.
For *? extends* wild card the compiler does'nt know to what level down the class hierarchy of class *Dog* the actual collection type can belong to. So it's even more dangerous in case of *? extends* to allow somebody to even add to the collection. Hence i am not allowed to add anything.

[ December 15, 2008: Message edited by: Harvinder Thakur ]
[ December 15, 2008: Message edited by: Harvinder Thakur ]

[Henry Wong]

But when i cast the (Integer) new Object(). then it work fine.

And you also "broke" the collection. Generally, if the compiler complains that you need a particular item, forcing it is not a good idea. If you want to force it, why bother using generics?

My question is, reference type is "? super Integer", then it should be able to accept Object, as Object is a super type of Integer? Am I correct?

No. You are not correct. "? super Integer" does *not* mean that it can accept any type that is a super of Integer. It means that it accepts an unknown type that is a super of Integer. So, in order to add to the list, you must add the unknown type -- and the only types that can be any unknown type of super of Integer, is Integer, as an Integer IS-A all super types of Integer.

Henry

[victor kamat]

Consider the code below.

Line 4: instead of <B> we could not have <D>; but <C>, <A> or <Object> are ok because they are each parent of C; (D is a child of C).

Lines 6, 7: adding instances of C and D is okay because each is a C and therefore guaranteed to be an A, B, or C.

Lines 8, 9: adding instances of A or B is an error, because neither is guaranteed to be a C.

1  public class Test {
2    public static void main(String... args) 
3     {
4         List<? super C> lst = new ArrayList<B>(); //1
5
6         lst.add( new C() );  //ok
7         lst.add( new D() );  //ok
8         lst.add( new B() );  // 2
9         lst.add( new A() );  // 3
10        lst.add( null );     //ok
11    }
12
13  class A {}
14  class B extends A {}
15  class C extends B {}
16  class D extends C {}
 

( Jesper Young: Corrected code tags )
[ December 15, 2008: Message edited by: Jesper Young ]

[victor kamat]

Because of bad code presentation here it is again:
Consider the code below.

Line 4: instead of <B> we could not have <D>; but <C>, <A> or <Object> are ok because they are each parent of C; (D is a child of C).

Lines 6, 7: adding instances of C and D is okay because each is a C and therefore guaranteed to be an A, B, or C.

Lines 8, 9: adding instances of A or B is an error, because neither is guaranteed to be a C.

1  public class Test {
2    public static void main(String... args) 
3     {
4         List<? super C> lst = new ArrayList<B>(); //1
5
6         lst.add( new C() );  //ok
7         lst.add( new D() );  //ok
8         lst.add( new B() );  // 2
9         lst.add( new A() );  // 3
10        lst.add( null );     //ok
11    }
12
13  class A {}
14  class B extends A {}
15  class C extends B {}
16  class D extends C {}
 

[Jesper de Jong]

Originally posted by victor kamat:
Because of bad code presentation here it is again: ...

Note that there is an edit button that looks like this: above your post, which you can use to edit your post - no need to post the whole thing again.

[Edmen Tay]

Hi Henry,

No. You are not correct. "? super Integer" does *not* mean that it can accept any type that is a super of Integer. It means that it accepts an unknown type that is a super of Integer. So, in order to add to the list, you must add the unknown type -- and the only types that can be any unknown type of super of Integer, is Integer, as an Integer IS-A all super types of Integer.

Can i said "? super Integer" is an unknown type can be stored in the collection whereby with the condition must pass the IS-A Integer test? then what else of super class of Integer can be added?

Hi Harvinder Thakur,

I had put some remark at your explanation.

List <? super Dog> listDogs = new ArrayList<Animal>(); //wildcard with super then listDogs is allow to reference type of Animal (super class of dog)
listDogs.add(new Dog());//Dog passed Is-an Animal test

listDogs.add(new Puppy());//Puppy passed Is-an Animal test
//fine as Puppy is subclass of Dog
listDogs.add(new God());//God failed Is-an Animal test

This is logic and make me clear. But the below quote:

List <? extends Dog>; listDogs = new ArrayList<Animal>(); //Compiler error, because listDogs trying to reference ArrayList with type Animal, but Animal failed Is-A Dog test //Statement 1

So, List<? extends Dog> listDogs = new ArrayList<Puppy>();//is a valid assignment, because listDogs trying to reference ArrayList with type Puppy and Puppy passed Is-A Dog test //Statement 2

listDogs.add(new Dog());// compiler error? refer Statement 2? but it passed the Is-A Dog test
listDogs.add(new Puppy());// compiler error? refer Statement 2? but it passed the Is-A Dog test

For *? extends* wild card the compiler does'nt know to what level down the class hierarchy of class *Dog* the actual collection type can belong to. So it's even more dangerous in case of *? extends* to allow somebody to even add to the collection.

Then what can be added into the list?

Thanks and appreciate the explanations posted from you guys.

Regards,
Edmen

[Henry Wong]

listDogs.add(new Dog());// compiler error? refer Statement 2? but it passed the Is-A Dog test
listDogs.add(new Puppy());// compiler error? refer Statement 2? but it passed the Is-A Dog test

Then what can be added into the list?

Keep in mind, that it is silly to purposely work with unknown types (wildcards), if you don't have to. You do so because you want to write code that can work with a broad set of generic types. In this example, you may want to write a method that can handle a list that can any type that extends Dog.

But it comes with a price. In this case, since you don't know what type the list actually hold, you can't add anything to the list. If you need to add something to the list, then you can't work with an unknowm type that extends Dog, you need to know the type.

Henry
[ December 15, 2008: Message edited by: Henry Wong ]

[Harvinder Thakur]

Let's take an example for *? extends* wildcard notation:

1. class abc
2. {
 
3. public static void main(String... args){
 
4. List <Puppy> list = new ArrayList<Puppy>();            
5. methodAcceptsGenericArgument(list);
6. Puppy puppy = list.get(1); // If add were allowed then we get a 
                             // ClassCastException as a Dog is not a Puppy
7.}
 
8.public static void methodAcceptsGenericArgument(List<? extends Dog> lstDogs)
10. {
11.  lstDogs.add(new Puppy()); //illegal, but suppose it is allowed then it 
                            //would be correct because the underlying list 
                            // is of type Puppy.
 
12.  lstDogs.add(new Dog()); //illegal, but suppose it is allowed then it 
                            //would be *INCORRECT* because the underlying 
                            // list is of type Puppy.
13.}
 
14.}

The above two calls to the add() method are O.K. from the perspective of the compiler but since the compiler removes the type info using type erasure such that the JVM at runtime does not have any type info hence, the above code would crash at runtime at line no. 6 above. So even though generics are supposed to be type safe we break the type safety of generics by adding something to a list which uses *? extends someclass/interface* notation.

Hope i make sense.

[Edmen Tay]

Hi all,
I try to understand the below code in IDE. and put some of my understanding comment

  import java.util.*;
 
public class TestGenericSuper {
public static void main(String... args) {

List<? super AA> lst1 = new ArrayList<AA>();//lst1 can contain AA,BB,CC,DD and unknown type that is super type of AA
List<? super BB> lst2 = new ArrayList<BB>();//lst2 can contain BB,CC,DD and unknown type that is super type of BB
List<? super CC> lst3 = new ArrayList<BB>();//lst3 can contain CC,DD and unknown type that is super type of CC
List<? super DD> lst4 = new ArrayList<CC>();//lst4 can contain DD and unknown type that is super type of DD

lst1.add(new AA());
lst1.add(new BB());
lst1.add(new CC());
lst1.add(new DD());
lst1.add(null);


lst2.add(new AA());//unknown super type is BB, and "AA IS-NOT BB". Therefore, will not compile
lst2.add(new BB());//will compile, unknown type is BB and "BB IS-A BB"
lst2.add(new CC());//will compile, "CC IS-A BB"
lst2.add(new DD());//will compile, "DD IS-A BB"

lst3.add(new AA());//unknown super type is CC, and "AA IS-NOT CC". Therefore, will not compile 
lst3.add(new BB());//unknown super type is BB, and "BB IS-NOT CC". Therefore, will not compile 
lst3.add(new CC()); //will compile, "CC IS-A CC"
lst3.add(new DD()); //will compile, "DD IS-A CC"

lst4.add(new AA());//unknown super type is DD, and "AA IS-NOT DD". Therefore, will not compile
lst4.add(new BB());//unknown super type is DD, and "BB IS-NOT DD". Therefore, will not compile 
lst4.add(new CC());//unknown super type is DD, and "CC IS-NOT DD". Therefore, will not compile
lst4.add(new DD());//will compile, "DD IS-A DD"
lst4.add(new Object());//unknown super type is DD, and "Object IS-NOT DD". Therefore, will not compile


List<? extends AA> lst5 = new ArrayList<AA>();//lst5 could be contain unknown type that is subclass of AA
List<? extends BB> lst6 = new ArrayList<CC>();//lst6 could be contain unknown type that is subclass of BB
List<? extends CC> lst7 = new ArrayList<CC>();//lst7 could be contain unknown type that is subclass of CC
List<? extends DD> lst8 = new ArrayList<DD>();//lst8 could be contain unknown type that is subclass of DD

//Below all will not compiled. because lst5,6,7,8 could add any type that is subclass of their type respectively,
//compiler don't know any type will be added
//Therefore, A and its subclass is not unknown type for subclass of A

//Except lst5.add(null); will compile because it considered as unknown type for subclass of A
lst5.add(new AA());
lst5.add(new BB());
lst5.add(new CC());
lst5.add(new DD());
lst5.add(null);
lst5.add(new Object());


lst6.add(new AA());
lst6.add(new BB());
lst6.add(new CC());
lst6.add(new DD());

lst7.add(new AA()); 
lst7.add(new BB()); 
lst7.add(new CC()); 
lst7.add(new DD()); 

lst8.add(new AA()); 
lst8.add(new BB()); 
lst8.add(new CC()); 
lst8.add(new DD()); 

}
}
 

class AA {
}
 
class BB extends AA {
}
 
class CC extends BB {
}
 
class DD extends CC {
}  

Please correct if i am wrong.

Thank you

Regards,
Edmen

[Edmen Tay]

Hi,
Below is the left out part:

lst5.add(new Object());//will not compile as it is unknown type of subclass AA


Regards,
Edmen

[Himalay Majumdar]

Originally posted by Harvinder Thakur:
[QB]

If i define a collection of as List<? super Dog>; listDogs
then i am telling the compiler that *listDogs* can be assigned any reference of a generic collection which contains objects of type Dog or super type of Dog. So, if i have the following classes:

class God{}
class Animal extends God{}
class Dog extends Animal{}
class Puppy extends Dog{}

then i can say,
List <? super Dog> listDogs = new ArrayList<Animal>();
or
List <? super Dog> listDogs = new ArrayList<Object>();

list.add(new Dog());
list.add(new Puppy());

I am free to add any Dog or a subclass of Dog object to it because the compiler knows that no matter what, the Dog or its subclass object is going to pass the IS-A test for the type (actually a supertype of Dog) of objects stored in the actual collection ( which i am actually modifying i.e. the ArrayList of Animals or Objects in this case).

But, i cannot add a super type of Dog into *listDogs* the reason being the following scenario:

List <? super Dog> listDogs = new ArrayList<Animal>();
 
listDogs.add(new Dog());
//fine
 
listDogs.add(new Puppy());
//fine as Puppy is subclass of Dog

So, Does it mean this is possible
listDogs.add(new Animal())

if NOT.. then what does Super type imply

[Himalay Majumdar]

Hi Edmen,

You quoted,

List<? super BB> lst2 = new ArrayList<BB>();//lst2 can contain BB,CC,DD and [B]unknown type that is super type of BB[/B]
 
lst2.add(new AA());//unknown super type is BB, and "AA IS-NOT BB". Therefore, will not compile

how is it possible that that unknown super type is BB in the second statement above.

Thanks
[ December 17, 2008: Message edited by: Himalay Majumdar ]

[Harvinder Thakur]

Originally posted by Himalay Majumdar:

So, Does it mean this is possible
listDogs.add(new Animal())

if NOT.. then what does Super type imply

Super type implies the generic type of the ArrayList i.e. Animal which is being assigned to the List listDogs which can only be assigned a collection which IS-A List.

List <? super Dog> listDogs = new ArrayList<Animal>();

So, above listDogs can be assigned any List which contains a supertype of Dog or Dog itself.
Actually the restriction posed by the compiler on additions to a generic typed Collection is better appreciated if we take the scenario of a method which takes an argument of List <? super Dog> listDogs and the method calling code assigning the ArrayList<Animal> to the method argument.

class generic
{
  public static void main(String... args)
  {
       List<Animal> listAnimals = new ArrayList<Animal>(); 
 
       genericMethod(listAnimals);
  }
 
  public static void genericMethod(List<? super Dog> listDogs)
  {
       listDogs.add(new Dog());//legal
       listDogs.add(new Animal());//Illegal, but suppose the compiler allows 
                                  //it then it is correct as the underlying 
                                  //collection is of type Animals
       listDogs.add(new God());//Illegal, but suppose the compiler allows 
                                //it then it is *INCORRECT* as the 
                                //underlying collection is of type Animals
   
  }
 
}

As you can see the *ONLY* safe addition that i can make to a collection which accepts a type T or it supertypes T' is T or its subtypes to that collection as demonstrated above.
But had it been *? extends* wild card notation( implying only Dog or its subtypes can be assigned) then adding subtype of Dog or even Dog itself to the listDogs collection would have been risky because the subtype passes the IS-A test for the supertype and not the supertype for its subtypes.

Hope it makes sense
[ December 17, 2008: Message edited by: Harvinder Thakur ]

[Harvinder Thakur]

Originally posted by Edmen Tay:

List<? super AA> lst1 = new ArrayList<AA>();//lst1 can contain AA,BB,CC,DD and unknown type that is super type of AA
List<? super BB> lst2 = new ArrayList<BB>();//lst2 can contain BB,CC,DD and unknown type that is super type of BB
List<? super CC> lst3 = new ArrayList<BB>();//lst3 can contain CC,DD and unknown type that is super type of CC
List<? super DD> lst4 = new ArrayList<CC>();//lst4 can contain DD and unknown type that is super type of DD

<? super AA> implies that lst1 can be *assigned* AA or its SuperType. BUT, you can only add AA or it's SubTypes to lst1 because that is the only addition which guarantees typesafety and therefore the compiler gives thumbs up.

<? extends AA> implies that the list can be *assigned* AA or its SubTypes. BUT, you can add nothing to it since if you were allowed to add an object to it then the typesafety boasted to be given by Generics will be GONE! So, consider it that adding generics to the java programming language had to bring about such vagaries and complications just to make your code typesafe.

[Himalay Majumdar]

I dont want to sound silly. Looking at your post i feel <? extends AA> should do wat <? super AA> is doing. And there should be nohing like <?super AA> existing.

[Harvinder Thakur]

Originally posted by Himalay Majumdar:

I dont want to sound silly. Looking at your post i feel <? extends AA> should do wat <? super AA> is doing. And there should be nohing like <?super AA> existing

Well, huh.... :roll: IMHO <? extends> and <? super > are opposites of each other. If your current state of understanding has got to do with how i have explained the concept then i would request you to quote the portion of my post causing the misunderstanding.
Also, I think the best thing would be for you guys to go through the generics tutorial once. Here is the Generics Link

[Himalay Majumdar]

<? super AA> implies that lst1 can be *assigned* AA or its SuperType. BUT, you can only add AA or it's SubTypes to lst1 because that is the only addition which guarantees typesafety and therefore the compiler gives thumbs up.

<? extends AA> implies that the list can be *assigned* AA or its SubTypes. BUT, you can add nothing to it since if you were allowed to add an object to it then the typesafety boasted to be given by Generics will be GONE! So, consider it that adding generics to the java programming language had to bring about such vagaries and complications just to make your code typesafe.

The above highlighted statements made me say. <? super AA> is doing what <? extends AA> should do

But You are right, I actually jumped into the topic without knowing much about generics. Thanks for the link
[ December 17, 2008: Message edited by: Himalay Majumdar ]