Understanding of ? extends T and ? super T in Java

? Wildcard type

<? extends T> represents the upper bound of the type, indicating that the parameterized type may be T or a subclass of T;
<? super T> represents the lower bound of type (called supertype limitation in Java Core), indicating that the parameterized type is the supertype of this type (parent type) until Object;

Upper boundary`<? extends T>`Can't save it inside, can only take it outside

For example, we now define:List<? extends T>First of all, it's easy for youmisunderstandingIt is a collection of all classes inherited from T. You may think that the List you defined can be used to put any subclass of T. So let's look at the following code:

import java.util.LinkedList;
import java.util.List;

public class test {
    public static void main(String[] args) {
        List<? extends Father> list = new LinkedList<>();
        list.add(new Son());
    }
}
class Human{
}
class Father extends Human{
}
class Son extends Father{
}
class LeiFeng extends Father {
}

(new Son()); This line will report an error:The method put(Son) is undefined for the type List<capture#1-of ? extends Father>

List<? extends Father>Indicates "having any list of types inherited from Son", the compiler cannot determine the type held by the List, so it is impossible to safely add objects to it. null can be added because null can represent any type. Therefore, the add method of List cannot add any meaningful elements, but can accept existing subtype List assignments.

You might try to do this:

List<? extends Father> list = new LinkedList<Son>();
list.add(new Son());

Even if you specify that it is Son type, you cannot add a Son object using the add method.

Why can't Father class and subclasses of Father class be added in the list? Let's analyze it.

List<? extends Father>It means that the upper limit is Father, and the following assignments are all legal

   List<? extends Father> list1 = new ArrayList<Father>();
   List<? extends Father> list2 = new ArrayList<Son>();
   List<? extends Father> list3 = new ArrayList<LeiFeng>();

ifList<? extends Father>If you support the add method:

list1 can add Father and all Father subclasses;
list2 can add Son and all subclasses of Son;
list3 can add LeiFeng and all subclasses of LeiFeng.

The following code does not compile:

list1.add(new Father());//error
list1.add(new Son());//error

The reason is that the compiler only knows that there is Father or its derived class in the container, but it does not know what type it is. Maybe it's Father? Maybe it's Son? Maybe it is LeiFeng, XiaoMing? After the compiler sees that the value is assigned with Father, the parameter type in the collection is not limited to "Father". Instead, it is marked with a placeholder: CAP#1 to represent the capture of a Father or a subclass of Father. I don't know what kind of class it is, the code is CAP#1. Then no matter whether you want to insert Son, LeiFeng, or Father compiler into it, you don't know if it can match this CAP#1, so it's not allowed.

So wildcard<?>The difference between it and type parameters is that for the compiler, all Ts represent the same type. For example, in the following generic method, all three Ts refer to the same type, either String or Integer.

public <T> List<T> fill(T... t);

But wildcard<?>Without such constraints,List<?>Simply, it means: I don’t know what it is when I put something in the collection.

So here's the error,List<? extends Father>Nothing can be put in.

List<? extends Father> listAdd cannot be performed, but this form is still very useful. Although the add method cannot be used, a Season can specify a different type during initialization. for example:

List<? extends Father> list1 = getFatherList();//getFatherList method will return a list of Father's subclass

In addition, since we have ensured that the Father class or a subclass in List is stored in the Father class, you can directly obtain the value using the get method:

List<? extends Father> list1 = new ArrayList<>();
Father father = list1.get(0);//The things you read can only be stored in Father or its base class.
Object object = list1.get(0);//The things you read can only be stored in Father or its base class.
Human human = list1.get(0);//The things you read can only be stored in Father or its base class.
Son son = (Son)list1.get(0);

The lower bound <? super T> does not affect the inward storage, but the outward acquisition can only be placed in the Object object.

The lower bound is declared with super, indicating that the parameterized type may be the specified type, or the parent type of this type until the Object.

//Super can only add Father and Father subclasses, cannot add Father's parent class, and the read things can only be stored in the Object class
List<? super Father> list = new ArrayList<>();
list.add(new Father());
list.add(new Human());//compile error 
list.add(new Son());
Father person1 = list.get(0);//compile error 
Son son = list.get(0);//compile error 
Object object1 = list.get(0);

Because the lower bound stipulates the lower limit of the minimum granularity of an element, it actually relaxes the type control of the container element. Since elements are Father's base class, it is OK to store granularity smaller than Father. For type safety considerations, we can join Father objects or any of its subclasses (such as Son) objects, but since the compiler does not know which superclass of Father content is, it is not allowed to join any specific superclasses (such as Human). When we read, the compiler can only return an Object object without knowing what type it is, because Object is the final ancestor class of any Java class. But in this way, all the element type information will be lost.

PECS Principles

Finally, let’s take a look at what the PECS (Producer Extends Consumer Super) principle is, and it is easy to understand:

If you frequently read content out, it is suitable to use the upper bound Extends.
It is often inserted in, and is suitable for use with the lower bound Super.

Summarize

extends can be used for return type limitations, but cannot be used for parameter type limitations (in other words:? extends xxx can only be used for method return type limitations. jdk can determine that the minimum inheritance boundary of this class is xxx. As long as the parent class of this class can receive it, but the passed parameters cannot determine the specific type, and can only accept null's incoming).
super can be used for parameter type limitation, but cannot be used for return type limitation (in other words:? super xxx can only be used for method parameters, because jdk can determine the subclass passed into xxx, and return can only be received with the Object class).
? It cannot be used for method parameters passing in, nor for method return.