泛型通配符 Generic Wildcards —— ？ extends super

Generic Wildcards

1. Upper Bounded Wildcards 上限通配符

• 上限通配符 upper bounded Wildcards
• extends关键字：在上限通配符中，extends关键字是表示通常的意义，它即代表着“继承”（一个类），也代表着“实现”（一个接口）。

以下述代码中的List<Person>和List<? extends Person>为例，前者相比受到更多的约束，它只能匹配Person类，而后者除了可以匹配Person类之外，还可以匹配继承了Person的任意子类

class Person{}

class Man extends Person{}

class Woman extends Person{}

class Children extends Man{}

public class GenericTest {
    public static void main(String[] args) {

//        List<Person> list = new ArrayList<Man>(); //编译错误
        //Man是Person的子类，ArrayList是Person的子类
        //但不代表这ArrayList<Man>是List<Person>的子类


        //使用上限通配符
        //测试：上限是到Person类
        List<? extends Person> list1 = new ArrayList<Person>();
        List<? extends Person> list2 = new ArrayList<Man>();
        List<? extends Person> list3 = new ArrayList<Woman>();
        List<? extends Person> list4 = new ArrayList<Children>();

        //测试：上限是到Man类
//        List<? extends Man> list5 = new ArrayList<Person>();  //报错，不能是Man的父类
        List<? extends Man> list6 = new ArrayList<Children>();
    }
}

2. Lower Bounded Wildcards 下限通配符

• 下限通配符 Lower bounded Wildcards

    public static void main(String[] args) {
        List<? super Woman> list = null;

        List<Person> listPerson = new ArrayList<>();
        List<Man> listMan = new ArrayList<>();
        List<Woman> listWoman = new ArrayList<>();
        List<Children> listChildren = new ArrayList<>();

        list = listPerson;
//        list = listMan; //编译错误
        list = listWoman;
//        list = listChildren; //编译错误
    }

3. Unbound Wildcard 无界通配符

• 无界通配符 Unbound Wildcard 无界通配符使用?指定的类型，例如，List<?>，这被称为一个未知类型的List.

  无界通配符的原理是这样的，以List为例，它将任意的具体类型List<A>，都看做是List<?>的子类

NOTE

Object类和String类、Double类是继承关系，但List<Object>和List<String>、List<Double>不是继承关系

public void printList(List<Object> list){
    for(Object o : list){
        System.out.print(o+" ");
    }
    System.out.println();
}
@Test
public void test1(){
    List<Double> list1 = new ArrayList<>();
    list1.add(1.0);
    list1.add(3.14);
    list1.add(2.78);
//  printList(list1); //编译报错,因为List<Double>不是List<Object>的子类
}

public void printList(List<?> list){
    for(Object o : list){
        System.out.print(o+" ");
    }
    System.out.println();
}

    @Test
    public void test1(){
        List<Double> list1 = new ArrayList<>();
        list1.add(1.0);
        list1.add(3.14);
        list1.add(2.78);
        printList(list1); 
        /*Output
        1.0 3.14 2.78 
        */
    }

4.参考

https://docs.oracle.com/javase/tutorial/java/generics/index.html