Java Generics: Wildcard capture misunderstanding

Admin 1
Viewed 8896

Reading the Java online tutorial I haven't understand anything about wildcard capture. For example:

    import java.util.List;
    public class WildcardError {
     void foo(List<?> i) {
      i.set(0, i.get(0));
     }
    }

Why the compiler can't retain the assignment safe?

It knows that, by executing for instance, the method with an Integer List, it gets from i.get an Integer value. So it try to set an Integer value at index 0 to the same Integer list (i).

So, what's wrong? Why write Wildcard helper?

wildcard generics java
7 Answers

According to Get-Put principle:

  1. If you have extends wildcard as in List<? extends Something>, then:

    1A. You can get from the structure using Something or its superclass reference. 

    void foo(List<? extends Number> nums) {
   Number number = nums.get(0); 
   Object number = nums.get(0); // superclass reference also works.
}

    1B. You cannot add anything to the structure (except null).

    void foo(List<? extends Number> nums) {
   nums.add(1); Compile error
   nums.add(1L); Compile error
   nums.add(null); // only null is allowed.
}

  2. Similarly, if you have super wildcard as in List<? super Something>, then:

    2A. You can add to the structure which is Something or its subclass. For eg:

    void foo(List<? super Number> nums) {
    nums.add(1); // Integer is a subclass of Number
    nums.add(1L); // Long is a subclass of Number
    nums.add("str"); // Compile error: String is not subclass of Number         
}

    2A. You cannot get from the structure (except via Object reference). For eg:

    void foo(List<? super Integer> nums) {
    Integer num = nums.get(0); // Compile error
    Number num = nums.get(0); // Compile error
    Object num = nums.get(0); // Only get via Object reference is allowed.        
}

Coming back to OP's question, List<?> i is just the short representation for List<? extends Object> i. And since it's a extends wildcard, the set operation fails.

The final piece remaining is WHY the operation fails ? Or why the Get-Put principle in the first place? - This has to do with type safety as answered by Jon Skeet here.

user_52559350

Solution Will Be,

import java.util.List;

    public class WildcardError {

    private void fooHelper(List<T> i){
         i.set(0, i.get(0));
    }
    public void foo(List<?> i){
         fooHelper(i);
    }
}

here fooHelper will capture type T of wildcard ? (so as the name wildcard capture).

user_40397500

I think you misunderstand the ? in Generics. It isn't "wildcard capture" at runtime. It is "wildcard capture" at compile time. Since that capture is gone after compilation, the List<?> often becomes List<Object> or a list of some interface or common base class that is the lowest subclass that is shared amongst the instances according to the Generics type.

Because Java had to make the Generics system compatible with non-Generics supporting JVMs, there are no Generics types at runtime. This means that all checks / captures don't exist at runtime. Either the compiler permits a very narrow range of compatible Generics type assignments when it compiles, or it throws an error.

Now if you want to hold a Generics type at runtime, there are approaches. Most of them involve passing the Class object as a parameter into a constructor, which holds it in a field. Then you can refer to the field for the exact passed type. You can entangle this type with your Generics parameters; and by doing so, you can then have the actual type in places in the runtime code where the "Generics type parameters" have been replaced by their most permissive type supported in the real Java type system. I don't recommend doing this for many situations, as it is a lot of work (and not likely to give you much more security); but, occasionally you really do need the type.

user_3021390

I guess your misunderstanding of the restriction comes from substitution of ? for any type, Object or something like that in your mind. But that assumption is not correct, ? in fact means unknown type. So in the following line

fooz.set(0, foo);

you're trying to assign the variable of some type to the variable of unknown type (since the function signature is like void set(int, ?)), which can never be possible, whatever the type of foo would be. In your case the type of foo is Object and you cannot assign it to a variable of some unknown type, which in fact may be Foo, Bar or any other.

user_102036940
Related