浅谈Java中的桥接方法与泛型的逆变和协变

泛型的协变和逆变是什么？对应于Java当中，协变对应的就是<? extends XXX>，而逆变对应的就是<? super XXX>。

1. 泛型的协变

1.1 泛型协变的使用

当我们有一个有方法，方法的签名定义成为如下的方式

public static void test(List<Number> list)

这时，如果我们想要给test方法传入一个List<Double>或者是List<Integer>可以吗？很显然不行，因为传递参数，肯定是要传递它的子类才行，但是List<Double>或者是List<Integer>是它的子类吗？很明显不是，这时我们就需要用到泛型的协变。

我们将方法的参数变成如下的这种形式

public static void test(List<? extends Number> list)

这时，我们的泛型，就只需要传入一个是Number的子类型的泛型即可。因为Integer和Double，它们都是Number的子类，因此很明显是合法的。

test(new ArrayList<Integer>());
test(new ArrayList<Double>());

在test方法中：

• 1.如果我们想要去获取集合当中的某个元素时，因为约定了元素的所有类型都得是Number类型极其子类的，因此我们获取的元素一定可以用它们的共同父类Number去进行接收。
• 2.但是当我们想要往集合当中添加元素时，竟然无法往list当中添加元素？奇奇怪怪的！而且关键我们的list，只要求元素的类型是Number或者它的子类类型。但是我们加入的是1，是个Intger类型，很明显是符合规范的呀！

    public static void test(List<? extends Number> list) {
        Number number = list.get(0);  // right
        list.add(1); // error
    }

1.2 泛型协变存在的问题

泛型的协变，不能让我们往集合当中添加元素。那么为什么不能添加呢？

要知道为什么，我们首先需要了解Java当中桥接方法的来由。

1.2.1 Java当中桥接方法的来由

我们首先定义如下的自定义ArrayList类，并重写了它的add方法，

public class MyArrayList extends ArrayList<Double> {

    @Override
    public boolean add(Double e) {
        return super.add(e);
    }
}

首先，我们肯定知道ArrayList类中的add方法的原型是下面这样的

public boolean add(E e) 

在Java当中，是在编译时去进行类型擦除的，在运行时并无泛型类型一说。也就是说，该原型方法，会被抹掉成为

public boolean add(Object e) 

但是，我们定义了自己的ArrayList，我们自己的add方法的原型为

public boolean add(Double e) 

这个两个方法的签名并不相同，但是当使用下的代码创建一个ArrayList时：

ArrayList<Double> list = new MyArrayList();
list.add(1.0);

它实际调用的方法的原型是public boolean add(Object e)，但是我们子类中的重写的方法的原型时什么？public booleab add(Double e)。

也就是说，通过父类的方法调用的和子类重写的方法，并不是同一个方法，因为它们连方法签名都不同。这时候，就需要要一个方式，将public booleab add(Object e)转到public booleab add(Double e)当中去执行。这时候，就会涉及到桥接方法的存在了。

Java的实现方式是：通过在Javac编译器编译时，为我们生成一个public boolean add(Object e)这样的方法，而这个方法当中，要做的实际上就是调用public booleab add(Double e)这个方法。

    public boolean add(Object o) {
        return add((Double) o);
    }

通过桥接方法的方式，就可以让我们能在针对泛型方法进行重写时，可以被JVM执行到。

1.2.2 为什么泛型协变时，不允许添加元素呢

当我们使用下面的代码创建了一个我们自定义的MyArrayList对象。

ArrayList<Double> list = new MyArrayList();

这时，我们调用test方法

test(list)

test方法对于list的泛型定义为<? entends Number>，理论上应该是可以往里面放入任何Number子类类型的元素的。但是别忘了，我们MyArrayList中对于方法的定义，是下面这样子的！

public boolean add(Object e) {
    return add((Double)e);
}

public boolean add(Double e)  {
    // ......
}

如果我们往集合当中添加一个Integer类型的1，走到桥接方法当中时会有(Double)e这样的强制类型转换，这不就是抛出了ClassCastException异常了吗？很明显，是不允许我们这样干的。因此Java的做法就是，在编译期就去禁止这种做法，避免产生运行时的ClassCastException。

有的人也许会说

ArrayList<Double> list = new MyArrayList();

我们创建list时，不是约束了泛型类型为Double了吗，为什么test方法内就不能默认它是Double的泛型呢？问题就是：我写test方法时，我怎么知道你传递的是Double类型的泛型，玩意别人传递的是Integer的泛型呢？所以很明显是行不通的。

1.2.3 从Java字节码的角度去看桥接方法

我们可以看到，Javac编译器，在对Java代码进行编译时，其实针对add方法去生成了两个方法，而它们的访问标识符并不相同。我们自己的方法的访问标识符为0x0001[public]，而Javac编译器为我们生成的桥接方法的返回值，为0x1041[pubic synthetic bridge]，多了两个访问标识符synthetic和bridge。

我们打开桥接方法的code字节码

我们来分析下字节码

• 1.aload_0，众所周知，就是从LocalVariableTable(局部变量表)获取this对象的引用，并压栈。
• 2.aload_1，自然就是将传入的元素e的引用压栈。
• 3.checkcast #3 <java/lang/Double>，自然是检查能否执行强制类型转换。
• 4.invokevirtual #4 <com/wanna/generics/java/MyArrayList.add : (Ljava/lang/Double;)Z>，做到实际上就是从常量池的4号元素当中拿到要执行的方法，也就是我们自己实现的方法。invokevirtual就是执行目标方法，没毛病。
• 5.ireturn，自然就是返回一个int类型的值，为什么是int类型？而不是boolean类型？因为Java当中，在存放到局部变量表和栈中的情况下，int/byte/boolean/char，都是使用的int的形式存放的，占用一个局部变量表的槽位。

我们通过分析得到的信息和我们之前的分析一致，就是通过桥接方法桥接一下，去调用我们自己实现的方法。我们接下来，尝试使用反射的方式去获取到add方法有几个，方法信息是什么。

        Arrays.stream(MyArrayList.class.getMethods()).filter(method -> method.getName().equals("add") && method.getParameterCount() == 1).forEach(method -> {
            System.out.printf("方法名为：%s，方法的返回值类型为：%s，方法的参数列表为：%s%n",
                    method.getName(), method.getReturnType(), Arrays.toString(method.getParameterTypes()));
        });

代码的最终执行结果为

方法名为：add，方法的返回值类型为：boolean，方法的参数列表为：[class java.lang.Double]
方法名为：add，方法的返回值类型为：boolean，方法的参数列表为：[class java.lang.Object]

也就是说，生成的桥接方法，是我们可以通过反射拿到的，它是一个真实的方法。

通过反射拿到Method之后，我们还可以通过访问标识符判断该方法是否是桥接方法。

method.isBridge() 
method.isSynthetic()

判断桥接方法，实际上，在spring框架当中的反射工具类(ReflectionUtils)当中就有用到，用来判断一个方法是否是用户定义的方法。

2. 泛型逆变

2.1 泛型逆变的使用

泛型逆变的泛型形式是：<? super XXX>，它的作用是赋值给它的约束容器的泛型类型，只能是XXX以及它的父类。

那么我们可以往容器里放入它的子类吗？也许会说，上面不是都说了需要放入的是XXX以及它的父类吗，那肯定是不能放入它的子类的呀！但是我们需要想到一个问题，那就是XXX的所有子类，其实都是可以隐式转换为XXX类型，或者可以直接说，它的子类就是XXX类型。

我们依次定义三个类

    static class Person {

    }

    static class User extends Person {

    }

    static class Student extends User {

    }

接着，定义一个使用逆变的泛型参数的方法

public static void test(List<? super User> list)

上面我们说了，可以接收的容器泛型类型是User以及它的父类，也就是说，容器的泛型可以是User也基于是Person。因此，我们可以传入下面这样的容器给test方法。

 test(new ArrayList<Person>());

在test方法当中，我们可以执行下面的才做

list.add(new User()); // 放入User
list.add(new Student());  // 放入User的子类

2.2 泛型逆变会有什么问题

我们需要想想一个问题：我们使用了逆变约定了，接收的容器的泛型类型是User以及User的父类。我们往容器当中放入的元素，可以是User以及User的子类。也就是说，我们获取容器中的元素时，根本不知道是什么类型，只能用Object去接收从容器中获取的元素类型，因为只是约定了容器的泛型为User和User的父类，而Object也是它的父类，因此我们甚至可以传入一个容器类型为ArrayList<Object>，我们根本无法决定元素类型的上限，只能用Object去进行接收。

final Object object = list.get(0);

现在又有一个问题：之前协变时，会出现因为执行桥接方法时，发生类型转换异常，在逆变当中会出现这种情况吗？

我们仔细想想，接收的容器泛型类型为User以及User的父类，而可以往容器里存放的是User以及User的子类，也就是说，我们放入到容器中的元素类型，比你原来约束的类型还严格，因为："User以及User的子类"一定是"User以及User的父类"的子类。也就是说，逆变当中，并不会因为桥接方法中进行的类型导致ClassCastException，所以允许add。

3.协变与逆变-PECS原则

对于协变和逆变，有这样的一个原则：称为PECS(Producer Extends Consumer Super)。也就是说：

• 1.Extends应该用在生产者的情况，也就是要根据泛型类型去返回对象的形式。
• 2.Super应该用在消费者的情况，应该传入一个泛型类型的容器，应该利用该容器对数据进行处理，但是不能根据泛型去进行返回，如果要进行返回，只能返回Object，但是这就失去了泛型的意义。

    public static <T> void testCS(List<? super T> list) {  // Consumer Super
        list.add(...);
    }

    public static <T> T testPE(List<? extends T> list) {  // Producer Extends
        return list.get(0);
    }

到此这篇关于浅谈Java中的桥接方法与泛型的逆变和协变的文章就介绍到这了,更多相关Java桥接方法与泛型逆变协变内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！