Java 泛型：泛型通配符-修改中...

清疚 2024-04-18 14:23 137阅读 0赞

**目录**

一、为什么使用通配符？

二、通配符类型详解

1、无边界的通配符

2、有边界的通配符——协变和逆变

2.1固定上边界通配符——extends协变（生产者）

2.2固定下边界通配符——super逆变（消费者）

三、数组的协变

四、自限定与协变

1、协变的参数类型

2、协变的返回类型

--------------------

## 一、为什么使用通配符？ ##

Java 泛型本身不支持型变（协变和逆变），因此引入通配符来解决泛型类型的类型转换问题。

在 Java 中，数组是可以协变的，比如Dog extends Animal，那么Animal\[\]与Dog\[\]就是兼容的。而集合是不能协变的，也就是说List<Animal>不是List<Dog>的父类，那么为了建立两个集合之间的联系，就需要用到通配符。

**使用通配符的好处：**

在保证运行时类型安全的基础上，提高参数类型的灵活性。

## 二、通配符类型详解 ##

### 1、无边界的通配符 ###

无边界的通配符（Unbounded Wildcards），就是<?>，比如List<?>

无边界的通配符的主要作用就是让泛型能够接收未知类型的数据。

但是我们不能对List<?>使用add()方法，仅有一个例外就是add(null)

**代码演示：**

public static void addTest(List<?> list){
            Object obj = new Object();
            // list.add(obj); // 编译报错
            // list.add(1); // 编译报错
            // list.add("ABC"); // 编译报错
            list.add(null);
        }

因为我们不能确定该List的类型，不知道add什么类型的数据才对，只有null是所有引用数据类型都具有的元素。

List<?>也不能使用get方法，只有Object类型是个例外

**代码演示：**

public static void addTest(List<?> list){
            // String s = list.get(0); // 编译报错
            // Integer i = list.get(1); // 编译报错
            Object obj = list.get(2); // OK
        }

因为我们不知道传入的List是什么类型的，所以无法接收得到的get，但是Object是所有数据类型的父类，所以只有接收它可以。

### 2、有边界的通配符——协变和逆变 ###

**协变和逆变：**

假设F(X)代表java中的一种代码模式，其中X为此模式中可变的部分。如果B是A的派生类，而F(B)也享受F(A)派生类的待遇，那么F模式是协变的。

如果F(A)反过来享受F(B)派生类的待遇，那么F模式是逆变的。

如果F(A)和F(B)之间不享受任何继承待遇，那么F模式是不变的。（这里的继承待遇指的是“如果B类是A类的派生类，那么B类的引用可以赋值给A类的引用。”）

Java中绝大部分代码模式都是不变的（哈哈。。。大家可以安心了）。

#### 2.1固定上边界通配符——extends协变（生产者） ####

**只出不进：**可以从里边取东西，但是不能放东西。如List<? extends E>不能使用add()方法

**代码示例：**

public class DemoTest {
        public static void main(String[] args) {
            List<String> list1 = new ArrayList<>();
            list1.add("hello world");
            // List<Object> list2 = list1;// 编译错误
            List<? extends Object> list3 = list1; // 编译通过，但是只允许读不允许写
            // list3.add(new Object());// 编译报错，不允许写
            Object obj = list3.get(0);// 允许读
            String str = (String) list3.get(0);// 知道具体类型还可以进行强转
        }
    }

上述示例中，List<String> 和 List<Object>之间是没有任何关系的，因此直接赋值编译器会报错。为了建立两个集合之间的联系，引入了通配符，这种形式是允许的List<? extends Object> list3 = list1；但这形式的结合，只允许从集合中读取数据（可以使用get()），而不允许从集合中写入数据（不能使用add()）

不能写数据：list1是窄范围类型，list3是宽范围类型，为了保持类型的正确性，是不允许宽范围类型去添加数据的，因为不知道list3会添加什么类型的数据，如果是Integer数据，那么便不能放入String数据的集合（类型安全问题）

可以读数据：String类型也是Object类型的派生类，此时通过Object去取数据，不会发生任何类型安全问题。

#### 2.2固定下边界通配符——super逆变（消费者） ####

**只进不出：**可以从里边放东西，但不能取东西。如List<? super E>不能使用get()方法

**代码示例：**

public class DemoTest {
        public static void main(String[] args) {
            List<Number> list1 = new ArrayList<>();
            // List<Integer> list2 = list1; // 编译错误，在不使用通配符的情况下，是不允许的
            List<? super Integer> list3 = list1; // 编译通过
            list3.add(22); // 可以往集合中添加Integer数据
            // list3.add(2.2); // 编译报错，限定了只能添加Integer
            // list3.add(false);// 编译报错，限定了只能添加Integer
            // Integer integer = list3.get(0);// 编译报错，不能用Integer接收数据
            Object object = list3.get(0);// 这样是可以的，但是意义不大
        }
    }

不能读数据：因为类型擦除，编译器并不知道数据的确切类型是什么，可能是Integer，可能是Number，也可能是Object，所以取出来的具体是什么数据不清楚，因此当使用具体类型去接收时，编译器会报错。

但是如果是一个确定的类型，当做Object取出来，而且你又无法判断它是什么，其实是没有多大意义的。

可以写数据：只能往集合中添加Integer类型的数据，因为集合一定是Integer或其父类类型的，所以不会存在类型安全问题。

## 三、数组的协变 ##

java中数组是协变的，可以向子类型的数组赋予基类型的数组引用（Number\[\] num = new Integer\[10\]）；由于数组在java中是完全定义的，因此内建了编译期和运行时的检查，具体参见如下代码示例。

**代码示例：**

public class Fruit {}
    public class Apple extends Fruit {}
    public class Jonathan extends Apple {}
    public class Orange extends Fruit {}

**以下情况是被允许的：**

1、将子类数组赋值给父类数组的引用

2、将子类对象放置到父类数组中

public class DemoTest {
        public static void main(String[] args) {
            // 创建一个Apple数组，并赋值给一个Fruit数组的引用，编译期和运行时都允许
            Fruit[] fruits = new Apple[10];
            // 将子类对象放置到父类数组中，编译期和运行时都允许
            fruits[0] = new Apple();
            fruits[1] = new Jonathan();
        }
    }

**但是，下边的情况是不被允许的：**

1、将父类对象放置到子类数组中（类型超限制）

2、将兄弟对象放置到数组中（不属于同一具体类型）

public class DemoTest {
        public static void main(String[] args) {
            // 创建一个Apple数组，并赋值给一个Fruit数组的引用，编译期和运行时都允许
            Fruit[] fruits = new Apple[10];
            // 将Apple的父类对象放置到子类数组中，编译期允许，但运行会抛出异常
            fruits[2] = new Fruit(); // 这个数组还是Apple数组
            // 将Apple的兄弟对象放置到数组中，编译期允许，但是运行时抛出异常
            fruits[3] = new Orange();
        }
    }

上边两种情况，均会抛出数据存储异常：

![20190908102757830.png][]

## 四、自限定与协变 ##

### 1、协变的参数类型 ###

在非泛型代码中（不使用泛型），参数类型不能随子类型发生变化，方法只能重载不能重写。

**代码示例：**

// 不使用泛型的父类情况
    public class Base {
        Object element;
        Object get(){
            return element;
        }
        // 参数类型不能随子类型发生变化，它固定是Object
        void set(Object obj){
            element = obj;
        }
    }
    
    // 不使用泛型的继承
    public class Child extends Base {
        Child child;
        // 这个是重载，不是重写，参数类型不一样
        void set(Child child){
            this.child = child;
        }
    }

常见的自限定写法（使用泛型）：定义一个父类，这个父类能够使用子类作为其参数、返回类型、作用域。

**代码示例：**

public class Base<T extends Base<T>> {
        // 用子类作为全局作用域
        T element;
        // 使用子类作为返回类型
        T get(){
            return element;
        }
        // 使用子类作为方法参数
        void set(T t){
            element = t;
        }
    }

在使用自限定类型时，方法可以进行重写，但只能接收子类型而不是父类型作为参数。

**示例代码：**

// 使用泛型的继承
    public class Child extends Base<Child> {
        // 这就是重写了
        @Override
        public void set(Child child) {
            super.set(child);
        }
    
        public void test(Child child,Child isChild,Base isBase){
            child.set(isChild); // 编译通过
            // 只能接收具体的子类型isChild，不能接收父类型isBase
            child.set(isBase);// 编译错误
        }
    }

### 2、协变的返回类型 ###

继承自限定父类的子类，将产生确切的子类型作为其返回值。

**代码示例：**

// 使用泛型的继承
    public class Child extends Base<Child> {
        public void test(Child ischild){
            // 产生确切的子类型作为其返回值 Child类型
            Child child = ischild.get();
            // 使用多态，父类也可以接收
            Base base = ischild.get();
        }
    }

至此，本文介绍结束。

[20190908102757830.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/830500143fce4edaaf30b1d315d45371.png