Why Does Multiple Wildcards on Generic Methods in Java Lead to Confusion?

Multiple Wildcards on Generic Methods: A Java Compiler Puzzle

Introduction

In Java generics, wildcards (*) represent unknown types. When multiple wildcards are used on generic methods, it can lead to confusion and unexpected behavior. This article examines the complexities of multiple wildcards and their impact on Java's type safety.

The Confusion

Consider the following code:

public class TwoListsOfUnknowns {
    static void doNothing(List<?> list1, List<?> list2) { }

    public static void main(String[] args) {
        List<String> list1 = null;
        List<Integer> list2 = null;
        doNothing(list1, list2); // compiles fine!
    }
}

The two wildcards in doNothing appear to be unrelated, allowing you to call it with a List and a List. However, the following addition to the method gives a compilation error:

static void doSomethingIllegal(List<?> list1, List<?> list2) {
    list1.addAll(list2); // DOES NOT COMPILE!!!
}

This suggests that while list1 and list2 can be different types, they may have some connection that prevents direct usage.

The Nested Wildcards Confusion

Further investigation reveals that the confusion lies not in multiple wildcards, but in nested wildcards:

public class LOLUnknowns1 {
    static void probablyIllegal(List<List<?>> lol, List<?> list) {
        lol.add(list); // this compiles!! how come???
    }
}

This code compiles without error, even though list could be a different type than lol's elements. However, it's important to note that this scenario raises questions about type safety.

The Truth: Capture Conversion

The confusion arises from a concept called capture conversion. It allows certain wildcards to capture specific types when used in generic methods. This is why the following variation of probablyIllegal compiles:

static void probablyIllegalAgain(List<List<? extends Number>> lol, List<? extends Number> list) {
    lol.add(list); // compiles fine!!! how come???
}

Here, the wildcard in lol can capture a type that extends Number, such as List or List. This means that probablyIllegalAgain can accept arguments that are both lists of numbers.

Understanding Nested Wildcards

The key takeaway is that multiple wildcards themselves are not problematic. The confusion arises when attempting to use a nested wildcard to capture a type that is not 'compatible' due to type variance.

In the case of LOLUnknowns1, the nested wildcard in List> cannot capture a specific type because the capture would not be safe for all possible element types of lol. This is why list can be of any type, leading to potential type safety issues.

Conclusion

Multiple wildcards on generic methods can be confusing, but understanding capture conversion and its limitations is crucial. Nested wildcards require careful consideration to ensure type safety. By adhering to these principles, you can navigate the intricacies of Java generics and write robust code.

The above is the detailed content of Why Does Multiple Wildcards on Generic Methods in Java Lead to Confusion?. For more information, please follow other related articles on the PHP Chinese website!