【Java】java 中的泛型通配符——从“偷偷地”地改变集合元素说起

一直没注意这方面的内容，想来这也算是基础了，就写了这个笔记。

首先java的通配符共有三种————先别紧张，现在只是粗略的过一下，看不看其实无所谓

然后再让我们定义四个类，下面会用到

class A {
    public String getName() {
        return "A";
    }
}

class B extends A{
    @Override
    public String getName() {
        return "B";
    }
}

class BAge extends B{
    @Override
    public String getName() {
        return "C";
    }

    public int getAge() {
        return 100;
    }
}

class BSize extends B{
    @Override
    public String getName() {
        return "D";
    }

    public int getSize() {
        return -1;
    }
}

从一个奇怪的现象说起

1. 首先，我们再引入一个类 PrintAges ，用于打印 BAge 的 getAge()

   class PrintAges{
   public static void print(BAge[] ages){
       if (ages == null)
           return;
   
       for (BAge bage : ages){
           if (bage != null)
               System.out.println(bage.getAge());
       }
   }
   }

   仔细看看上面这个类，你觉得我写的 PrintAges 怎样？够完美吗，不会引发异常吧？我觉得也很完美了，肯定不会有异常出现在我的代码里了。

2. 我们测试下

   BAge[] temps = new BAge[]{new BAge(), new BAge()};
   PrintAges.print(temps);

输出：

100
100

完美运行。

1. 我们再增加两行

   BAge[] temps = new BAge[]{new BAge(), new BAge()};
   B[] barray = temps;  // 新增加的第一行
   barray[0] = new BSize(); // 新增加的第二行
   PrintAges.print(temps);

   你猜怎么着？我偷偷地改变了数组中的元素！我在 BAge 类型的数组中的元素赋了一个 BSize 的对象！

   而且，编译通过了。但是肯定会有异常出现，你猜是在哪一行？

输出：

Exception in thread "main" java.lang.ArrayStoreException: JavaApp.BSize at JavaApp.JavaApplicationStudyGen.main(JavaApplicationStudyGen.java:33)

本来我以为会在 PrintAges 的 print 方法中发生异常，但是实际上新增加的第二行发生了运行时错误，赋值错误。

而在C#中，这种问题出现的可能性就更小了。C#中，新增的第一行是无法通过编译的。

那么，这种问题在集合……准确地说是在泛型里会不会出现呢？

1. 上述问题在泛型中的讨论。

我们先对 PrintAges 添加一个 print 函数的重载

class PrintAges{
    public static void print(ArrayList<BAge> list) {
        if (list == null)
            return;

        for(BAge age : list) System.out.println(age.getAge());
    }
    public static void print(BAge[] ages){
        if (ages == null)
            return;

        for (BAge bage : ages){
            if (bage != null)
                System.out.println(bage.getAge());
        }
    }
}

然后我们对用再次运行如下代码：

ArrayList<BAge> list = new ArrayList<BAge>();
list.add(new BAge());
ArrayList<B> yourList = list; // 编译错误
yourList.set(0, new BSize()); // star 1
BAge age = list.get(0); // star 2
PrintAges.print(list);

这次，Java 处理的比较严格，在把 ArrayList<BAge> 赋值给 ArrayList<B> 类型的对象时产生了编译错误。

在 C# 里，也是一样的，在把 ArrayList<BAge> 赋值给 ArrayList<B> 类型的对象时会产生编译错误。

一开始，我不理解这样做对 list 引用的对象 ArrayList

但是，不能赋值的原因，把一个 BSize 类型的对象放在了一个实际上是 ArrayList

经过类型擦除之后， star 2 所在行的代码就会变成

BAge age = (BSize)list.get(0); // star 2

这样就是完全不正确的了。

也就是说，我们应该禁止类似 ArrayList<B> yourList = new ArrayList<BAge>() 这样的赋值，否则，就会出现这样的错误和意外。

说实话，B[] barray = new BAge[]{new BAge(), new BAge()} 这样的赋值操作也该被禁止的，但是 Java 就可以。看看人家 C# 就不允许这样做（笑）

记住这样的错误。接下来，我们就可以讨论 Java 的泛型通配符了。

通配符出现的原因

所以所，通配符的出现就是为了在错误避免上述错误的同时，给程序员提供一点便利。

而通配符是怎么样发生作用的呢？是通过编译器给定的三条“游戏规则”（也即是上面给的表格里的规则）发生作用的。

在一开始理解的时候是需要一点逻辑能力的：

1. 上限通配符 <? extends B> 确保了可读性， <? extends B> 表示参数类型只能是 B 或是 B 的子类 可以被编译通过的语句：

ArrayList<? extends B> list = new ArrayList<A>(); // 编译错误
ArrayList<? extends B> list = new ArrayList<B>(); // ok
ArrayList<? extends B> list = new ArrayList<BAge>(); // ok
ArrayList<? extends B> list = new ArrayList<BSize>(); // ok

基于以上的编译规则，我们可以得出以下事实：

• 你一定能从 list 中读取到一个 B 元素，因为 list 要么指向 ArrayList<B> ，要么指向包含 B 子类对象的 ArrayList<B>
• 你不能不能插入一个 B 元素 ，因为 list 可能指向的是 ArrayList<BSize> 或者指向 ArrayList<BAge>
• 你不能不能插入一个 BAge 元素 ，因为 list 可能指向的是 ArrayList<BSize>
• 你不能不能插入一个 BSize 元素 ，因为 list 可能指向的是 ArrayList<BAge>

注意，上述代码中， list 中的 T 被替换成了 ? extends B

也就是说，读取操作可以被确保，你一定能从 list 中读取到一个 B 元素 这样， list.get 方法就可以被正常使用了。

而 list.set(int, T) 就被替换成了 list.set(int, ? extends B)，这个方法就被编译器“禁止”了。也就是说，如果你写出 list.set(0, new B()) 或 list.set(0, new BSize()) 是不行的。

在这里你肯定要提出疑问了，你不是说符合“游戏规则” <? extends B> 表示参数类型只能是 B 或是 B 的子类 就行的吗？ 我只能说，文字所能传达的信息是有限的，这个表述也只适用于 ArrayList<? extends B> list = new ArrayList<A>(); 这样的赋值时刻。还是得看上述推导的“事实”

1. 下限通配符 <? super B> 确保了写入性

   ```Java

   ArrayList<? super B> list = new ArrayList