java 不变、协变、逆变

前言

先说结论，java 的 List 是不变的，java 的 array 是协变的。java 的 list 可以通过添加通配符的方式来达到协变或者逆变的效果。

什么是不变、协变、逆变

其实，这三个概念就是看着术语比较吓人人，理解起来非常简单。因为不变、协变、逆变一定涉及父类子类以及容器类，那么，为了阐述方便，我们可以先定义如下几个类：

public class Grandpa {
}

public class Father extends Grandpa {
}

public class Son extends Father {
}

如代码所示，这三个类形成一个简单的继承关系。
那么，不变就是，Father 是 Grandpa 的子类，但是 List<Father> 和 List<Grandpa> 没有关系。Father 是 Son 的父类，但是 List<Father> 和 List<Son> 没有关系。协变就是，Father 是 Son 的父类，那么 List<Father> 也是 List<Son> 的父类。逆变就是，Father 是 Grandpa 的子类，但是 List<Father> 却是 List<Grandpa> 的父类。

初学者可能有误区，可能对协变理解的比较好，认为正常的逻辑应该是所有的容器都是协变的，即 Father 是 Son 的父类，那么 List<Father> 理应是 List<Son> 的父类。但其实是错误的。首先 java 的 List 默认是不变的，而不是协变的。其次，只有协变其实不能满足我们在生产生活中（也就是写代码的时候）的需求。

下面我们用代码示例来说明一下。

不变

java 的 List 都是不变的。具体体现在代码中，就是我们可以做如下操作：

        List<Father> fatherList1 = new ArrayList<Father>();
//        List<Father> fatherList2 = new ArrayList<Grandpa>(); // error
//        List<Father> fatherList3 = new ArrayList<Son>(); // error

其中，ArrayList<Gradpa> 和 ArrayList<Son> 都不能赋值给一个 List<Father> 对象，就体现了不变性。

协变

只有不变肯定是表达力度是不够的。比如我们想处理 List<Father> 和 List<Son>，同时，我们期望List<Son> 的处理方式跟 List<Father> 一样。那么，如果 java 中只有不变性的话，我们就得写两个方法：

                public void handle(List<Father> fathers);
                public void handle(List<Son> sons);

因为我们想让 List<Father> 和 List<Son> 的处理逻辑一样，所以这两个方法里面的逻辑也是完全一样的。而这种简单的代码复制，在编程中是要极力避免的。java 的协变可以帮我们处理这种情况。

        List<? extends Father> fatherList4 = new ArrayList<Father>(); 
        List<? extends Father> fatherList5 = new ArrayList<Son>();
//        List<? extends Father> fatherList6 = new ArrayList<Grandpa>(); // error

java 中使用 List<? extends T> 来表示协变。如上面代码所示，我们可以成功的把List<Son>赋值给List<Father>。
但是，java 的协变在带给我们处理的方便的同时，也给了我们限制。比如，我们拿到一个List<? extends Father> 我们能对这个 list 做什么呢？事实上，我们只能从这个 List 中读出 Father对象，而不能往里面写入 Father对象。因为，我们不知道运行的时候，到底这个 list 是代表 List<Father> 还是 List<Son>。如果运行时传入的是 List<Son> 那么我们是不可以往里面写入一个 Father对象的。
总结一下 java 协变，我们只可以从里面读数据，不能往里写数据。

值得注意的是，java 的 List 默认是不变的。但是java 的 Array 默认却是协变的。比如我们可以有如下代码：

        Father[] fatherArray1 = new Father[0];
        Father[] fatherArray2 = new Son[0];
//        Father[] fatherArray3 = new Grandpa[0]; // error

逆变

逆变就是协变的反义词。类似协变，我们可以有如下的代码：

        List<? super Father> fatherList7 = new ArrayList<Father>();
        List<? super Father> fatherList8 = new ArrayList<Grandpa>();
//        List<? super Father> fatherList9 = new ArrayList<Son>(); // error

java 对于逆变，使用 List<? super T>的语法来实现。其中 fatherList8的赋值成功，可以体现出逆变的特性。同样的，java 在提供了逆变这个便利性的时候，也给我们带了限制。我们上面说，协变只能从里面读数据，不能往里写数据。逆变则恰恰相反：我们只能往里面写数据，而不能从里面数数据。简单的分析一下：对于写数据，无论运行时传入的是 List<Father> 还是 List<Grandpa>我们都可以往里面安全的写入 Father 对象。而对于读，考虑如下代码：

//        Father father = fatherList8.get(0); // error

这行代码是不能编译通过的。分析的方式很类似：因为运行时候传进来的可能是List<Father> 或者 List<Grandpa>，那么我们从里面读 Father的操作就可能失败。当然，我们可以绕过这里的限制，比如我们可以从 List 里面读取一个Object 然后通过 instanceof的方式判断类型，然后进行转型。

小结

java List 是不变的，java Array是协变的。java List 可以通过 List<? extends T> 实现协变，也可以通过 List<? super T> 实现逆变。但是，对于 List<? extends T> 我们只能从里面读出 T，而不能写入 T；类似的，对于 List<? super T> 我们只能往里面安全的写入 T，但是不能读出 T 。