Why method parameter and wildcard doesn't work interchangeably?

Question

I thought that parameter and wildcard placeholder roughly has same meaning, where the first one is for defining classes and methods and the second is for declaring variables. But apparently it is not the case.

import java.util.List;
import java.util.function.Consumer;

public class Main {

    public static void main(String[] args) {
        Consumer<List<? extends Number>> l1 = null;
        Consumer<List<? extends Number>> l2 = null;

        l1 = l2;    // compiles
    }

    static <T extends Number> void m(Consumer<List<T>> l) {
        Consumer<List<? extends Number>> l3 = l; // doesn't compile
    }
}

I thought that line Consumer<List<? extends Number>> l3 = l should work just as l1 = l2;. But it is not the case. Can someone explain why this sample doesn't compile and how can I workaround this.

I would use `Consumer> l2` though it's not obvious be me why this doesn't work. — Peter Lawrey, Jan 05 '18 at 14:41
The example is slightly artificial and therefore I cannot change the type of the `l3`. In my scenario it is a type of parameter of the other method. — Artem Petrov, Jan 05 '18 at 14:45
The issue is that Consumer> l can be a list of anything however, Consumer> l3 is much more specific. — John Kane, Jan 05 '18 at 14:47
@PeterLawrey you are right. This works: `Consumer> l2 = (Consumer) l;` but is there some way to make it work without creating/suppressing a warning? — Artem Petrov, Jan 05 '18 at 14:49
@ArtemPetrov this was a joke. [Don't use raw types](https://stackoverflow.com/questions/2770321/what-is-a-raw-type-and-why-shouldnt-we-use-it). — Turing85, Jan 05 '18 at 14:50
You would think, alternatively an explanation of why this is dangerous in some way. — Peter Lawrey, Jan 05 '18 at 14:50
@Turing85 I agree unless the compiler prevents you from writing sane code. ;) — Peter Lawrey, Jan 05 '18 at 14:51
`static >> void m(C c) { C c3 = c; }` - would this be satisfactory? — Turing85, Jan 05 '18 at 14:53
Workaround: `Consumer extends List extends Number>> l3 = l;` — Aniket Sahrawat, Jan 05 '18 at 14:55
@Turing85 Type of 'l3' should not be changed. In real world scenario it is type of parameter of the other method. — Artem Petrov, Jan 05 '18 at 14:55
Technically a dupe of: https://stackoverflow.com/questions/2745265 All the compiler sees is `Consumer` and `Consumer` where `T1 = List` (e.g `List`) and `T2 = List extends Number>`. Generics are invariant, so you can't assign one to the other. — Jorn Vernee, Jan 05 '18 at 14:57
`Consumer>` does not match `Consumer>`. Wildcard matching is not recursive; it only applies to the topmost level of a wildcard. — VGR, Jan 05 '18 at 16:42
@Peter You can make it compile without using a raw type, if you go *via* a raw type with a "magic double cast" (don't know if it has an agreed name) `Consumer> l3 = (Consumer>)(Consumer)l; // compiles` — Bohemian, Jan 05 '18 at 17:50
@VGR Why `Consumer> l` is treated as `Consumer>` and not as `Consumer>`? — Artem Petrov, Jan 05 '18 at 17:57
Because the compiler doesn’t know what T is, but the compiler does know that T must be a specific type. T can never be a wildcard. — VGR, Jan 05 '18 at 17:59

score 0 · Answer 1 · answered Jan 20 '18 at 21:00

Consumer<List<T>> is not a subtype of Consumer<List<? extends Number>> even though List<T> is a subtype of List<? extends Number>, in the same way that Foo<Dog> is not a subtype of Foo<Animal> even though Dog is a subtype of Animal.

Generic type parameters are invariant, meaning that (unless you have a wildcard at the top level) they must match exactly. If you want it to be compatible with different type parameters, you must have a wildcard at the top level, like this:

Consumer<? extends List<? extends Number>> l3 = l;

Or you can just declare your method as

static void m(Consumer<? extends List<? extends Number>> l3)

and it will accept all the arguments that it accepted before.

(However, I want to point out that your method as declared with Consumer doesn't really make any sense. Your method is generic on T, and it takes in a consumer which takes in a List<T>. There is almost no way for your method to use this consumer, because your method would have to pass it a List<T>, but your method has no idea what T is, and it has no other arguments of type T or any other way to figure out what T is or get a List<T>, so the only thing it can safely pass in is an empty list. So the only way your method can use this consumer is to pass it an empty list, which is probably not very useful.)

Why method parameter and wildcard doesn't work interchangeably?

1 Answers1