初识Java 18-2 泛型
目录
构建复杂模型
类型擦除
C++中的泛型
迁移的兼容性
类型擦除存在的问题
边界的行为
对类型擦除的补偿
创建类型实例
泛型数组
本笔记参考自： 《On Java 中文版》
构建复杂模型
泛型的一个优点就是，能够简单且安全地创建复杂模型。
【例子：生成更复杂的数据结构】
import onjava.Tuple4;
import java.util.ArrayList;
public class TupleList
extends ArrayList> {
public static void main(String[] args) {
TupleList 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());
}
@Override
public String toString() {
return id + "：" + description +
", 价格：" + price + "元";
}
public void priceChange(double change) {
price += change;
}
public static Supplier generator =
new Supplier() {
private Random rand = new Random(47);
@Override
public Product get() {
return new Product(rand.nextInt(1000),
"某件商品", Math.round(
rand.nextDouble() * 1000.0) + 0.99);
}
};
}
// 构建货架模型
class Shelf extends ArrayList {
Shelf(int nProducts) {
// Suppliers需要由自己进行实现
Suppliers.fill(this, Product.generator, nProducts);
}
}
// 构建通道模型
class Aisle extends ArrayList {
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 {
private ArrayList 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));
}
@Override
public 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
【例子：发现泛型的不合理】
import java.util.ArrayList;
public class ErasedTypeEquivalence {
public static void main(String[] args) {
Class c1 = new ArrayList().getClass();
Class c2 = new ArrayList().getClass();
System.out.println(c1 == c2);
}
} 程序执行，会返回true。
输出告诉我们，ArrayList
除此之外，Java的泛型还有一个更麻烦的特性：
【例子：泛型代码内部的信息】
import java.util.*;
class Frob {
}
class Fnorkle {
}
class Quark {
}
class Particle {
}
public class LostInformation {
public static void main(String[] args) {
List list = new ArrayList<>();
System.out.println(Arrays.toString(
list.getClass().getTypeParameters()));
Map map = new HashMap<>();
System.out.println(Arrays.toString(
map.getClass().getTypeParameters()));
Quark quark = new Quark<>();
System.out.println(Arrays.toString(
quark.getClass().getTypeParameters()));
Particle particle = new Particle<>();
System.out.println(Arrays.toString(
particle.getClass().getTypeParameters()));
}
}
程序执行的结果是：
Class.getTypeParameters()方法会返回一个由类型变量的对象组成的数组，表示泛型对象声明（所声明）的类型变量。这似乎表示着我们可以获取与泛型参数有关的类型信息。但结果是，我们只能发现作为参数占位符的标识符。
这就说明：在Java的泛型代码内部，并不存在有关泛型参数类型的可用信息。
而C++等语言是可以在泛型内部获取类型信息的。
Java的泛型是通过类型擦除实现的。因此在使用泛型时，任何具体的类型信息都会被擦除。在泛型内部，唯一能够知道的事情就是我们在使用这个对象。因此，ArrayList
（这种通过类型擦除实现的泛型有时也被称为第二类泛型类型）
C++中的泛型
Java的设计中有许多参考了C++的元素。因此，二者在参数化类型的语法部分也十分相似：
【例子：C++中的泛型（即模板）】
#include
using namespace std;
template
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 manipulator(hf);
manipulator.manipulate();
} 编译并执行程序，可得：
C++编译器会在实例化模板时进行检测。因此，在实例化Manipulator
接下来再尝试通过Java实现同样的效果：
【例子：在Java中进行尝试】
首先编写一个HasF类：
public class HasF {
public void f(){
System.out.println("HasF.f()");
}
}但接下来的部分却没办法如C++一样书写。若我们尝试调用方法obj.f()，编译器就会提示我们：
因为类型擦除的缘故，编译器不会知道Manipulator
public class Manipulator2 {
private T obj;
Manipulator2(T x) {
obj = x;
}
public void manipulator() {
obj.f();
}
}
在这里，泛型的类型参数被擦除为了其的第一个边界HasF（与之相对的，也存在拥有多重边界的泛型）。编译器会将类型参数替换为擦除后的类型，因此可以说，在这个例子中T被替换成了HasF。
并且，该例子实际上并不需要使用到泛型——可以直接使用更加具体的类型HasF。
注意：当我们希望代码能够跨越多个类型运行时，泛型才会发挥作用（因此，在具有实际价值的泛型代码中，类型参数及其应用往往会比简单的类替换更加复杂）。
（基于以上论点，可以认为
下面的例子展示了更好的一种泛型应用：通过让方法返回类型参数T，可以使泛型返回精确的类型。
【例子：更好的泛型使用】
public class ReturnGenericType {
private T obj;
ReturnGenericType(T x) {
obj = x;
}
public T get() {
return obj;
}
} 迁移的兼容性
注意：类型擦除并不是一项语言特性。它是Java在实现泛型时使用的一种必要的折中，因为泛型并不是这门语言与生俱来的一部分。
因此，Java中的泛型并没有将类型参数具体化成第一类实体的能力。
因为类型擦除，泛型类型被视同第二类类型处理，这使得其无法在一些重要的上下文中得到使用：泛型类型只会在静态类型检查时存在，之后，程序会将泛型类型擦除成它们的非泛型上界。
在Java 5之前，存在许多编写完毕的非泛型的库。库是一门语言重要的组成部分，无法被轻易抛弃。因此，Java的泛型设计必然需要保证向后兼容性和迁移兼容性。前者保证原有的数据依旧合法，后者则需要协调泛化的程序与非泛化的库（反之亦然）。
||| 至于类型擦除是否是一种好的手段，就只能靠时间来验证了。
类型擦除存在的问题
类型擦除在非泛化代码和泛化代码之间构建起了一座桥梁，泛型得以在不破坏现有库的情况下加入Java。
然而这种做法是有代价的。泛型代码无法用于需要显式引用运行时类型的操作，例如类型转换、instanceof操作以及new表达式。在编写泛型代码时，我们只是看起来掌握了参数的类型信息。就比如，现在有一个泛型类：
class Foo {
T var;
} 若为它创建一个实例：
Foo f = new Foo<>(); 尽管不论是直观的理解或是语法本身带来的暗示，都在说明T已经被替换成了Cat。遗憾的是，泛型内部的T已经只是一个Object。
泛型擦除像是一个边界，在边界里面的成员会被擦除成原始的类型。只有在进出边界时，它们才会被转换成对应的类型。
另外，因为类型擦除和迁移兼容性，Java中泛型的使用并非是强制性的。
【例子：不强制的泛型使用】
class GenericBase {
private T element;
public void set(T arg) {
element = arg;
}
public T get() {
return element;
}
}
// 使用泛型：
class Derived1 extends GenericBase {}
// 使用原始类型，但未发出警告：
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 {
private Class kind;
public ArrayMaker(Class kind) {
this.kind = kind;
}
@SuppressWarnings("unchecked")
T[] create(int size) { // 需要使用类型转换
return (T[]) Array.newInstance(kind, size);
}
public static void main(String[] args) {
ArrayMaker stringMaker =
new ArrayMaker<>(String.class);
String[] stringArray = stringMaker.create(9);
System.out.println(Arrays.toString(stringArray));
}
} 程序执行的结果是：
在这个例子中，尽管kind看起来会获得一个具体的Class
在create()方法中使用到的Array.newInstance()，是在泛型中创建数组的推荐方法。
我们也可以使用泛型创建集合（而不是数组）：
【例子：无意义的集合】
import java.util.ArrayList;
import java.util.List;
public class ListMaker {
List create() {
return new ArrayList<>();
}
public static void main(String[] args) {
ListMaker stringMaker = new ListMaker<>();
List stringList = stringMaker.create();
}
} 在create()内部的new ArrayList<>()方法中没有使用
---
但我们依旧可以通过一些方式进行有意义的调用：
【例子：有意义的泛型集合】
import onjava.Suppliers;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;
public class FilledList extends ArrayList {
FilledList(Supplier 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 list = new FilledList<>("Hello", 4);
System.out.println(list);
// 也可以借由Supplier接口进行实现
List 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 {
Class kind;
public ClassTypeCapture(Class kind) {
this.kind = kind;
}
public boolean f(Object arg) {
return kind.isInstance(arg);
}
public static void main(String[] args) {
ClassTypeCapture ctt1 =
new ClassTypeCapture<>(Building.class);
System.out.println(ctt1.f(new Building()));
System.out.println(ctt1.f(new House()));
ClassTypeCapture 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 Foo {
T x; // 字段x
T* y; // 指向T类的指针
public:
Foo() {
// 初始化指针
y = new T();
}
};
class Bar {};
int main()
{
Foo fb;
Foo fi; // 甚至可以使用基本类型
return 0;
} ---
而Java则需要使用工厂设计方法来创建新的实例。Class就是一个方便的工厂对象，将其作为类型标签，我们能够在Java中实现类似上例的功能：
【例子：通过newInstance()创建泛型对象】
import java.util.function.Supplier;
class ClassAsFactory implements Supplier {
Class kind;
ClassAsFactory(Class kind) {
this.kind = kind;
}
@Override
public T get() {
try {
return kind.getConstructor().newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
class Employee {
public Employee() {
}
@Override
public String toString() {
return "Employee";
}
}
public class InstantiateGenericType {
public static void main(String[] args) {
ClassAsFactory fe =
new ClassAsFactory<>(Employee.class);
System.out.println(fe.get());
ClassAsFactory 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 {
private int i = 0;
@Override
public Integer get() {
return ++i;
}
}
class Widget {
private int id;
Widget(int n) {
id = n;
}
@Override
public String toString() {
return "Widget " + id;
}
public static
class Factory implements Supplier {
private int i = 0;
@Override
public Widget get() {
return new Widget(++i);
}
}
}
class Fudge {
private static int count = 1;
private int n = count++;
@Override
public String toString() {
return "Fudge " + n;
}
}
class Foo2 {
private List x = new ArrayList<>();
Foo2(Supplier factory) {
// 等价于使用Stream.generate(factory)生成5个元素，并装入该类中
Suppliers.fill(x, factory, 5);
}
@Override
public 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类用于调用各种工厂方法，生成实例。这里展示了三种创建工厂的方式：
- IntegerFactory：本身就是一个实现了Supplier
的工厂； - Widget：包含了一个作为工厂的内部类；
- Fudge：不执行任何类似工厂的操作，但编译器会自动将Fudge::new转变成对get的调用。
除此之外，还有另一种设计模式：模板方法。将方法在子类中进行重写，用来生成对应类型的对象：
【例子：使用模板方法生成泛型实例】
abstract class GenericWithCreate {
final T element;
GenericWithCreate() {
element = create();
}
// 会在子类中重写的模板方法：
abstract T create();
}
class X {
}
class XCreator extends GenericWithCreate {
@Override
X 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 {
private List array = new ArrayList<>();
public void add(T item) {
array.add(item);
}
public T get(int index) {
return array.get(index);
}
} 这样我们就获得了数组的行为，并且得到了泛型提供的编译时类型检查。
但如果确实有使用泛型数组的必要，那么可以尝试使用一个泛型引用，通过将这个引用指向一个数组，可以变相满足编译器的规定：
【例子：将引用指向数组】
class Generic {
}
public class ArrayOfGenericReference {
static Generic[] gia;
} 因为类型擦除，这个数组实际上没有具体的类型，无论指定的泛型参数是什么，数组都会具有相同的结构和大小。这看上去有点像Object，那么我们是否可以将一个Object类型的数组转换成目标数组？
答案依旧是否定的：
【例子：无法对Object数组进行转型】
public class ArrayOfGeneric {
static final int SIZE = 100;
static Generic[] gia;
@SuppressWarnings("unchecked")
public static void main(String[] args) {
try {
gia = (Generic[]) new Object[SIZE];
} catch (ClassCastException e) {
System.out.println(e.getMessage());
}
// 运行时会发生类型擦除，得到的是原始类型Generic[]
gia = (Generic[]) new Generic[SIZE];
System.out.println(gia.getClass().getSimpleName());
gia[0] = new Generic<>();
// 发生编译时错误（类型不匹配）：
// gia[1] = new Object();
// gia[2] = new Generic();
}
} 程序执行的结果是（输出已经过折叠）：
数组的类型在它们被创建的时候才会确定下来，因此转型信息Generic
gia = (Generic[]) new Object[SIZE]; 能得到的只会是Object数组，这就会导致问题。
而另一条创建语句：
gia = (Generic[]) new Generic[SIZE]; 对一个被擦除类型的数组进行强制类型转换得到了成功。这也是唯一可以成功创建泛型数组的方式。
以此类推，下面是一个更加复杂的例子：
【例子：更复杂的泛型数组尝试】
public class GenericArray {
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 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 {
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 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 {
private T[] array;
@SuppressWarnings("unchecked")
public GenericArrayWithTypeToken(Class 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 gai =
new GenericArrayWithTypeToken<>(
Integer.class, 10);
// 现在可以正常运行：
Integer[] ia = gai.rep();
}
} 尽管还是需要抑制警告，但在这个例子中，数组在运行时是精确的T[]类型了。
然而，在Java的源代码中，也存在着许都使用Object数组转型为参数化类型的操作，对其编译甚至会产生警告……（因此，Java的库代码难以作为我们自己编写代码时的范例）