why is this assignment not allowed in Java generic

Question

here is the code example

public static ArrayList<? extends A> get(){
   return null;
}

public static void main(String[] args){
   ArrayList<A> test=get();//not allowed
}

since A certainly is the super class of any ? extends A, why is the code snippet not allowed?

You've got it the wrong way round; `ArrayList` is assignable to `ArrayList extends A>`, but you're trying to assign an `ArrayList extends A>` to `ArrayList `. Imagine if the code is like `String s = new Object();`, which isn't allowed despite the fact that `String` satisfies `Object`. — kaya3, Feb 19 '20 at 13:17
Also your `main` is not written correctly, you did not include `String [] args`. — Nexevis, Feb 19 '20 at 13:19
@kaya3 I think my code is like `Object s=new String()` , since `Object` satisfy `? extends Object` — choxsword, Feb 19 '20 at 13:21
But it is not like you think, your code is like `String s = new Object();`. Because `ArrayList extends A>` is a supertype of `ArrayList`. — kaya3, Feb 19 '20 at 13:22
In test you could insert an `A` but the original list could actually be a `ArrayList` — Joop Eggen, Feb 19 '20 at 13:22
@kaya3 supertype? afaik, only array type in java is covariant — choxsword, Feb 19 '20 at 13:25
@JoopEggen but you couldn't put an `A` into ArrayList (? extends A) either. — choxsword, Feb 19 '20 at 13:32
Possible duplicate of https://stackoverflow.com/questions/1906677/super-e-and-extends-e-for-list — Hari Rao, Feb 19 '20 at 13:38
The original list can be a `List` with an (unknown) X that extends A. Hence an error as you would not like someone inserting a non-X object into the list. _That is all, and make a `List>` result practically useless. — Joop Eggen, Feb 19 '20 at 14:23

kaya3 · Accepted Answer · 2020-02-19T13:35:04.183

You've got it the wrong way round; ArrayList<A> is assignable to ArrayList<? extends A>, but you're trying to assign an ArrayList<? extends A> to ArrayList<A>.

In fact, List<? extends A> is a supertype of List<A>, not a subtype; using the REPL:

> List<A> list = new ArrayList<? extends A>();
Error:
unexpected type
  required: class or interface without bounds
  found:    ? extends A

> List<? extends A> list = new ArrayList<A>();
[]

So your code is like String s = new Object();, not like Object s = new String();.

OK, so why isn't List<? extends A> assignable to List<A>? The answer is in the Liskov substitution principle. A List<A> can do some things that a List<? extends A> can't do, such as .add(new A()):

> List<A> listA = new ArrayList<>();
[]

> listA.add(new A());
true

> List<? extends A> listExtendsA = new ArrayList<B>(); // B is a subclass of A
[]

> listExtendsA.add(new A());
Error:
incompatible types: A cannot be converted to capture#2 of ? extends A

This makes sense because you shouldn't be allowed to add an instance of A to a List<B>. On the other hand, List<A> is assignable to List<? extends A>, because a List<A> can do everything that a List<? extends A> can do.

Actually, a List<? extends A> can't do very much; you can't even .add(new B()), for example.

why is ` List extends A> list = new ArrayList();` allowed ? since you couldn't put `A` into the list. — choxsword, Feb 19 '20 at 13:34
You can't call `.length()` on an `Object`, either, but that doesn't mean `String` should not be assignable to `Object`; it means the opposite, `Object` should not be assignable to `String`. — kaya3, Feb 19 '20 at 13:35

why is this assignment not allowed in Java generic

1 Answers1