泛型（9）：通配符（上）

古城微笑少年丶 2023-07-17 06:40 77阅读 0赞

你已经看到了一些使用通配符的示例——在泛型参数表达式中的问号。本节将更深入地探讨这个问题。我们开始入手的示例要展示数组的一种特殊行为：可以向导出类型的数组赋予基类型的数组引用：

class Fruit {
    }
    
    class Apple extends Fruit {
    }
    
    class Jonathan extends Apple {
    }
    
    class Orange extends Fruit {
    }
    
    public class CovariantArrays {
    	public static void main(String[] args) {
    		Fruit[] fruit = new Apple[10];
    		fruit[0] = new Apple();
    		fruit[1] = new Jonathan();
    		try {
    			fruit[0] = new Fruit();
    		} catch (Exception e) {
    			System.out.println(e);
    		}
    		try {
    			fruit[0] = new Orange();
    		} catch (Exception e) {
    			System.out.println(e);
    		}
    	}
    }

main()中的第一行创建了一个Apple数组，并将其赋值给一个Fruit数组引用。这是有意义的，因为Apple也是一种Fruit，因此Apple数组应该也是一个Fruit数组。

但是，如果实际的数组类型是Apple\[\]，你应该只能在其中放置Apple或Apple的子类型，这在编译期和运行时都可以工作。但是请注意，编译器允许你将Fruit放置到这个数组中，这对于编译器来说是有意义的，因为它有一个Fruit\[\]引用——它有什么理由不允许将Fruit对象或者任何从Fruit继承出来的对象（例如Orange），放置到这个数组中呢？因此，在编译期，这是允许的。但是，运行时的数组机制知道它处理的是Apple\[\]，因此会在向数组中放置异构类型时抛出异常。

实际上，向上转型不适合用在这里。你真正做的是将一个数组赋值给另一个数组。数组的行为应该是它可以持有其他对象，这里只是因为我们能够向上转型而已，所以很明显，数组对象可以保留有关它们包含的对象类型的规则。就好像数组对它们持有的对象是有意识的，因此在编译期检查和运行时检查之间，你不能滥用它们。

对数组的这种赋值并不是那么可怕，因为在运行时可以发现你已经插入了不正确的类型。但是泛型的主要目标之一是将这种错误检测移入到编译期。因此当我们试图使用泛型容器来代替数组时，会发生什么呢？

import java.util.ArrayList;
    import java.util.List;
    
    public class NonCovariantGenerics {
    	List<Fruit> flist = new ArrayList<Apple>();
    }

尽管你在第一次阅读这段代码时会认为：“不能将一个Apple容器赋值给一个Fruit容器”。别忘了，泛型和容器相关正确的说法是：“不能把一个涉及Apple的泛型赋给一个涉及Fruit的泛型”。如果就像在数组的情况中一样，编译器对代码的了解足够多，可以确定所涉及到的容器，那么它可能会留下一些余地。但是它不知道任何有关这方面的信息，因此它拒绝向上转型。然而实际上这根本不是向上转型——Apple的List不是Fruit的List。Apple的List将持有Apple和Apple的子类型，而Fruit的List将持有任何类型的Fruit，诚然，这包括Apple在内，但是它不是一个Apple的List，它仍旧是Fruit的List。Apple的List在类型上不等价于Fruit的List，即使Apple是一种Fruit类型。

真正的问题是我们在谈论容器的类型，而不是容器持有的类型。与数组不同，泛型没有内建的协变类型。这是因为数组在语言中是完全定义的，因此可以内建了编译期和运行时的检查，但是在使用泛型时，编译器和运行时系统都不知道你想用类型做些什么，以及应该采用什么样的规则。

但是，有时你想要在两个类型之间建立某种类型的向上转型关系，这正是通配符所允许的：

import java.util.ArrayList;
    import java.util.List;
    
    public class GenericsAndCovariance {
    	public static void main(String[] args) {
    		List<? extends Fruit> flist = new ArrayList<Apple>();
    //		flist.add(new Apple());
    //		flist.add(new Fruit());
    //		flist.add(new Object());
    		flist.add(null);
    		Fruit f = flist.get(0);
    	}
    }

flist类型现在是List<? extends Fruit>，你可以将其读作“具有任何从Fruit继承的类型的列表”。但是，这实际上并不意味着这个List将持有任何类型的Fruit。通配符引用的是明确的类型，因此它意味着“某种flist引用没有指定的具体类型”。因此这个被赋值的List必须持有诸如Fruit或Apple这样的某种指定的类型，但是为了向上转型为flist，这个类型是什么并有人关心。

如果唯一的限制是这个List要持有某种具体的Fruit或Fruit的子类型，但是你实际上并不关系它是什么，那么你能用这样的List做什么呢？如果不知道List持有什么类型，那么你怎样才能安全地向其中添加对象呢？就像在CovariantArrays.java中向上转型数组一样，你不能，除非编译器不是运行时系统可以阻止这种操作的发生。你很快就会发现这一问题。

你可能会认为，事情变得有点走极端了，因为现在你甚至不能向刚刚声明过将持有Apple对象的List中放置一个Apple对象了。是的，但是编译器并不知道这一点。List<? extends Fruit>可以合法地指向一个List<Orange>。一旦执行这种类型的向上转型，你就将丢失掉向其中传递任何对象的能力，甚至是传递Object也不行。

另一方面，如果你调用一个返回Fruit的方法，则是安全的，因为你知道在这个List中的任何对象至少具有Fruit类型，因此编译器将允许你这么做。

### 一、编译器有多聪明 ###

现在，你可能会猜想自己被阻止去调用任何接受参数的方法，但是请考虑下面的程序：

import java.util.Arrays;
    import java.util.List;
    
    public class CompilerIntelligence {
    	public static void main(String[] args) {
    		List<? extends Fruit> flist = Arrays.asList(new Apple());
    		Apple a = (Apple) flist.get(0);
    		flist.contains(new Apple());
    		flist.indexOf(new Apple());
    	}
    }

你可以看到，对contains()和indexOf()的调用，这两个方法都接受Apple对象作为参数，而这些调用都可以正常执行。这是否意味着编译器实际上将检查代码，以查看是否有某个特定的方法修改了它的对象？

通过查看ArrayList的文档，我们可以发现，编译器并没有这么聪明。尽管add()将接受一个具有泛型参数类型的参数，但是contains()和indexOf()将接受Object类型的参数。因此当你指定一个ArrayList<? extends Fruit>时，add()的参数就变成了“? extends Fruit”。从这个描述中，编译器并不能了解这里需要Fruit的哪个具体子类型，因此它不会接受任何类型的Fruit。如果先将Apple向上转型为Fruit，也无关紧要——编译器将直接拒绝对参数列表中涉及通配符的方法（例如add()）的调用。

在使用contains()和indexOf()时，参数类型是Object，因此不涉及任何通配符，而编译器也将允许这个调用。这意味着将由泛型类的设计者来决定哪些调用是“安全的”，并使用Object类型作为其参数类型。为了在类型中使用了通配符的情况下禁止这类调用，我们需要在参数列表中使用类型参数。

可以在一个非常简单的Holder类中看到这一点：

public class Holder<T> {
    	private T value;
    
    	public Holder() {
    	}
    
    	public Holder(T val) {
    		value = val;
    	}
    
    	public T getValue() {
    		return value;
    	}
    
    	public void setValue(T value) {
    		this.value = value;
    	}
    
    	public boolean equals(Object obj) {
    		return value.equals(obj);
    	}
    
    	public static void main(String[] args) {
    		Holder<Apple> apple = new Holder<>(new Apple());
    		Apple d = apple.getValue();
    		apple.setValue(d);
    //		Holder<Fruit> fruit = apple;
    		Holder<? extends Fruit> fruit = apple;
    		Fruit p = fruit.getValue();
    		d = (Apple) fruit.getValue();
    		try {
    			Orange c = (Orange) fruit.getValue();
    		} catch (Exception e) {
    			System.out.println(e);
    		}
    //		fruit.setValue(new Apple());
    //		fruit.setValue(new Fruit());
    		System.out.println(fruit.equals(d));
    	}
    }

Holder有一个接受T类型对象的set()方法，一个get()方法，以及一个接受Object对象的equals()方法。正如你已经看到的，如果创建了一个Holder<Apple>，不能将其向上转型为Holder<Fruit>，但是可以将其向上转型为Holder<? extends Fruit>。如果调用get()，它只会返回一个Fruit——这就是在给定“任何扩展自Fruit的对象”这一边界之后，它所能知道的一切了。如果能够了解更多的信息，那么你可以转型到某种具体的Fruit类型，而这不会导致任何警告，但是你存在着得到ClassCastException的风险。set()方法不能工作于Apple()或Fruit，因为set()的参数也是“？ extends Fruit”，这意味着它可以是任何事物，而编译器无法验证“任何事物”的类型安全性。

但是，equals()方法工作良好，因为它将接受Object类型而并非T类型的参数。因此，编译器只关注传递进来和要返回的对象类型，它并不会分析代码，以查看是否执行了任何实际的写入和读取操作。

### 二、逆变 ###

还可以走另外一条路，即使用超类型通配符。这里，可以声明通配符是由某个特定类的任何基类来界定的，方法是指定<? super MyClass>，甚至或者使用类型参数：<? super T>（尽管你不能对泛型参数给出一个超类型边界；即不能声明<T super MyClass>）。这使得你可以安全地传递一个类型对象到泛型类型中。因此，有了超类型通配符，就可以向Collection写入了：

import java.util.List;
    
    public class SuperTypeWildcards {
    	static void writeTo(List<? super Apple> apples) {
    		apples.add(new Apple());
    		apples.add(new Jonathan());
    //		apples.add(new Fruit());
    	}
    }

参数Apple是Apple的某种基类型的List，这样你就知道向其中添加Apple或Apple的子类型是安全的。但是既然Apple是下界，那么你可以知道向这样的List中添加Fruit是不安全的，因为这将使这个List敞开口子，从而可以向其中添加非Apple类型的对象，而这是违反静态类型安全的。

因此你可能会根据如何能够向一个泛型类型“写入”（传递一个方法），以及如何能够从一个泛型类型中“读取”（从一个方法中返回），来着手思考子类型和超类型边界。

import java.util.ArrayList;
    import java.util.List;
    
    public class GenericWriting {
    	static <T> void writeExact(List<T> list, T item) {
    		list.add(item);
    	}
    
    	static List<Apple> apples = new ArrayList<>();
    	static List<Fruit> fruit = new ArrayList<>();
    
    	static void f1() {
    		writeExact(apples, new Apple());
    //		writeExact(fruit, new Apple());
    	}
    
    	static <T> void writeWithWildcard(List<? super T> list, T item) {
    		list.add(item);
    	}
    
    	static void f2() {
    		writeWithWildcard(apples, new Apple());
    		writeWithWildcard(fruit, new Apple());
    	}
    
    	public static void main(String[] args) {
    		f1();
    		f2();
    	}
    }

writeExact()方法使用了一个确切参数类型（无通配符）。在f1()中，可以看到这个工作良好——只要你指向List<Apple>中放置Apple。但是，writeExact()不允许将Apple放置到List<Fruit>中，即使知道这应该是可以的。

在writeWithWildcard()中，其参数现在是<? super T>，因此这个List将持有从T导出的某中具体类型，这样就可以安全地将一个T类型的对象或者从T导出的任何对象作为参数传递给List的方法。在f2()中可以看到这一点，在这个方法中我们仍旧可以像前面那样，将Apple放置到List<Apple>中，但是现在我们还可以如你所期望的那样，将Apple放置到List<Fruit>中。

我们可以执行下面这个相同的类型分析，作为对协变和通配符的一个复习：

import java.util.Arrays;
    import java.util.List;
    
    public class GenericReading {
    	static <T> T readExact(List<T> list) {
    		return list.get(0);
    	}
    
    	static List<Apple> apples = Arrays.asList(new Apple());
    	static List<Fruit> fruit = Arrays.asList(new Fruit());
    
    	static void f1() {
    		Apple a = readExact(apples);
    		Fruit f = readExact(fruit);
    		f = readExact(apples);
    	}
    
    	static class Reader<T> {
    		T readExact(List<T> list) {
    			return list.get(0);
    		}
    	}
    
    	static void f2() {
    		Reader<Fruit> fruitReader = new Reader<>();
    		Fruit f = fruitReader.readExact(fruit);
    //		Fruit a = fruitReader.readExact(apples);
    	}
    
    	static class CovariantReader<T> {
    		T readCovariant(List<? extends T> list) {
    			return list.get(0);
    		}
    	}
    
    	static void f3() {
    		CovariantReader<Fruit> fruitReader = new CovariantReader<>();
    		Fruit f = fruitReader.readCovariant(fruit);
    		Fruit a = fruitReader.readCovariant(apples);
    	}
    
    	public static void main(String[] args) {
    		f1();
    		f2();
    		f3();
    	}
    }

与前面一样，第一个方法readExact()使用了精确的类型。因此如果使用这个没有任何通配符的精确类型，就可以向List中写入和读取这个精确类型。另外，对于返回值，静态的泛型方法readExact()可以有效地“适应”每个方法调用，并能够从List<Apple>中返回一个Apple，从List<Fruit>中返回一个Fruit，就像在f1()中看到的那样。因此，如果可以摆脱静态泛型方法，那么当只是读取时，就不需要协变类型了。

但是，如果有一个泛型类，那么当你创建这个类的实例时，要为这个类确定参数。就像在f2()中看到的，fruitReader实例可以从List<Fruit>中读取一个Fruit，因为这就是它的确切类型。但是List<Apple>还应该产生Fruit对象，而fruitReader不允许这么做。

为了修正这个问题，CovariantReader.readCovariant()方法将接受List<? extends T>，因此，从这个列表中读取一个T是安全的（你知道在这个列表中的所有对象至少是一个T，并且可能是从T导出的某种对象）。在f3()中，你可以看到现在可以从List<Apple>中读取Fruit了。

**如果本文对您有很大的帮助，还请点赞关注一下。**