Covariance and Contravariance in Java

extends

The wildcard declaration of 

List<?
extends Number> foo3

 means that any of these are legal assignments:

List<? extends Number> foo3 = new ArrayList<Number>();  // Number "extends" Number (in this context)
List<? extends Number> foo3 = new ArrayList<Integer>(); // Integer extends Number
List<? extends Number> foo3 = new ArrayList<Double>();  // Double extends Number

Reading - Given the above possible assignments, what type of object are you guarenteed to read from 

List
foo3

:
You can read a 

Number

 because
any of the lists that could be assigned to 

foo3

 contain
a 

Number

 or
a subclass of 

Number

.
You can't read an 

Integer

 because 

foo3

 could
be pointing at a 

List<Double>

.
You can't read a 

Double

 because 

foo3

 could
be pointing at a 

List<Integer>

.

Writing - Given the above possible assignments, what type of object could you add to 

List
foo3

 that would be legal for all the above possible 

ArrayList

 assignments:
You can't add an 

Integer

 because 

foo3

 could
be pointing at a 

List<Double>

.
You can't add a 

Double

 because 

foo3

 could
be pointing at a 

List<Integer>

.
You can't add a 

Number

 because 

foo3

 could
be pointing at a 

List<Integer>

.

You can't add any object to 

List<?
extends T>

 because you can't guarantee what kind of 

List

 it
is really pointing to, so you can't guarantee that the object is allowed in that 

List

.
The only "guarantee" is that you can only read from it and you'll get a 

T

 or
subclass of 

T

.

super

Now consider 

List
<? super T >

.

The wildcard declaration of 

List<?
super Integer> foo3

 means that any of these are legal assignments:

List<? super Integer> foo3 = new ArrayList<Integer>();  // Integer is a "superclass" of Integer (in this context)
List<? super Integer> foo3 = new ArrayList<Number>();   // Number is a superclass of Integer
List<? super Integer> foo3 = new ArrayList<Object>();   // Object is a superclass of Integer

Reading - Given the above possible assignments, what type of object are you guaranteed to receive when you read from 

List
foo3

:
You aren't guaranteed an 

Integer

 because 

foo3

 could
be pointing at a 

List<Number>

 or 

List<Object>

.
You aren't guaranteed an 

Number

 because 

foo3

 could
be pointing at a 

List<Object>

.
The only guarantee is that you will get an instance of an 

Object

 or
subclass of 

Object

(but
you don't know what subclass).

Writing - Given the above possible assignments, what type of object could you add to 

List
foo3

 that would be legal for all the above possible 

ArrayList

 assignments:
You can add an 

Integer

 because
an 

Integer

 is
allowed in any of above lists.
You can add an instance of a subclass of 

Integer

 because
an instance of a subclass of 

Integer

 is
allowed in any of the above lists.
You can't add a 

Double

 because 

foo3

 could
be pointing at a 

ArrayList<Integer>

.
You can't add a 

Number

 because 

foo3

 could
be pointing at a 

ArrayList<Integer>

.

You can't add a 

Object

 because 

foo3

 could
be pointing at a 

ArrayList<Integer>

.

Link : http://stackoverflow.com/questions/4343202/difference-between-super-t-and-extends-t-in-java
Refer to this one for details : http://www.codeproject.com/Articles/899319/Comparing-covariance-contravariance-rules