I have this scenario, but why java is not respecting the class hierarchy?
import ... public class GenericsTest { public static void main(String[] args) { List<Integer> myList = new ArrayList<Integer>(); myList.add(1); myList.add(new Integer(2)); new GenericsTest().doInsert(myList); } private void doInsert(List<? extends Number> myList) { // Number <- Integer myList.add(new Integer(1)); // This don't compiles } } Can someone explains this? Thanks!!!
The wildcard in generics does not mean "anything" it means "I don't know." So List<? extends Number> is not "a list that can hold anything that extends number." It is "A list of something that extends number, but I don't know what they are." So it's illegal to add an Integer to it, because you don't know if Integer is the thing that extends number that this is a list of. A list of anything that extends Number is just List<Number>.
List<Number> list = new ArrayList<Number>(); list.add(Integer.valueOf(1));List is always a List<Integer> in this program, the compiler can't just analyze your code and assume that. It has to create code that is valid for all possible uses of the doInsert(List<? extends Number> myList) method signature.Imagine what would happen with the following code, if the code you provided was legal:
List<Double> listDouble = new ArrayList<Double>(); doInsert(listDouble); Double d = listDouble.get(0); //ClassCastException! The compiler adds an implicit cast at the last line. This cast fails at runtime, and this breaks the type safety guarantee of generics, because the compiler didn't save you from ruining the list contents and your data type assumptions. It was supposed to hold only Double values, but an integer found a way inside.
Your options:
doInsert(List<? extends Number> myList) Allows iterating over Numbers, but not adding to the collection. Accepts list defined on any subtype of Number.
doInsert(List<Number> myList) Allows iterating and modifying, but only accepts lists defined exactly as List<Number>.
doInsert(List<? super Number> myList) Allows iterating over the items (as Object), and allows adding any kind of Number. Accepts only lists of Number of its ancestors (what makes it practically useless in this case).
The reason this will not work is because the type of the referenced List does not have to be a integer. However, the following will compile.
private void doInsert(List<Number> myList) { myList.add(new Integer(1)); } Along with:
private void doInsert(List<? extends Number> myList) { ((List<Number>)myList).add(new Integer(1)); } Ive appended this answer based on the comment from @Eyal Schneider to show that the second way listed does work if you set it up correctly. Though it is most likely not a good thing to do.
public class Test{ public void doInsert(List<? extends Number> myList) { ((List<Number>)myList).add(new Integer(1)); ((List<Number>)myList).add(new Short("2")); ((List<Number>)myList).add(new BigDecimal("3")); ... } public static void main(String[] args){ Test t=new Test(); List<Number> list=new ArrayList<Number>(); t.doInsert(list); for(Number number:list) System.out.println(number); } } Consider the following counter example, assuming it was acceptable:
public class GenericsTest { public static void main(String[] args) { List<Integer> myList = new ArrayList<Integer>(); myList.add(1); myList.add(new Integer(2)); List<Integer> myDoubleList = new ArrayList<Double>(); myList.add(1.0); myList.add(new Double(2)); new GenericsTest().doInsert(myList); // Here you're trying to add an Integer into a List<Double> } private void doInsert(List<? extends Number> myList) { // Number <- Integer myList.add(new Integer(1)); // This don't compiles } } 
Integerinto a list ofImaginaryNumbers?doInsert(new ArrayList<Short>()), for example.