Generics using <? extends A>,<? super A> Problem

[mohitkumar gupta]

1.

  List<? super Integer> list = new ArrayList<Integer>();
Object first = list.get(0);  

Compiles
---------------------------------------
2.

  List<? super Integer> list = new ArrayList<Integer>();
Integer first = list.get(0);  

Doesnot Compiles
-------------------------------------

3.

 List<? super Integer> list = new ArrayList<Integer>();
for (Integer element : list) {
	System.out.println(element);
}
   

Doesnot Compiles

------------------------------------------
4.

  List<? extends Integer> list = new ArrayList<Integer>();
Integer first = list.get(0);  

Complies


-------------------------------
5.

 List<? extends Integer> list = new ArrayList<Integer>();
for (Integer element : list) {
	System.out.println(element);   //complies
}   

---------------------------------------
Can anyone give me reason for each of the above code ?
whenever extends is used code complies but not when super is used
is there a reason for it ?

--------------------------

  Queue<? super Number> q1 = null;
Queue<? extends Integer> q2 = null;
q2 = q1;  

this code gives compiler error

q1 can refer to any queue of Number or its supertype
while q2 can refer to any queue of Integer or it subtype

then why the code gives compile time error

[Sudhakar Sharma]

Hi Mohit,

The Point is whenever we are asking

List<? super Integer> list = new ArrayList<Integer>();  
Object first = list.get(0); 

you are saying the compiler create an ArrayList<Integer> (of type Interger) and set it to the List<? super Integer>( list which can store Interger and yes as well as its supertype) So as you should know that, the runtime doesnot care about the type safety it uptp the compiler and compiler make a reference who can store that all elements as an Object. Therefore get method would return an Object in this case So Compiles fine.

In other case you setting it to Integer without casting.

-------------------
view plaincopy to clipboardprint?
List<? extends Integer> list = new ArrayList<Integer>();
for (Integer element : list) {
System.out.println(element); //complies
}

I think the opposite reason (ie taking ref of type <? extends Integer>, fetching from that must be an Integer ) arises here

Please Confirm

Thank You

[mohitkumar gupta]

AS Sudhakar Sharma says:
you are saying the compiler create an ArrayList<Integer> (of type Interger) and set it to the List<? super Integer>( list which can store Interger and yes as well as its supertype) So as you should know that, the runtime doesnot care about the type safety it uptp the compiler and compiler make a reference who can store that all elements as an Object. Therefore get method would return an Object in this case So Compiles fine.

ok then

    List<? super Integer> list = new ArrayList<Integer>();  
Integer first = list.get(0); //DOESNOT COMPILES  

It doesnot compiles but what about this one,
why does it compile ?

  List<? extends Integer> list = new ArrayList<Integer>();  
Integer first = list.get(0);  //COMPILES 

[Matthew Brown]

Think about what the compiler knows about the objects in the collection.

In your first example, the reference type is List<? super Integer>. It could refer to a List<Integer>, a List<Number> or a List<Object>. list.get(0) could be returning an Object, so assigning it to an Integer reference isn't safe.

In the second example, List<? extends Integer>, list could refer to a List<Integer> or a List<MySubclassOfInteger>*. So list.get(0) is guaranteed to return something that can be safely assigned to an Integer reference.

Note that if you're adding elements it works the other way around:

List<? super Integer> list = new ArrayList<Integer>();  
Integer first = list.get(0); // DOES NOT COMPILES  
list.add(new Integer(99));  // COMPILES

List<? extends Integer> list = new ArrayList<Integer>();  
Integer first = list.get(0);  // COMPILES
list.add(new Integer(99));  // DOES NOT COMPILE

* At least, it could if Integer wasn't final! But that's not relevant here.

[Sudhakar Sharma]

Hi All,

Thats what i wanted to say thank you for clear explanation.

Thanks