【原】带你快速看完9.8分神作《Effective Java》—— 泛型篇

🍊 Java学习：Java从入门到精通总结

🍊 Spring系列推荐：Spring源码解析

📆 最近更新：2021年12月13日

🍊 个人简介：通信工程本硕💪、阿里新晋猿同学🌕。我的故事充满机遇、挑战与翻盘，欢迎关注作者来共饮一杯鸡汤

🍊 点赞 👍 收藏 ⭐留言 📝 都是我最大的动力！

豆瓣评分9.8的图书《Effective Java》，是当今世界顶尖高手Josh Bloch的著作，在我之前的文章里我也提到过，编程就像练武，既需要外在的武功招式（编程语言、工具、中间件等等），也需要修炼心法（设计模式、源码等等）学霸、学神OR开挂

我个人在Java领域也已经学习了近5年，在修炼“内功”的方面也通过各种途径接触到了一些编程规约，例如阿里巴巴的泰山版规约，在此基础下读这本书的时候仍是让我受到了很大的冲激，学习到了很多约定背后的细节问题，还有一些让我欣赏此书的点是，书中对于编程规约的解释让我感到十分受用，并愿意将他们应用在我的工作中，也提醒了我要把阅读JDK源码的任务提上日程。

最后想分享一下我个人目前的看法，内功修炼不像学习一个新的工具那么简单，其主旨在于踏实，深入探索底层原理的过程很缓慢并且是艰辛的，但一旦开悟，修为一定会突破瓶颈，达到更高的境界，这远远不是我通过一两篇博客就能学到的东西。

接下来就针对此书列举一下我的收获与思考。

不过还是要吐槽一下的是翻译版属实让人一言难尽，有些地方会有误导的效果，你比如java语言里extends是继承的关键字，书本中全部翻译成了扩展 就完全不是原来的意思了。所以建议有问题的地方对照英文原版进行语义上的理解。

没有时间读原作的同学可以参考我这篇文章。

---

文章目录

在泛型篇开始介绍之前，要先明确几个书中的术语，以免看得眼花缭乱：

术语	中文含义	举例
Parameterized type	参数化类型	List
Actual type parameter	实际类型参数	String
Generic type	泛型类型	List
Formal type parameter	形式类型参数	E
Unbounded wildcard type	无限制通配符类型	List<?>
Raw type	原始类型	List
Bounded type parameter	限制类型参数
Recursive type bound	递归类型限制	<T extends Comparable>
Bounded wildcard type	限制通配符类型	List<? extends Number>
Generic method	泛型方法	static List asList(E[] a)
Type token	类型令牌	String.class

26 不要使用原始类型（如List）

每一种泛型类型都定义一个原生态类型，例如List<String>对应的原生态类型就是List，他们的存在主要是为了与泛型出现之前的代码兼容。

有了泛型之后，类型声明中可以包含信息，而不是通过注释去提醒：

private final Collection<Stamp> stamps = ....

从这个声明中，编译器知道stamps 集合应该只包含Stamp 实例，错误的插入会生成一个编译时错误消息，提醒具体是哪里出错了：

Test.java:9: error: incompatible types: Coin cannot be converted to Stamp
c.add(new Coin());
         ^

当从集合中检索元素时，编译器会为你插入不可⻅的强制转换

---

如果使用诸如List 之类的原始类型，则会丢失类型安全性，但是如果使用参数化类型（例如List）则不会

原始类型List和参数化类型List 之间有什么区别呢？
前者逃避了泛型检查，而后者明确地告诉编译器，它能够保存任何类型的对象。

可以将List<String> 传递给List 类型的参数，但不能将其传递给List<Object> 类型的参数。泛型有子类型化的规则，List<String> 是原始类型 List 的子类型，但不是参数化类型List<Object> 的子类型

为了更直观的说明，给出下面的代码：

public static void main(String[] args) {
        List<String> strings = new ArrayList<>();
        unsafeAdd(strings, Integer.valueOf(42));
        String s = strings.get(0); // Has compiler-generated cast
    }

    private static void unsafeAdd(List list, Object o) {
        list.add(o);
    }

如果运行该程序，则当程序尝试调用strings.get(0)的结果（一个Integer）转换为一个String 时，会得到ClassCastException 异常。

如果在unsafeAdd的声明中的参数化类型List 替换原始类型List，则编译器直接就会给出报错信息：

但在不确定或不在意集合中元素类型时，可能会用到原始类型。例如编写一个返回两个集合中重复元素个数的程序：

static int numElementsInCommon(Set s1, Set s2) {
int result = 0;
for (Object o1 : s1)
	if (s2.contains(o1))
		result++;
return result;
}

这种方法使用原始类型，是危险的。安全替代方式是使用无限制通配符类型（unbounded wildcard types）。如果要使用泛型类型，但不知道或关心实际类型参数是什么，则可以使用问号来代替。例如，泛型类型 Set<E> 的无限制通配符类型是Set<?>

static int numElementsInCommon(Set<?> s1, Set<?> s2){...}

注意：不能把任何元素（除null之外）放入一个Collection<?> 中，编译器也会报错：

---

“不要使用原始类型”这条规则有几个特例情况：
1. 必须在类签名（class literals）中使用原始类型
例如List.class，String[].class 和int.class 都是合法的，但List<String>.class 和List<?>.class 不合法

2. 因为泛型类型信息在运行时被擦除，所以在<?>以外的参数化类型上使用instanceof是非法的
下面是使用泛型类型的instanceof 运算的示例：

if (o instanceof Set) { // Raw type
	Set<?> s = (Set<?>) o; // Wildcard type
	...
}

一旦确定 o 对象是一个Set，则必须将其转换为通配符Set<?>。这是一个强制转换，所以不会导致编译器警告。

27 消除非受检的警告

这一条告诉我们如何处理非受检的警告。

使用泛型编程时，会看到许多编译器警告：

1. unchecked cast warning，非受检强制转换警告
2. 非受检方法调用警告
3. unchecked parameterized vararg type warning，非受检参数化可变参数类型警告
4. unchecked conversion warning，非受检转换警告

很多非受检警告很容易消除，例如：

Set<Lark> exaltation = new HashSet();

编译器会提醒做错了什么：

根据编译器提示修改：

Set<Lark> exaltation = new HashSet<>();

有些警告非常难消除，但还是要秉承尽可能消除每一个受检警告的原则，如果不能消除警告，但确信引发警告的代码是类型安全的，那么用@SuppressWarnings(“unchecked”)注解来禁止这条警告。

如果在不止一行的方法或构造函数中使用了@SuppressWarnings(“unchecked”)，可以将它移动到一个局部变量的声明中。

例如ArrayList的toArray方法：

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

编译器会有这样一条警告：

ArrayList.java:305: warning: [unchecked] unchecked cast
	return (T[]) Arrays.copyOf(elements, size, a.getClass());
	
required: T[]
found: Object[]

将@SuppressWarnings(“unchecked”)注解放在return语句中是不合法的，因为它不是一个声明，也不要把注解放在整个方法上，而是应该声明一个局部变量来保存返回值，在局部变量上面添加注解：

public <T> T[] toArray(T[] a) {
	if (a.length < size) {
		// This cast is correct because the array we're creating
		// is of the same type as the one passed in, which is T[].
		@SuppressWarnings("unchecked") T[] result = (T[]) Arrays.copyOf(elements, size, a.getClass());
		return result;
	}
	System.arraycopy(elements, 0, a, 0, size);
	if (a.length > size)
		a[size] = null;
	return a;
}

每当使用@SuppressWarnings(“unchecked”) 注解时，都要写一下注释，说明为什么这么做是安全的。

28 列表优于数组

数组与泛型有很大的不同：
1. 数组是协变的（covariant）
意思是：如果Sub是Super的子类型，则数组类型Sub[] 是数组类型Super[] 的子类型。

2. 泛型是不变的（invariant）
对于任何两种不同的类型Type1 和Type2，List<Type1> 既不是List<Type2> 的子类型也不是父类型。

现在有两段代码：

Object[] objectArray = new Long[1];
objectArray[0] = "I don't fit in"; 

List<Object> ol = new ArrayList<Long>(); // Incompatible types
ol.add("I don't fit in");

无论哪种方式都会报错，因为不能把一个String 类型放到一个Long 类型容器中，但是用一个数组的话，在运
行时才会报错；对于列表，可以在编译时就能发现错误。

3. 数组是具体化的，在运行时才知道和强化他们的类型
就比如上面的代码，将String保存到Long数组中就会得到ArrayStoreException异常

4. 泛型在编译时就强化它的类型信息，并在运行时擦除它的元素类型信息

由于上面这些区别，数组和泛型不能很好地混用，所以new List<E>[]，new List<String>，new E[]这些语法都是错误的！在编译时会产生一个泛型数组创建错误。

非法的原因是它不安全，以下面这段代码为例：

List<String>[] stringLists = new List<String>[1]; 	// (1)
List<Integer> intList = List.of(42); 				// (2)
Object[] objects = stringLists; 					// (3)
objects[0] = intList; 								// (4)
String s = stringLists[0].get(0); 					// (5)

• 假设第1行创建一个泛型数组是合法的
• 第2行创建并初始化包含单个元素的List<Integer>
• 第3行将List<String> 数组存储到Object数组变量中，这是合法的，因为数组是协变的
• 第4行将List<Integer> 存储在Object数组的唯一元素中，这是因为泛型是通过擦除来实现的：List<String>[] 实例是List[]，所以这个赋值不会产生ArrayStoreException 异常

现在问题就来了，我们将一个List<Integer> 实例存储到一个声明为List<String> 实例的数组中，为了防止这种情况出现，第一行必须报错。

E，List<E> 和List<String> 等在技术上被称为不可具体化的类型，指其运行时表示法包含的信息比它的编译时表示法包含的信息更少。唯一可具体化的参数化类型是无限制的通配符类型，如List<?>等，创建无限制通配符类型的数组是合法的，但并不常用。

当泛型数组创建错误时，最佳解决方案是使用集合类型List<E> 。例如编写一个带有集合的Chooser类和一个方法，方法返回集合中随机选择的一个元素。

public class Chooser {
    private final Object[] choiceArray;
    
    public Chooser(Collection choices) {
        choiceArray = choices.toArray();
    }
    
    public Object choose() {
        Random rnd = ThreadLocalRandom.current();
        return choiceArray[rnd.nextInt(choiceArray.length)];
    }
}

上面这种写法必须将choose方法的返回值从Object转换成每次调用该方法时想要的类型

public class Chooser<T> {
	private final T[] choiceArray;
	
	public Chooser(Collection<T> choices) {
		choiceArray = choices.toArray();
	}

	// choose 方法不变
}

上面的类会报错：

如果加一条强制类型转换的话：

choiceArray = (T[]) choices.toArray();

仍有报警信息：

要消除上面的警告，需要用列表代替数组：

public class Chooser<T> {
    private final List<T> choiceList;

    public Chooser(Collection<T> choices) {
        choiceList = new ArrayList<>(choices);
    }

    public T choose() {
        Random rnd = ThreadLocalRandom.current();
        return choiceList.get(rnd.nextInt(choiceList.size()));
    }
}

---

总结一下，数组和泛型有着截然不同的类型规则：
1. 数组是协变且可以具体化的
2. 泛型是不可变的且可以被擦除的

29 优先考虑泛型

每个程序员都应该学习如何编写泛型

以一个简单的栈类实现为例：

public class Stack {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    public Stack(){
        elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(Object e){
        ensureCapacity();
        elements[size ++] = e;
    }

    public Object pop(){
        if (size == 0)
            throw new EmptyStackException();
        Object result = elements[-- size];
        elements[size] = null;
        return result;
    }

    public boolean isEmpty(){
        return size == 0;
    }

    private void ensureCapacity() {
        if (elements.length == size)
            elements = Arrays.copyOf(elements,  2 * size + 1);
    }
}

第一步用相应的类型参数替换所有的Object类型：

public class Stack<E> {
    private E[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    public Stack(){
        elements = new E[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(E e){
        ensureCapacity();
        elements[size ++] = e;
    }

    public E pop(){
        if (size == 0)
            throw new EmptyStackException();
        E result = elements[-- size];
        elements[size] = null;
        return result;
    }
	
	// 其他的不变
}

这个类产生一个错误：

如条目28所述，你不能创建一个不可具体化类型E的数组。解决这个问题一般有两个方法：
1. 创建一个Object数组，将它转换成泛型数组类型

这里需要确保unckecked cast不会危及程序的安全性：相关的数组（elements）保存在一个private的域中，永远不会返回给客户端或传递给任何其他方法。

由于构造方法只包含未经检查的数组创建，所以在整个构造方法中抑制警告。

2. 将elements的类型从E[] 更改为Object[]
这样会得到一条不同的错误：

可以把从数组中获取到的元素强制转换为E，这样就得到了一条警告：

根据第27条，只在这个局部上抑制警告，而不是在整个pop方法上：

上面两个方法，第一个方法可读性更强：数组被声明为E[ ]类型以清晰地表示它只包含E实例；第一个方法更简洁：第一种方法只需在创建数组的时候转换一次，第二种方法每次读取一个数组元素时都需要转换一次。

Stack类的具体用法如下，下列代码以倒叙形式打印出命令行参数：

public static void main(String[] args) {
   Stack<String> stack = new Stack<>();
    for (String arg : args){
        stack.push(arg);
    }
    while (!stack.isEmpty())
        System.out.println(stack.pop().toUpperCase());
}

---

有一些泛型限制了可允许的类型参数值，例如：

class DelayQueue<E extends Delayed> implements BlockingQueue<E>

要求实际的类型参数E 是java.util.concurrent.Delayed的子类型

30 优先考虑泛型方法

静态工具方法尤其适合于泛型化

编写泛型方法类似于编写泛型类：

public static Set union(Set s1, Set s2) {
	 Set result = new HashSet(s1);
	 result.addAll(s2);
	 return result;
}

上面的类有两个警告信息：

如果修复这些警告，要将方法声明修改为声明一个类型参数：

public static <E> Set<E> union(Set<E> s1, Set<E> s2) {
	Set<E> result = new HashSet<>(s1);
	result.addAll(s2);
	return result;
}

这个例子中，类型参数列表是，返回类型是Set

使用上面的方法也很简单：

public static void main(String[] args) {
	Set<String> guys = Set.of("Tom", "Dick", "Harry");
	Set<String> stooges = Set.of("Larry", "Moe", "Curly");
	Set<String> aflCio = union(guys, stooges);
	System.out.println(aflCio);
}

上面代码的运行结果会输出：[Moe, Tom, Harry, Larry, Curly, Dick]

union 方法的一个限制是所有三个集合（输入参数和返回值）的类型必须完全相同。通过使用限定通配符类型（bounded wildcard types）（Set<? extends xxx>），可以使该方法更加灵活。

除此之外，还有递归类型限制（recursive type bound）的概念：通过包含类型参数本身的表达式来限制类型参数。

递归类型限制的一个经典用法和Comparable接口有关：

public interface Comparable<T> {
	int compareTo(T o);
}

类型参数T，可以与实现Comparable<T> 的类型的元素进行比较。例如，String 类实现了Comparable<String>，Integer 类实现了Comparable<Integer>，几乎所有类型都只能与同类型的元素比较。

---

public static <E extends Comparable<E>> E max(Collection<E> c);

<E extends Comparable <E >> 可以理解为「任何可以与自己比较的类型E」

下面的代码实现了计算最大值的功能：

public static <E extends Comparable<E>> E max(Collection<E> c) {
	if (c.isEmpty())
		throw new IllegalArgumentException("Empty collection");
	
	E result = null;
	
	for (E e : c)
		if (result == null || [e.compareTo(result](http://e.compareTo(result)) > 0)
	 		result = Objects.requireNonNull(e);
	
	return result;
}

这里更好的选择是返回一个Optional<E>，这一点将在后面说明

31 利用限定通配符来提升API的灵活性

相对于提供的不可变的类型，有时需要更多的灵活性，在第29条里写了一个Stack的API：

public class Stack<E> {
	public Stack();
	
	public void push(E e);
	
	public E pop();
	
	public boolean isEmpty();
}

如果要添加一个方法来将多个元素放到栈里：

public void pushAll(Iterable<E> src) {
    for (E e : src)
         push(e);
}

如果此时声明了一个Stack<Number>，尝试插入Integer数据就会报错：

Stack<Number> numberStack = new Stack<>();
Iterable<Integer> integers = ... ;
numberStack.pushAll(integers);

Java提供了一种特殊的参数化类型——限定通配符类型（bounded wildcard type），pushAll的输入参数类型应该是「E的某个子类型的Iterable接口」，用代码表示就是Iterable<? extends E>：

public void pushAll(Iterable<? extends E> src) {
   for (E e : src)
         push(e);
}

假设还想写一个popAll方法，与pushAll方法相对应：popAll方法从栈中弹出每个元素并将元素添加到给定的集合中。

public void popAll(Collection<E> dst) {
     while (!isEmpty())
         dst.add(pop());
}

假设有一个Stac<Number> 和Collection<Object> 类型的变量，从栈中弹出一个元素并将其存储在该变量中：

Stack<Number> numberStack = new Stack<Number>();
Collection<Object> objects = ... ;
numberStack.popAll(objects);

会得到与第一版pushAll 非常类似的错误：Collection<Object> 不是Collection<Number> 的子类型。popAll的输入参数的类型不应该是「E的集合」，而应该是「E的某个父类型的集合」。使用Collection<? super E>修改上面的代码：

public void popAll(Collection<? super E> dst) {
     while (!isEmpty())
         dst.add(pop());
}

所以结论就很明显：为了获得最大的灵活性，对代表生产者和消费者的输入参数使用通配符类型。

PECS

这是一个记忆的口诀，producer-extends，consumer-super：

如果一个参数化类型代表一个T 生产者，使用<? extends T>；如果它代表T 消费者，则使用<? super T>。

Stack 示例中，pushAll方法的src 参数生成栈使用的E 实例，因此src的合适类型为Iterable<? extends E>；popAll方法的dst 参数消费Stack 中的E 实例，因此dst的合适类型是Collection <? super E>。

下面就用一些例子来说明这个口诀如何使用的：

1. 第28条中的Chooser类构造方法

public Chooser(Collection<T> choices)

这个构造方法只使用集合选择来生产类型T的值，所以它的声明应该使用一个extends T的通配符类型：

public Chooser(Collection<? extends T> choices)

2. 30条中的union 方法

public static <E> Set<E> union(Set<E> s1, Set<E> s2)

两个参数s1和s2都是E的生产者：

public static <E> Set<E> union(Set<? extends E> s1, Set<? extends E> s2)

注意，返回类型仍然是Set。不要使用限定通配符类型作为返回类型，修改之后的用法如下：

Set<Integer> integers = Set.of(1, 3, 5);
Set<Double> doubles = Set.of(2.0, 4.0, 6.0);
Set<Number> numbers = union(integers, doubles);

3. 第30条中的max 方法

public static <T extends Comparable<T>> T max(List<T> list)

修改之后的声明为：

public static <T extends Comparable<? super T>> T max(List<? extends T> list)

为了从原来到修改后的声明，需要应用两次PECS，先应用到参数 list，它产生T 实例，所以将类型从List<T>更改为List<? extends T>；最初，T 被指定为继承Comparable<T>，但 Comparable 的 T 消费 T 实例，所以使用Comparable<? super T> 代替 Comparable<T>

通过这个例子也可以得到两条结论：

1. 使用Comparable<? super T> 优于Comparable<T>
2. 使用Comparator<? super T> 优于Comparator<T>

32 合理地结合泛型和可变参数

可变参数和泛型不能很好的搭配使用，可变参数的目的是允许客户端将一个可变数量的参数传递给一个方法，但这是一个脆弱的抽象（leaky abstraction）：当你调用一个可变参数方法时，会创建一个数组来保存可变参数

当参数化类型的变量引用不属于该类型的对象时会发生堆污染

例如：

static void dangerous(List<String>... stringLists) {
	List<Integer> intList = List.of(42);
	Object[] objects = stringLists;
	objects[0] = intList; // Heap pollution
	String s = stringLists[0].get(0); // ClassCastException
}

此方法没有可⻅的强制转换，但在调用一个或多个参数时抛出ClassCastException异常。所以将值保存在泛型可变参数数组参数中是不安全的。

这个例子引发了一个有趣的问题：为什么声明一个带有泛型可变参数的方法是合法的，当显式创建一个泛型数组是非法的呢？

答案是：具有泛型的可变参数的方法在实践中可能非常有用，例如Arrays.asList(T... a)，Collections.addAll(Collection<? super T> c, T... elements)，EnumSet.of(E first, E... rest)，因此设计人员选择忍受这种不一致。

在Java 7中，增加了@SafeVarargs注解，@SafeVarargs注解表示了作者对该方法是类型安全的承诺，对于每一个带有泛型可变参数的方法，都要用@SafeVarargs注解。

注意：如果不在可变参数的数组中保存任何值，这也可能破坏类的安全性，例如：

static <T> T[] toArray(T... args) {
	return args;
}

上面的代码看起来没什么，但实际上它很危险：该数组的类型由传递给方法的参数的编译时类型决定，由于此方法返回其可变参数数组，它可以将堆污染传播到调用栈上。

举个例子你就明白了：

static <T> T[] pickTwo(T a, T b, T c) {
	switch(ThreadLocalRandom.current().nextInt(3)) {
		case 0: return toArray(a, b);
		case 1: return toArray(a, c);
		case 2: return toArray(b, c);
	}
	throw new AssertionError(); // Can't get here
}

编译器会生成代码，以创建一个可变参数数组，将两个T实例传递给toArray，toArray方法的返回值是Object[ ]，就容易像dangerous一样产生堆污染，例如：

public static void main(String[] args) {
	String[] attributes = pickTwo("Good", "Fast", "Cheap");
}

当运行它时，抛出一个ClassCastException异常，原因是pickTwo返回的值上产生了一个隐藏的String[ ]转换，Object不是String的子类，所以会报错。

所以允许另一个方法访问一个泛型的可变参数数组是不安全的，但有两种情况例外：

1. 将数组传给用@SafeVarargs注解过的方法
2. 将数组传给一个非可变参数的方法，该方法仅计算数组内容部分

下列代码是一个安全使用泛型可变参数的典型例子，将入参合并为一个List：

@SafeVarargs
static <T> List<T> flatten(List<? extends T>... lists) {
	List<T> result = new ArrayList<>();
	for (List<? extends T> list : lists)
		result.addAll(list);
	return result;
}

在下列情况下，泛型可变参数方法是安全的：

1. 它没有在可变参数数组中保存任何值
2. 它不会使数组（或克隆）对不可信代码可⻅

SafeVarargs注解只能用在无法被覆盖的方法上，因为不可能保证每个重写方法都是安全的。在Java 8中，该注解仅能用在static和final方法上。

如果不想用SafeVarargs注解，可以采用第28条里面的建议，用一个List参数代替可变参数：

static <T> List<T> flatten(List<List<? extends T>> lists) {
	List<T> result = new ArrayList<>();
	for (List<? extends T> list : lists)
		result.addAll(list);
	return result;
}

可以将此方法与静态工厂方法List.of 结合使用，来允许可变数量的参数：

audience = flatten(List.of(friends, romans, countrymen));

这种方法的优点是编译器可以证明这种方法是类型安全的。

List.of 声明使用了@SafeVarargs 注解

这个技巧也可以用在toArray方法上：

static <T> List<T> pickTwo(T a, T b, T c) {
	switch(rnd.nextInt(3)) {
		case 0: return List.of(a, b);
		case 1: return List.of(a, c);
		case 2: return List.of(b, c);
	}
	throw new AssertionError();
}

main 方法变成这样：

public static void main(String[] args) {
	List<String> attributes = pickTwo("Good", "Fast", "Cheap");
}

生成的代码是安全的，因为它只使用了泛型，没有用到数组。

33 优先考虑类型安全的异构容器

泛型最常用于集合，Set<E>、Map<K, V>等，以及单个元素的容器，ThreadLocal<T>、AtomicReference<T>等，这里有一个限制就是每个容器只能有固定数量的泛型参数。

有时需要更多的灵活性，例如数据库有很多列，如果能安全地访问所有列就好了，其实这个需求借助Map就可以实现，将key进行参数化替代将容器参数化。

以Favorites类为例，它允许其客户端保存和检索任意多种类型的favorite实例：

public class Favorites {
    public <T> void putFavorite(Class<T> type, T instance) {...};
    public <T> T getFavorite(Class<T> type) {...};
}

Class对象将扮演参数化key的一部分，入参的类型变为Class<T>

例如：String.class的类型为Class<String>，Integer.class的类型为Class<Integer>。

当一个类的字面被用在方法中时，被称为类型令牌。

下面是API的用法：

public static void main(String[] args) {
   Favorites f = new Favorites();
    f.putFavorite(String.class, "Java");
    f.putFavorite(Integer.class, 0xcafebabe);
    f.putFavorite(Class.class, Favorites.class);

    String favoriteString = f.getFavorite(String.class);
    int favoriteInteger = f.getFavorite(Integer.class);
    Class<?> favoriteClass = f.getFavorite(Class.class);
    System.out.printf("%s %x %s%n", favoriteString,
            favoriteInteger, favoriteClass.getName());
}

上面的输出结果是：Java cafebabe Favorites

• Favorites是类型安全的：当请求String时不会返回其他的类型；
• Favorites也是异构的，所有Key都是不同类型的。

所以Favorites就是一个类型安全的异构容器

public class Favorites {
    private Map<Class<?>, Object> favorites = new HashMap<>();

    public <T> void putFavorite(Class<T> type, T instance){
        favorites.put(Objects.requireNonNull(type), instance);
    };

    public <T> T getFavorite(Class<T> type){
        return type.cast(favorites.get(type));
    };
}

favorites的Map的value类型是Object，所以Map并不能保证key - value的类型一定相同

• getFavorite方法的先从favorites的映射中获得与指定Class对象对应的值，它的类型只是个Object，但我们需要返回一个T，所以使用了cast方法将对象引用动态转换成Class对应的类型

• cast方法只检验它的参数是否为Class对象所表示的类型的实例，如果是则返回参数，否则就抛出ClassCastException异常

确保Favorites不违背它的类型约束条件的方式是在插入元素的时候检查一下待插入元素的类型：让putFavorite方法检验instance是否真的是type所表示的类型的实例：

有一些集合包装类采用了同样的技巧，如checkSet、checkedList、checkedMap

此外Favorites类也不能用在不可具体化的类型中，即可以保存最喜爱的String或String[ ]，但不能保存List<String>。原因是List<String>.class语法错误，但这也是一件好事，防止List<String>和List<Integer>共享同一个Class 对象（List.class）

---

有时可能我们要限制可传递给方法的类型。这可以通过有限制的类型令牌（bounded type token）来实现。

Java里面注解API就广泛使用了有限制的类型令牌，例如：

public <T extends Annotation> T getAnnotation(Class<T> annotationType);

入参 annotationType 是表示注解类型的有限值的类型令牌。如果element有这种类型的注解，该方法返回

被注解元素的本质上是一个类型安全的异构容器，key是注解类型

假设有一个Class<?>类型的对象，将它传给getAnnotation时，可以将对象转换成Class<? extends Annotation>，这种转换是unchecked的，所以会有编译时警告。Class提供了一个安全执行这种转换的方法：asSubClass，它将调用它的Class对象转换成入参类的一个子类：

static Annotation getAnnotation(AnnotatedElement element, String annotationTypeName) {
    Class<?> annotationType = null; // Unbounded type token
    try {
        annotationType = Class.forName(annotationTypeName);
    } catch (Exception ex) {
        throw new IllegalArgumentException(ex);
    }
    return element.getAnnotation(
            annotationType.asSubclass(Annotation.class));
}