Java 逆变与协变

Posted 2020-10-05 DW039

最近一直忙于学习模电、数电，搞得头晕脑胀，难得今天晚上挤出一些时间来分析一下Java中的逆变、协变。Java早于C#引入逆变、协变，两者在与C#稍有不同，Java中的逆变、协变引入早于C#，故在形式没有C#直观（Google推出的基于jvm的Kotlin语音，则完全走向了C#的路线）。Java中逆变、协变，在泛型集合使用中更多些、更直观（像C#中的用法在Java中较少出现，但并非不可）。

正常泛型集合的使用

示例代码如下：

public static void main(String[] args) {
        
        ArrayList<Number> alist = new ArrayList<>();
        alist.add(new Integer(10));
        alist.add(new Float(10.12));
        
        Number n = alist.get(0);
    }

对于alist集合而言，泛型类型参数 Number 已限定其可容纳的类型。Integer/Float 类型的对象都可成功加入，并能通过get(index)获取（获取时注意类型为Number）。通过这个示例，可以看到正常泛型集合可 "存取规范的类型及其子类型对象"。

协变

如下示例代码：

public class Person {

}
public class Student extends Person{

}
public class Teacher extends Person{

}
public static void main(String[] args) { 
    ArrayList<Person> alist = new ArrayList<>(); 
    ArrayList<Student> slist = new ArrayList<>(); 
    //类型转换错误 
    alist = slist; 
}

 

在 Java 中 Person虽是Student的父类，但泛型 ArrayList<Person> 却并非 ArrayList<Student>的父类，所以 alist = slist 类型不兼容。上面程序中的目的是用 slist 替代 alist的实际功能，因此在以后使用 alist 时实际调用的应该是 slist 对应的功能。

在 Java 中要满足上述需求，应该具备2个条件：

1、放入数据时调用 alist.add(e) 要保证参数e，能转换为 slist.add(e) 中所需类型

2、获取数据时调用 alist.get(index) 的实际执行者 slist.get(index) 返回的结果能够转换为 alist 声明的Person类型

上面条件2是成立的，但条件1却并不一定成立。因 ArrayList<Person> 规范类型为Person，Student、Teacher都满足alist.add(e)的要求，却并不满足 slist.add(e)对类型必须是Student的要求。

修改代码如下：

public static void main(String[] args) {
        
        ArrayList<? extends Person> alist = new ArrayList<>(); 
        ArrayList<Student> slist = new ArrayList<>(); 
        //类型转换正常 
        alist = slist; 
        //添加数据错误
        alist.add(new Student());
        //正常
        Person p = alist.get(0);
    }

? extends Person 指明 alist 赋值的泛型集合约束类型只要是 extends Person 的就可以，因此将 ArrayList<Student> slist 赋值给 alist 满足泛型类型参数约束。

alist.add(e) 根据 ? extend Person 的定义，e只要是 Person 类型或其子类型就可满足添加条件，然而 slist 只允许 Student 类型对象加入，因此前面所说的条件1无法保证（null可以被加入，但却意义） 。

因此Java中（根据前面2个条件分析可得到该结论）使用 extends 声明的泛型或泛型集合，只能从其中取值，不能向其中添值。

extends 声明的集合只能用于从其中取出元素，可能有朋友会问“不能向其中放入值，又何来从其中取值”。看下面的代码：

public static void main(String[] args) {
        
            ArrayList<Student> slist = new ArrayList<>(); 
            slist.add(new Student());
            
            ArrayList<Teacher> tlist = new ArrayList<>(); 
            tlist.add(new Teacher());
            
            test(slist);
            test(tlist);      
    }
    private static void test(List<? extends Person> list) {
        for(Person p : list){
            System.out.println(p.toString());
        }
    }

通过上面的代码很容易发现，test方法的参数 list 在方法内部不允许添加元素（null除外）；但在 main 中却可以向 slist、tlist 中添加元素，并作为实参传递到 test 方法的调用过程中。从 test 方法的角度分析，参数 list 里面具体存放的是Person？Student？Teacher？无所谓，这里统一当作Person对象来用绝对是类型安全的。这种把 泛型约束的子类型 当作 泛型约束的父类型 来用的情况就是协变。 

逆变 

示例代码：

public static void main(String[] args) {
        ArrayList<Person> alist = new ArrayList<>(); 
        ArrayList<Student> slist = new ArrayList<>(); 
        //类型转换错误 
        slist = alist; 
    }

如上代码 意欲使用 alist 替代 slist 进行元素的存储，跟进前面的分析上面代码编译错误。

在 Java 中要满足上述需求，应该具备2个条件：

1、放入数据时调用 slist.add(e) 要保证参数e，能转换为 alist.add(e) 中所需类型

2、获取数据时调用 slist.get(index) 的实际执行者 alist.get(index) 返回的结果能够转换为 slist 声明的Student类型

上面条件1是成立的，但条件2却并不一定成立。因 ArrayList<Person> 规范类型为Person，Student、Teacher都满足alist.add(e)的要求，alist.get(index) 返回值却并一定满足 slist.get(index)返回值必须是Student类型的要求。

修改代码如下：

public static void main(String[] args) {
        ArrayList<Object> alist = new ArrayList<>();
        ArrayList<? super Person> slist = new ArrayList<>();
        // 正常
        slist = alist;
        slist.add(new Student());
        slist.add(new Teacher());
        // 错误
        slist.add(new Object());

        Object obj = slist.get(0);
    }

? super Person 指明 slist 赋值的泛型集合约束类型只要是 super Person 的就可以，因此将 ArrayList<Object> alist 赋值给 slist 满足泛型类型参数约束。

？ super Person 虽指明集合可容纳Person的父类类型（仅是有容纳能力），但 Person 的继承关系、层级并不明确（Person来自其他jar包）。因此该泛型约束对于Person的父类型并无约束能力，所以 super 禁止添加Person父类型到集合中（有能力容纳，但不允许放入），只能放入Person及其子类型。

slist.get(index)调用实际上执行的是alist.get(index)，最终返回值类型是Person？Teacher？Student？ 不得而知，所以使用 super 声明的泛型集合get返回只能为Object类型。

因此Java中（根据前面2个条件分析可得到该结论）使用 super 声明的泛型或泛型集合，只能向其中添值，不要从其中取值（取回的值均为 Object 类型，没有意义）。

同样有朋友会问 super 声明的泛型集合只放不取有何意义？看下面代码：

public static void main(String[] args) {
        ArrayList<Person> alist = new ArrayList<>(); 
        test2(alist); 
        for(Person p : alist){
            System.out.println(p.toString());
        }
    }
    
    
    public static void test2(List<? super Person> list){
        list.add(new Student());
        list.add(new Teacher());
    }

 通过上面的代码很容易发现，在 main 中 alist 有明确的类型，并作为实参传递到 test2 方法的调用过程中。从 test2 方法的角度分析，可以向集合中添加Person及其子类对象。这种把 泛型约束的父类型 当作 泛型约束的子类型 来用的情况就是逆变。 

 

说明：

Java 中使用逆变、协变的机会并不算多。如果要使用请记住：如果限定集合仅可放入值时用 super、如果要限定集合仅可取出值时用 extends、如果集合既需要放入值又要取出值时用标准泛型集合。

文章写的仓促，若有不妥请各位朋友指正。