8 泛型程序设计
8.1 为什么要使用泛型程序设计
- 类型参数（type parameters）（
E、T、S...） - 通配符类型（wildcard type）（
?）
注意这两者用法用处并不同。
8.2 定义简单泛型类
public class Pair<T> {
private T first;
private T second;
public Pair() { first = null; second = null; }
public Pair(T first, T second) { this.first = first; this.second = second; }
public T getFirst() { return first; }
public T getSecond() { return second; }
public void setFirst(T newValue) { first = newValue; }
public void setSecond(T newValue) { second = newValue; }
}
8.3 泛型方法
类型变量放在修饰符的后面，返回类型的前面。
泛型方法可以定义在普通类中，也可以定义在泛型类中。
当调用一个泛型方法时，在方法名前的尖括号中放入具体的类型。
8.4 类型变量的限定
可以通过对类型变量 T 设置限定（bound）：
public static <T extends Comparable> T min(T[] a) {. . .}
- 关键词是
extends，T 和限定类型可以是类，也可以是接口。 - 一个类型变量或通配符可以有多个限定，例如：
T extends Comparable & Serializable；限定类型用“&”分隔，而逗号用来分隔类型变量。 - 限定中至多有一个类，且必须是限定列表中的第一个。
8.5 泛型代码和虚拟机
虚拟机没有泛型类型对象 —— 所有对象都属于普通类。
8.5.1 类型擦除
无论何时定义一个泛型类型，都自动提供了一个相应的原始类型（raw type）。原始类型的名字就是删去类型参数后的泛型类型名。擦除（erased）类型变量，并替换为限定类型。
原始类型用第一个限定的类型变量来替换，如果没有给定限定就用 Object 替换。为了提高效率，应该将标记接口（即没有方法的接口）放在边界列表的末尾。
public class Pair {
private Object first;
private Object second;
public Pair() { first = null; second = null; }
public Pair(Object first, Object second) { this.first = first; this.second = second; }
public Object getFirst() { return first; }
public Object getSecond() { return second; }
public void setFirst(Object newValue) { first = newValue; }
public void setSecond(Object newValue) { second = newValue; }
}
8.5.2 翻译泛型表达式
当程序调用泛型方法时，如果擦除返回类型，编译器插入强制类型转换。
8.5.3 翻译泛型方法
如果类型擦除与多态发生了冲突，例如：
public class Datelnterval extends Pair<LocalDate> {
@Override
public void setSecond(LocalDate second) {
if (second.compareTo(getFirst()) >= 0)
super.setSecond(second);
}
...
}
类型擦除之后，成为：
class DateInterval extends Pair {
public void setSecond(LocalDate second) { . . . }
. . .
}
但是 Pair 类型擦除之后的方法是
public void setSecond(Object second)；
覆盖时方法参数类型不一致，这与多态产生了冲突。因此编译器会为 Datelnterval 生成桥方法（bridge method）：
public void setSecond(Object second) { setSecond((LocalDate) second); }
如果为 get 方法生成桥方法，于是在 Datelnterval 类中，有两个 getSecond 方法：
LocalDate getSecond() // defined in DateInterval 中定义的
Object getSecond() // 桥方法，覆盖 Pair 中的方法，调用第一个方法
方法签名（不包含返回值）相同的两个方法是不合法的。
但是在虚拟机中，用参数类型和返回类型确定一个方法。因此，编译器可能产生两个仅返回类型不同的方法字节码，虚拟机能够正确地处理这一情况。
第五章提到的协变返回类型也使用了桥方法
总之，需要记住有关 Java 泛型转换的事实：
- 虚拟机中没有泛型，只有普通的类和方法。
- 所有的类型参数都用它们的限定类型替换。
- 桥方法被合成来保持多态。
- 为保持类型安全性，必要时插人强制类型转换。
8.5.4 调用遗留代码（略）
8.6 约束与局限性
8.6.1 不能用基本类型实例化类型参数
没有Pair<double>，只有Pair<Double>。因为类型擦除之后，Pair 会有 Object 域，而 Object 不能存储 double。
8.6.2 运行时类型查询只适用于原始类型
如：
if (a instanceof Pair<String>) // Error
if (a instanceof Pair<T>) // Error
Pair<String> p = (Pair<String>) a; // Warning--can only test that a is a Pair
其实只能测试 a 是否是一个 Pair。为提醒这一风险，试图查询一个对象是否属于某个泛型类型时，倘若使用 instanceof 会得到一个编译器错误，如果使用强制类型转换会得到一个警告。同样，getClass方法总是返回原始类型。因为虚拟机中的对象总有一个特定的非泛型类型。
8.6.3 不能创建参数化类型的数组
如：
Pair<String>[] table = new Pair<String>[10]; // Error
Object[] objarray = table;
objarray[0] = "Hello"; // Error--component type is Pair
objarray[0] = new Pair<Employee>(); // 可以通过数组存储检査
因此不允许创建（new）参数化类型的数组。但是声明是合法的，可以使用类型转换来初始化。
Pair<String>[] table = (Pair<String>[]) new Pair<?>[10];
当然这样不安全。只有一种安全而有效的方法：ArrayList<Pair<String>>。
8.6.4 Varargs 警告
参数个数可变的方法：
public static <T> void addAll(Collection<T> coll, T... ts)
{
for (t : ts) coll.add(t);
}
// 如下调用：
Collection<Pair<String>> table = . . .;
Pair<String> pair1 = . . .;
Pair<String> pair2 = . . .;
addAll(table, pair1, pair2);
为了调用这个方法虚拟机会创建Pair<String>的数组。不过此时只会得到一个警告，而不是错误。消除这个警告可以用注解@SuppressWarnings("unchecked")或@SafeVarargs。
8.6.5 不能实例化类型变置
不能使用new T(...)或T.class这样的表达式。
想要创建实例可以调用者提供一个构造器表达式或提供class（然后使用Class.newlnstance方法）。
// 1.构造器表达式
Pair<String> p = Pair.makePair(String::new);
public static <T> Pair<T> makePair(Supplier<T> constr)
{
return new Pair<>(constr.get(), constr.get());
}
// 2. 提供class
Pair<String> p = Pair.makePair(String.class);
public static <T> Pair<T> makePair(Class<T> cl)
{
try { return new Pair<>(cl.newInstance(), cl.newInstance()); }
catch (Exception ex) { return null; }
}
8.6.6 不能构造泛型数组
不能new T[...]。
- 构造器表达式或者反射，详见P324
ArrayList.toArray的例子，详见P324
8.6.7 泛型类的静态上下文中类型变量无效
不能在静态域或方法中引用类型变量。
public class Singleton<T> {
private static T singleInstance; // Error
public static T getSingleInstance() // Error
{
if (singleInstance == null) construct new instance of T
return singleInstance;
}
}
声明Singleton<Random>和Singleton<JFileChooser>，然而类型擦除后只剩 Singleton 类，它只有一个 singleInstance 域。
8.6.8 不能抛出或捕获泛型类的实例
既不能抛出也不能捕获泛型类对象。实际上，甚至泛型类扩展 Throwable 都是不合法的。
public class Problem<T> extends Exception { /* . . . */ } // Error--can't extend Throwable
catch 子句中不能使用类型变量：
public static <T extends Throwable> void doWork(Class<T> t) {
try {
do work
}
catch (T e) { // Error--can't catch type variable
Logger.global.info(...)
}
}
不过，在异常规范中使用类型变量是允许的。
public static <T extends Throwable> void doWork(T t) throws T { // OK
try {
do work
}
catch (Throwable realCause) {
t.initCause(realCause);
throw t;
}
}
8.6.9 可以消除对受查异常的检查
8.6.10 注意擦除后的冲突
8.7 泛型类型的继承规则
-
无论 S 与 T 有什么联系，通常，
Pair<S>与Pair<T>没有什么联系。 -
永远可以将参数化类型转换为一个原始类型。但是会有风险，如：
Pair<Manager> managerBuddies = new Pair<>(ceo, cfo);
Pair rawBuddies = managerBuddies; // OK
rawBuddies.setFirst(new File(". . .")); // only a compile-time warning
Manager one = rawBuddies.getFirst(); // 抛出 ClassCastException 异常
- 泛型类可以扩展或实现其他的泛型类。就这一点而言，与普通的类没有什么区别。
例如，ArrayList<T>类实现List<T>接口。这意味着，一个ArrayList<Manager>可以被转换为一个List<Manager>。但是如前面所见，一个ArrayList<Manager>不是一个ArrayList<Employee>或List<Employee>。
8.8 通配符类型
8.8.1 通配符概念
通配符类型中，允许类型参数变化。例如：
Pair<? extends Employee>
它表示类型参数是 Employee 的子类任何泛型 Pair 类型。
Pair<Employee>和Pair<Manager>都是Pair<? extends Employee>的子类型。
使用通配符会通过Pair<? extends Employee>的引用不会破坏Pair<Manager>：
Pair<Manager> managerBuddies = new Pair<>(ceo, cfo);
Pair<? extends Employee> wildcardBuddies = managerBuddies; // OK
wildcardBuddies.setFirst(lowlyEmployee); // compile-time error
因为，Pair<? extends Employee>的方法看起来是这样的：
? extends Employee getFirst()
void setFirst(? extends Employee)
这样将不可能调用 setFirst 方法。编译器只知道需要某个 Employee 的子类型，但不知道
具体是什么类型。它拒绝传递任何特定的类型。毕竟?不能用来匹配。
使用 getFirst 就不存在这个问题：将 getFirst 的返回值赋给一个 Employee 的引用完全合法。
这就是引入有限定的通配符的关键之处：现在已经有办法区分安全的访问器方法和不安全的更改器方法了。
8.8.2 通配符的超类型限定
通配符限定与类型变量限定十分类似，但是它还可以指定一个超类型限定（supertype bound）。
例如，Pair<? super Manager>有方法：
void setFirst(? super Manager)
? super Manager getFirst()
编译器无法知道 setFirst 方法的具体类型，因此调用这个方法时不能接受类型为 Employee 或 Object 的参数。只能传递Manager 类型的对象，或者某个子类型对象。
另外，如果调用 getFirst，不能保证返回对象的类型，只能把它赋给一个 Object。
直观地讲，带有超类型限定的通配符可以向泛型对象写入，带有子类型限定的通配符可以从泛型对象读取。
8.8.3 无限定通配符
如：Pair<?>。
? getFirst()
void setFirst(?)
getFirst 的返回值只能赋给一个 Object 。setFirst 方法不能被调用，甚至传入 Object 对象（但是可以调用setFirst(null)）。但是原始类型 Pair 可以用任意 Object 对象传入其 setFirst 方法。
- 用处在于一些简单操作的可读性更强。如检测一个 pair 是否包含一个 null 引用：
public static boolean hasNulls(Pair<?> p)
{
return p.getFirst() == null || p.getSecond() == null;
}
8.8.4 通配符捕获
public static void swap(Pair<?> p) {
swapHelper(p);
}
public static <T> void swapHelper(Pair<T> p) {
T t = p.getFirst();
p.setFirst(p.getSecond());
p.setSecond(t);
}
注意：swapHelper 是一个泛型方法，而 swap 不是，它具有固定的Pair<?>类型的参数。
在这种情况下，swapHelper 方法的参数 T 捕获通配符。它不知道通配符表示哪种类型，但是是一个确定的类型。
8.9 反射和泛型
Class 类是泛型的。例如，String.class实际上是一个Class<String>类的对象（事实上，是唯一的对象）。
被擦除的类仍然保留了一些关于它们的泛型起源的信息：
public static Comparable min(Comparable[] a)
是由泛型方法擦除的：
public static <T extends Comparable<? super T>> T min(T[] a)
可以使用反射 API 来确定：
- 这个泛型方法有一个叫做 T 的类型参数。
- 这个类型参数有一个子类型限定，其自身又是一个泛型类型。//
Comparable<? super T> - 这个限定类型有一个通配符参数。//
? super T - 这个通配符参数有一个超类型限定。
- 这个泛型方法有一个泛型数组参数。//
T[] a
换句话说，你可以重建关于泛型类和方法的所有信息，就如他们的实现者声明的那样。但是你不会知道特定的对象或方法调用是如何处理类型参数的。
为了表达泛型类型声明，使用java.lang.reflect包中提供的接口Type。这个接口包含下列子类型：
Class类，描述具体类型。Type Variable接口，描述类型变量（如T extends Comparable<? super T>）。WildcardType接口，描述通配符（如？super T）。ParameterizedType接口，描述泛型类或接口类型（如Comparable<? super T>）。GenericArrayType接口，描述泛型数组（如T[]）。
说实话，通配符及后面部分看的云里雾里的。。。。。