初识Java 18-2 泛型

目录

构建复杂模型

类型擦除

C++中的泛型

迁移的兼容性

类型擦除存在的问题

边界的行为

对类型擦除的补偿

创建类型实例

泛型数组

---

本笔记参考自： 《On Java 中文版》

---

构建复杂模型

        泛型的一个优点就是，能够简单且安全地创建复杂模型。

【例子：生成更复杂的数据结构】

import onjava.Tuple4;import java.util.ArrayList;public class TupleList<A, B, C, D>extends ArrayList<Tuple4<A, B, C, D>> {public static void main(String[] args) {TupleList<Vehicle, Amphibian, String, Integer> tl =new TupleList<>();tl.add(TupleTest2.h());tl.add(TupleTest2.h());tl.forEach(System.out::println);}
}

        程序执行的结果是：

        除此之外，我们也可以利用泛型组合各种各样的“块”，使其最终能够实现强大的功能。下面的例子表示的是一个商店（Store），这个商店中有通道（Aisle）、货架（Shelf）和商品（Product）：

【例子：通过泛型构建一个商店模型】

import onjava.Suppliers;import java.util.ArrayList;
import java.util.Random;
import java.util.function.Supplier;// 构建商品模型
class Product {private final int id;private String description;private double price;Product(int idNumber, String descr, double price) {id = idNumber;description = descr;this.price = price;System.out.println(toString());}@Overridepublic String toString() {return id + "：" + description +", 价格：" + price + "元";}public void priceChange(double change) {price += change;}public static Supplier<Product> generator =new Supplier<Product>() {private Random rand = new Random(47);@Overridepublic Product get() {return new Product(rand.nextInt(1000),"某件商品", Math.round(rand.nextDouble() * 1000.0) + 0.99);}};
}// 构建货架模型
class Shelf extends ArrayList<Product> {Shelf(int nProducts) {// Suppliers需要由自己进行实现Suppliers.fill(this, Product.generator, nProducts);}
}// 构建通道模型
class Aisle extends ArrayList<Shelf> {Aisle(int nShelves, int nProducts) {for (int i = 0; i < nShelves; i++)add(new Shelf(nProducts));}
}class CheckOutStand {
}class Office {
}// 最终组合成了一个商店的模型
public class Store extends ArrayList<Aisle> {private ArrayList<CheckOutStand> checkouts =new ArrayList<>();private Office office = new Office();public Store(int nAisles, int nShelves, int nProducts) {for (int i = 0; i < nAisles; i++)add(new Aisle(nShelves, nProducts));}@Overridepublic String toString() {StringBuffer result = new StringBuffer();for (Aisle a : this)for (Shelf s : a)for (Product p : s) {result.append(p);result.append("\n");}return result.toString();}public static void main(String[] args) {System.out.println(new Store(3, 2, 2));}
}

        程序执行的结果是：

        从Store.toString()方法中可以看出：尽管经过了层层封装，但我们依旧可以方便、安全地管理这些模块。

        这里还需要注意自定义的Suppliers.fill()方法，这个方法的实现会在之后提到。此处的fill()方法可以等价于：

Stream.generate(Product.generator).limit(nProducts).forEach(this::add);

类型擦除

        Java的泛型同样存在着不合理之处。例如，尽管我们可以声明ArrayList.class，但却无法使用ArrayList<Integer>.class。

【例子：发现泛型的不合理】

import java.util.ArrayList;public class ErasedTypeEquivalence {public static void main(String[] args) {Class c1 = new ArrayList<String>().getClass();Class c2 = new ArrayList<Integer>().getClass();System.out.println(c1 == c2);}
}

        程序执行，会返回true。

        输出告诉我们，ArrayList<String>和ArrayList<Integer>是相同的类型。但这是有问题的：因为它们的行为并不相同。我们无法将Integer对象放入到ArrayList<String>，却可以把Integer对象放入到ArrayList<Integer>中。

        除此之外，Java的泛型还有一个更麻烦的特性：

【例子：泛型代码内部的信息】

import java.util.*;class Frob {
}class Fnorkle {
}class Quark<Q> {
}class Particle<POSITION, MOMENTUM> {
}public class LostInformation {public static void main(String[] args) {List<Frob> list = new ArrayList<>();System.out.println(Arrays.toString(list.getClass().getTypeParameters()));Map<Frob, Fnorkle> map = new HashMap<>();System.out.println(Arrays.toString(map.getClass().getTypeParameters()));Quark<Fnorkle> quark = new Quark<>();System.out.println(Arrays.toString(quark.getClass().getTypeParameters()));Particle<Long, Double> particle = new Particle<>();System.out.println(Arrays.toString(particle.getClass().getTypeParameters()));}
}

        程序执行的结果是：

        Class.getTypeParameters()方法会返回一个由类型变量的对象组成的数组，表示泛型对象声明（所声明）的类型变量。这似乎表示着我们可以获取与泛型参数有关的类型信息。但结果是，我们只能发现作为参数占位符的标识符。

        这就说明：在Java的泛型代码内部，并不存在有关泛型参数类型的可用信息。

    而C++等语言是可以在泛型内部获取类型信息的。

        Java的泛型是通过类型擦除实现的。因此在使用泛型时，任何具体的类型信息都会被擦除。在泛型内部，唯一能够知道的事情就是我们在使用这个对象。因此，ArrayList<String>和ArrayList<Integer>在运行时都被“擦除”成了它们的原始类型（raw type）：ArrayList。

（这种通过类型擦除实现的泛型有时也被称为第二类泛型类型）

C++中的泛型

        Java的设计中有许多参考了C++的元素。因此，二者在参数化类型的语法部分也十分相似：

【例子：C++中的泛型（即模板）】

#include <iostream>
using namespace std;template <class T>
class Manipulator {T obj;public:Manipulator(T x) {obj = x;}void manipulate() {obj.f();}
};class HasF {
public:void f() {cout << "HasF::f()" << endl;}
};int main() {HasF hf;Manipulator<HasF> manipulator(hf);manipulator.manipulate();
}

        编译并执行程序，可得：

        C++编译器会在实例化模板时进行检测。因此，在实例化Manipulator<HasF>时，编译器会发现HasF中存在着方法f()。

        接下来再尝试通过Java实现同样的效果：

【例子：在Java中进行尝试】

        首先编写一个HasF类：

public class HasF {public void f(){System.out.println("HasF.f()");}
}

        但接下来的部分却没办法如C++一样书写。若我们尝试调用方法obj.f()，编译器就会提示我们：

因为类型擦除的缘故，编译器不会知道Manipulator<HasF>的类型参数是HasF，因此会认为这种调用是不安全的。若想要调用f()，我们就必须人为规定泛型类的边界，帮助编译器确定符合边界的类型：

public class Manipulator2<T extends HasF> {private T obj;Manipulator2(T x) {obj = x;}public void manipulator() {obj.f();}
}

        <T extends HasF>告诉编译器，T的类型必须是HasF及其的子类。

        在这里，泛型的类型参数被擦除为了其的第一个边界HasF（与之相对的，也存在拥有多重边界的泛型）。编译器会将类型参数替换为擦除后的类型，因此可以说，在这个例子中T被替换成了HasF。

    并且，该例子实际上并不需要使用到泛型——可以直接使用更加具体的类型HasF。

        注意：当我们希望代码能够跨越多个类型运行时，泛型才会发挥作用（因此，在具有实际价值的泛型代码中，类型参数及其应用往往会比简单的类替换更加复杂）。

（基于以上论点，可以认为<T extends HasF>这种用法存在缺陷。）

        下面的例子展示了更好的一种泛型应用：通过让方法返回类型参数T，可以使泛型返回精确的类型。

【例子：更好的泛型使用】

public class ReturnGenericType<T extends HasF> {private T obj;ReturnGenericType(T x) {obj = x;}public T get() {return obj;}
}

---

迁移的兼容性

        注意：类型擦除并不是一项语言特性。它是Java在实现泛型时使用的一种必要的折中，因为泛型并不是这门语言与生俱来的一部分。

    因此，Java中的泛型并没有将类型参数具体化成第一类实体的能力。

        因为类型擦除，泛型类型被视同第二类类型处理，这使得其无法在一些重要的上下文中得到使用：泛型类型只会在静态类型检查时存在，之后，程序会将泛型类型擦除成它们的非泛型上界。

        在Java 5之前，存在许多编写完毕的非泛型的库。库是一门语言重要的组成部分，无法被轻易抛弃。因此，Java的泛型设计必然需要保证向后兼容性和迁移兼容性。前者保证原有的数据依旧合法，后者则需要协调泛化的程序与非泛化的库（反之亦然）。

||| 至于类型擦除是否是一种好的手段，就只能靠时间来验证了。

---

类型擦除存在的问题

        类型擦除在非泛化代码和泛化代码之间构建起了一座桥梁，泛型得以在不破坏现有库的情况下加入Java。

        然而这种做法是有代价的。泛型代码无法用于需要显式引用运行时类型的操作，例如类型转换、instanceof操作以及new表达式。在编写泛型代码时，我们只是看起来掌握了参数的类型信息。就比如，现在有一个泛型类：

class Foo<T> {T var;
}

若为它创建一个实例：

Foo<Cat> f = new Foo<>();

尽管不论是直观的理解或是语法本身带来的暗示，都在说明T已经被替换成了Cat。遗憾的是，泛型内部的T已经只是一个Object。

    泛型擦除像是一个边界，在边界里面的成员会被擦除成原始的类型。只有在进出边界时，它们才会被转换成对应的类型。

        另外，因为类型擦除和迁移兼容性，Java中泛型的使用并非是强制性的。

【例子：不强制的泛型使用】

class GenericBase<T> {private T element;public void set(T arg) {element = arg;}public T get() {return element;}
}// 使用泛型：
class Derived1<T> extends GenericBase<T> {}// 使用原始类型，但未发出警告：
class Derived2 extends GenericBase {}// 引发错误：
//class Derived3 extends GenericBase<?> {}public class ErasureAndInheritance {@SuppressWarnings("unchecked")public static void main(String[] args) {Derived2 d2 = new Derived2();Object obj = d2.get();d2.set(obj); // d2.set()会引发警告，使用@SuppressWarnings()进行关闭}
}

        Derived2继承了GenericBase，而未使用泛型参数。编译器没有在这里给出警告，直到进行编译时，在d2.get()才显现出来。若要关闭警告，可以使用Java提供的注解：

@SuppressWarnings("unchecked")

这一注解应该被放置于触发警告的类上。

        Derived3会引发错误：

编译器需要的是一个原始的基类，而我们却提供了一个带有<?>的泛型。

    在Java中，使用类型参数就意味着我们需要管理边界。这使得Java泛型并没有完全发挥其应有的灵活性。

---

边界的行为

        类型擦除使得泛型会表现出一些无意义的行为：

【例子：无意义的泛型行为】

import java.lang.reflect.Array;
import java.util.Arrays;public class ArrayMaker<T> {private Class<T> kind;public ArrayMaker(Class<T> kind) {this.kind = kind;}@SuppressWarnings("unchecked")T[] create(int size) { // 需要使用类型转换return (T[]) Array.newInstance(kind, size);}public static void main(String[] args) {ArrayMaker<String> stringMaker =new ArrayMaker<>(String.class);String[] stringArray = stringMaker.create(9);System.out.println(Arrays.toString(stringArray));}
}

        程序执行的结果是：

        在这个例子中，尽管kind看起来会获得一个具体的Class<T>，但当进入类型擦除的边界时，<T>就会消失。换言之，kind中存储的只是一个无意义的Class，它无法生成一个具体的结果，因此我们还需要使用到类型转换（并且会产生警告）。

    在create()方法中使用到的Array.newInstance()，是在泛型中创建数组的推荐方法。

        我们也可以使用泛型创建集合（而不是数组）：

【例子：无意义的集合】

import java.util.ArrayList;
import java.util.List;public class ListMaker<T> {List<T> create() {return new ArrayList<>();}public static void main(String[] args) {ListMaker<String> stringMaker = new ListMaker<>();List<String> stringList = stringMaker.create();}
}

        在create()内部的new ArrayList<>()方法中没有使用<T>，并且在运行时<T>也会被移除。这使得这个集合似乎并没有具体意义，但若使用new ArrayList()，依旧会引发警告。

---

        但我们依旧可以通过一些方式进行有意义的调用：

【例子：有意义的泛型集合】

import onjava.Suppliers;import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;public class FilledList<T> extends ArrayList<T> {FilledList(Supplier<T> gen, int size) {// 等价于使用Stream.generate(gen)生成size个元素，并装入该类中Suppliers.fill(this, gen, size);}public FilledList(T t, int size) {for (int i = 0; i < size; i++)this.add(t);}public static void main(String[] args) {List<String> list = new FilledList<>("Hello", 4);System.out.println(list);// 也可以借由Supplier接口进行实现List<Integer> ilist = new FilledList<>(() -> 47, 4);System.out.println(ilist);}
}

        程序执行的结果是：

        虽然在this.add()方法中，编译器无法知道任何关于T的信息，但我们依旧可以在编译时确保放入FilledList中的是类型T。因此，尽管存在类型擦除，编译器依旧可以确保类型在使用方法内部的一致性。

        现在，泛型运行时的关键就指向的边界——对象进入和离开方法体的临界点。编译器在这里执行类型检查，插入类型转换。可以观察下面两个类之间的区别：

        这两个类之间唯一的区别就是它们是否使用了泛型。现在可以通过反编译指令（javap -c）来观察它们的字节码：

        可以发现，非泛型类和泛型类在这里得到的字节码完全相同。在main()中调用set()方法时，编译器自动插入了类型转换，并且get()的类型转换仍然存在。从这里可以得出一个结论：泛型所有的行为都发生在边界，包括输入值的检查、类型转换等。

对类型擦除的补偿

        类型擦除会使得我们在一些操作上受掣肘：

        尽管我们有时可以绕过这些问题，但有些问题总是需要泛型来解决。此时可以使用类型标签来补偿类型擦除带来的损失：我们可以在类型表达式中显示地为所使用的类型传入一个Class对象。

        类型标签与instanceof的不同之于，instanceof是静态的检查，若类型被擦除，那么instanceof就会失效。而类型标签可以通过isInstance()提供动态的检查，这使得它可以在泛型中进行使用：

【例子：使用类型标签】

class Building {
}class House extends Building {
}public class ClassTypeCapture<T> {Class<T> kind;public ClassTypeCapture(Class<T> kind) {this.kind = kind;}public boolean f(Object arg) {return kind.isInstance(arg);}public static void main(String[] args) {ClassTypeCapture<Building> ctt1 =new ClassTypeCapture<>(Building.class);System.out.println(ctt1.f(new Building()));System.out.println(ctt1.f(new House()));ClassTypeCapture<House> ctt2 =new ClassTypeCapture<>(House.class);System.out.println(ctt2.f(new Building()));System.out.println(ctt2.f(new House()));}
}

        程序执行的结果是：

        编译器会确保类型标签能够与泛型参数相匹配。

创建类型实例

        在Erased.java中执行new T()操作是无法成功的，这有两个原因：①类型擦除和②编译器无法验证T中是否存在无参构造器。但C++却支持这种操作：

【例子：C++允许创建泛型的类型实例】

template<class T> class Foo {T x; // 字段xT* y; // 指向T类的指针
public:Foo() {// 初始化指针y = new T();}
};class Bar {};int main()
{Foo<Bar> fb;Foo<int> fi; // 甚至可以使用基本类型return 0;
}

---

        而Java则需要使用工厂设计方法来创建新的实例。Class就是一个方便的工厂对象，将其作为类型标签，我们能够在Java中实现类似上例的功能：

【例子：通过newInstance()创建泛型对象】

import java.util.function.Supplier;class ClassAsFactory<T> implements Supplier<T> {Class<T> kind;ClassAsFactory(Class<T> kind) {this.kind = kind;}@Overridepublic T get() {try {return kind.getConstructor().newInstance();} catch (Exception e) {throw new RuntimeException(e);}}
}class Employee {public Employee() {}@Overridepublic String toString() {return "Employee";}
}public class InstantiateGenericType {public static void main(String[] args) {ClassAsFactory<Employee> fe =new ClassAsFactory<>(Employee.class);System.out.println(fe.get());ClassAsFactory<Integer> fi =new ClassAsFactory<>(Integer.class);try {System.out.println(fi.get());} catch (Exception e) {System.out.println(e.getMessage());}}
}

        程序执行的结果是：

        在该例中，我们尝试创建Integer的实例，结果却失败了。这是因为Integer中不存在无参构造器。这个错误不会在编译时被发现，也因此上例的方式并不被推荐。更好的方式是使用显式工厂，同时限制能够传入的类型：

【例子：创建工厂，生成泛型实例】

import onjava.Suppliers;import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;class IntegerFactory implements Supplier<Integer> {private int i = 0;@Overridepublic Integer get() {return ++i;}
}class Widget {private int id;Widget(int n) {id = n;}@Overridepublic String toString() {return "Widget " + id;}public staticclass Factory implements Supplier<Widget> {private int i = 0;@Overridepublic Widget get() {return new Widget(++i);}}
}class Fudge {private static int count = 1;private int n = count++;@Overridepublic String toString() {return "Fudge " + n;}
}class Foo2<T> {private List<T> x = new ArrayList<>();Foo2(Supplier<T> factory) {// 等价于使用Stream.generate(factory)生成5个元素，并装入该类中Suppliers.fill(x, factory, 5);}@Overridepublic String toString() {return x.toString();}
}public class FactoryConstraint {public static void main(String[] args) {System.out.println(new Foo2<>(new IntegerFactory()));System.out.println(new Foo2<>(new Widget.Factory()));System.out.println(new Foo2<>(Fudge::new));}
}

        程序执行的结果是：

        Foo2类用于调用各种工厂方法，生成实例。这里展示了三种创建工厂的方式：

1. IntegerFactory：本身就是一个实现了Supplier<Integer>的工厂；
2. Widget：包含了一个作为工厂的内部类；
3. Fudge：不执行任何类似工厂的操作，但编译器会自动将Fudge::new转变成对get的调用。

        除此之外，还有另一种设计模式：模板方法。将方法在子类中进行重写，用来生成对应类型的对象：

【例子：使用模板方法生成泛型实例】

abstract class GenericWithCreate<T> {final T element;GenericWithCreate() {element = create();}// 会在子类中重写的模板方法：abstract T create();
}class X {
}class XCreator extends GenericWithCreate<X> {@OverrideX create() {return new X();}void f() {System.out.println(element.getClass().getSimpleName());}
}public class CreatorGeneric {public static void main(String[] args) {XCreator xc = new XCreator();xc.f();}
}

        程序执行的结果是：

        GenericWithCreate有唯一的无参构造器，这样就可以要求任何所有这个类的程序员，必须通过我们规定的方式初始化这个类。另一边，create()方法将类的创建逻辑交付给了子类实现，这使得该方法的返回值可以在子类中得到更具体的定义。

---

泛型数组

        正如之前所看到的，我们无法直接在泛型中创建泛型数组：

一个直接的方法是使用集合来代替数组：

【例子：使用集合替代数组】

import java.util.ArrayList;
import java.util.List;public class ListOfGenerics<T> {private List<T> array = new ArrayList<>();public void add(T item) {array.add(item);}public T get(int index) {return array.get(index);}
}

        这样我们就获得了数组的行为，并且得到了泛型提供的编译时类型检查。

        但如果确实有使用泛型数组的必要，那么可以尝试使用一个泛型引用，通过将这个引用指向一个数组，可以变相满足编译器的规定：

【例子：将引用指向数组】

class Generic<T> {
}public class ArrayOfGenericReference {static Generic<Integer>[] gia;
}

        因为类型擦除，这个数组实际上没有具体的类型，无论指定的泛型参数是什么，数组都会具有相同的结构和大小。这看上去有点像Object，那么我们是否可以将一个Object类型的数组转换成目标数组？

        答案依旧是否定的：

【例子：无法对Object数组进行转型】

public class ArrayOfGeneric {static final int SIZE = 100;static Generic<Integer>[] gia;@SuppressWarnings("unchecked")public static void main(String[] args) {try {gia = (Generic<Integer>[]) new Object[SIZE];} catch (ClassCastException e) {System.out.println(e.getMessage());}// 运行时会发生类型擦除，得到的是原始类型Generic[]gia = (Generic<Integer>[]) new Generic[SIZE];System.out.println(gia.getClass().getSimpleName());gia[0] = new Generic<>();// 发生编译时错误（类型不匹配）：// gia[1] = new Object();// gia[2] = new Generic<Double>();}
}

        程序执行的结果是（输出已经过折叠）：

        数组的类型在它们被创建的时候才会确定下来，因此转型信息Generic<Integer>[]也只会存在于编译时。语句：

gia = (Generic<Integer>[]) new Object[SIZE];

能得到的只会是Object数组，这就会导致问题。

        而另一条创建语句：

gia = (Generic<Integer>[]) new Generic[SIZE];

对一个被擦除类型的数组进行强制类型转换得到了成功。这也是唯一可以成功创建泛型数组的方式。

        以此类推，下面是一个更加复杂的例子：

【例子：更复杂的泛型数组尝试】

public class GenericArray<T> {private T[] array;@SuppressWarnings("unchecked")public GenericArray(int sz) {array = (T[]) new Object[sz];}public void put(int index, T item) {array[index] = item;}public T get(int index) {return array[index];}// 通过返回T[]，可以发现其的潜在表现形式：public T[] rep() {return array;}public static void main(String[] args) {GenericArray<Integer> gai = new GenericArray<>(10);try {Integer[] ia = gai.rep();} catch (ClassCastException e) {System.out.println(e.getMessage());}// 可以使用Object数组接受：Object[] oa = gai.rep();}
}

        程序执行的结果是（输出已经过折叠）：

        显然，这里的gai也被类型擦除影响，其在运行时的实际类型也变成了Object。

        之前也提到过，通过@SuppressWarnings("unchecked")可以抑制编译器发出警告，否则会出现这样的警告：

        为了获取更加详细的信息，可以在编译时添加-Xlint:unchecked选项。而如果这么做，就会得到如下的信息：

    若认为报出的警告并不影响程序运行，就可以使用注解关闭警告，因为警告在一些时候也会成为不必要的噪声。

        因为类型擦除，在上例中我们只能得到Object[]。若此时立刻将其转变为T[]，就会丢失数组的实际类型，这可能会让一些潜在错误有机可乘。

        一个可能的替代方法是在泛型类内部使用Object数组，而在边界处执行类型转换：

【例子：在边界上执行类型转换】

public class GenericArray2<T> {private Object[] array;public GenericArray2(int sz) {array = new Object[sz];}public void put(int index, T item) {array[index] = item;}@SuppressWarnings("unchecked")public T get(int index) {return (T) array[index];}// 该方法依旧存在问题：为检测的类型转换@SuppressWarnings("unchecked")public T[] rep() {return (T[]) array;}public static void main(String[] args) {GenericArray2<Integer> gai =new GenericArray2<>(10);for (int i = 0; i < 10; i++)gai.put(i, i);for (int i = 0; i < 10; i++)System.out.print(gai.get(i) + " ");System.out.println();try {Integer[] ia = gai.rep();} catch (Exception e) {System.out.println(e);}}
}

        程序执行的结果是：

        这么做依旧需要抑制警告。但比上一个例子更好的一点在于，现在get()方法能够正确地进行类型转换了。而不好的一点在于，rep()方法依旧无法将Object[]转型为T[]。这里就可以得出一个结论：底层的数组类型是无法更改的，这个类型只能是Object[]。

    在泛型类内部使用Object[]的另一个好处是，让程序员花费更少的精力来处理数组的运行时类型。

---

        既然底层的数组无法更改，那么我们还可以换一个思路。通过类型标记，我们可以直接创建一个目标数组的实例：

【例子：使用类型标记创建数组实例】

import java.lang.reflect.Array;public class GenericArrayWithTypeToken<T> {private T[] array;@SuppressWarnings("unchecked")public GenericArrayWithTypeToken(Class<T> type, int sz) {array = (T[]) Array.newInstance(type, sz);}public void put(int index, T item) {array[index] = item;}public T get(int index) {return array[index];}// 依旧会暴露潜在的表达方式：public T[] rep() {return array;}public static void main(String[] args) {GenericArrayWithTypeToken<Integer> gai =new GenericArrayWithTypeToken<>(Integer.class, 10);// 现在可以正常运行：Integer[] ia = gai.rep();}
}

        尽管还是需要抑制警告，但在这个例子中，数组在运行时是精确的T[]类型了。

    然而，在Java的源代码中，也存在着许都使用Object数组转型为参数化类型的操作，对其编译甚至会产生警告……（因此，Java的库代码难以作为我们自己编写代码时的范例）