简单泛型
1.泛型的主要目的之一就是用来指定容器要持有什么类型的对象，而且由编译器来保证类型的正确性。
2.Java泛型的核心概念：告诉编译器想使用什么类型，然后编译器帮你处理一切细节。
一.一个元组类库
1.元组（tuple）：它是将一组对象直接打包储存于其中的一个单一对象。
2.下面程序是一个二维元组，它能够持有两个对象：
public class TwoTuple {
public final A first;
public final B second;
public TwoTuple(A a, B b) {
first = a;
second = b;
}
public String toString() {
return "(" + first + ", " + second + ")";
}
}
客户端程序可以读取first或second所引用的对象，然后可以随心所欲地使用这两个对象。但是，它们却无法将其他值赋予first或second。因为final声明为你买了安全保险，实现了Java编程的安全性原则，而且这种格式更加简洁明了。
3.我们可以利用继承机制实现更长的元组。
一个堆栈类
1.不用LinkedList，自己实现的内部链式存储机制：
public class LinkedStack {
private static class Node {
U item;
Node next;
Node() {
item = null;
next = null;
}
Node(U item, Node next) {
this.item = item;
this.next = next;
}
boolean end() {
return item == null && next == null;
}
}
private Node top = new Node();
public void push(T item) {
top = new Node(item, top);
}
public T pop() {
T result = top.item;
if (!top.end()) {
top = top.next;
}
return result;
}
}
2.另一个例子RandomList：假设我们需要一个持有特定类型对象的列表，每次调用其上的select()方法时，它可以随机地选取一个元素：
class RandomList {
private ArrayList storage = new ArrayList();
private Random rand = new Random(47);
public void add(T t) {
storage.add(t);
}
public T select() {
return storage.get(rand.nextInt()storage.size());
}
}
泛型方法
1.可以在类中包含参数化方法，而这个方法所在的类可以是泛型类，也可以不是泛型类。也就是说，是否拥有泛型方法，与其所在的类是否是泛型没有关系。
2.如果使用泛型方法可以取代将整个类泛型化，那么就应该只使用泛型化，另外对于一个static方法而言，无法访问泛型类的类型参数，所以如果static方法需要使用泛型能力，就必须使其成为泛型方法。
3.要定义泛型方法，只需将泛型参数列表置于返回值之前：
public void f(T x) {
System.out.println(x.getClass().getName());
}
如果调用f()时传入的是基本类型，自动打包机制就会介入其中，将基本类型的值包装为对应的对象。
一.可变参数与泛型方法
1.泛型方法与可变参数列表能够很好的共存：
//和java.util.Arrays.asList()方法功能相同
public static List makeList(T... args) {
List result = new ArrayList();
for (T items : args) {
result.add(item);
}
return result;
}
二.简化元组的使用
1.我们现在可以重新编写之前的元组工具，使其成为更通用的工具类库：
public class Tuple {
public static TwoTuple tuple(A a, B b) {
return new TwoTuple(a, b);
}
......
}
下面是一个测试类：
public class TupleTest {
static TwoTuple f() {
return Tuple.tuple("hi", 47);
}
static TwoTuple f2() {
return Tuple.tuple("hi", 47);
}
public static void main(String... args) {
TwoTuple ttsi = f();
System.out.println(f());
System.out.println(f2());
}
}
/*
Output:
(hi, 47)
(hi, 47)
*/
在这里，方法f()返回一个参数化的TwoTuple对象，而f2()返回的是非参数化的TwoTuple对象。编译器并没有关于f2()的警告信息，因为我们并没有将其返回值作为参数化对象使用。在某种意义上，它被“向上转型”为一个非参数化的TwoTuple。然而，如果试图将f2()的返回值转型为参数化的TwoTuple，编译器就会发出警告。
擦除的神秘之处
1.ArrayList
public class Test {
public static void main() {
Class c1 = new ArrayList().getClass();
Class c2 = new ArrayList().getClass();
if (c1 == c2)
System.out.println("true");
System.out.println(Arrays.toString(c1.getTypeParameters()));
System.out.println(Arrays.toString(c2.getTypeParameters()));
}
}
/*
Output:
true
[E]
[E]
*/
首先我们可以看到，上面的程序会认为它们是相同的类型。另外，程序中使用的Class.getTypeParameters()可以返回一个TypeVariable对象数组，表示有泛型声明所声明的类型参数，但是我们能够发现的只有用作参数占位符的标识符。因此我们得出结论：在泛型代码内部，无法获得任何有关泛型参数类型的信息。
2.Java泛型是使用擦除来实现的，这意味着当你在使用泛型时，任何具体的类型信息都被擦除了，你唯一知道的就是你在使用一个对象。因此List
3.由于擦除，在使用泛型时，这些类型参数都会被当作Object进行处理。
一.擦除的问题
1.泛型不能用于显式地引用运行时类型的操作之中，例如转型、instanceof操作和new表达式。
2.为了关闭由于没有使用泛型的警告，Java提供了一个注解：
@SuppressWarnings("unchecked")
这个注解被放置在可以产生这类警告的方法之上，而不是整个类上。
二.边界处的动作
public class ArrayMaker {
private Class kind;
private 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))
}
}
/*
Output:
[null, null, null, null, null, null, null, null, null]
*/
上面这段代码中，由于擦除，kind实际被储存为Class，没有任何参数。因此Array,newInstance()中并没有收到任何具体的类型信息，因此必须转型。
注意，对于在泛型中创建数组，使用Array.newInstance()是推荐的方式。
2.因为擦除在方法体中移除了类型信息，所以在运行时的问题就是边界：即对象进入和离开方法的地点。这些正是编译器执行类型检查并插入转型代码的地点。
3.在泛型中所有的动作都发生在边界处——对传递进来的值进行额外的编译期检查，并插入对传递出去的值的转型。典型的情况就是在get()和set()方法中使用泛型。
擦除的补偿
1.擦除丢失了在泛型代码中执行某些操作的能力。任何在运行时需要知道的确切类型信息的操作都将无法工作：
public class Erased {
private final int SIZE = 100;
public static void f(Object arg) {
if (arg instanceof T) {) //ERROR
T var = new T(); //ERROR
T[] array = new T[SIZE]; //ERROR
T[] array = (T) new Object[SIZE]; //ERROR
}
}
一.创建类型实例
1.上面的程序中对创建一个new T()的尝试无法实现，部分原因是因为擦除，而另一部分原因是因为编译器不能验证T具有默认（无参）构造器。
2.对于上面这个问题Java的解决方法是使用工厂对象来创建新的实例，建议使用显式工厂，并限制其类型，使得只能接受实现了这个工厂的类：
interface Factory {
T create();
}
class Foo {
private T x;
public > Foo(F Factory) {
x = factory.create();
}
}
class IntegerFactory implements Factory {
public Integer create() {
return new Integer(0);
}
}
class Widget {
public static class WidgetFactory implements Factory {
public WidgetFactory create() {
return new Widget();
}
}
}
public class FactoryConstraint {
public static void main(String... args) {
new Foo(new IntegerFactory());
new Foo(new Widget.WidgetFactory());
}
}
二.泛型数组
1.不能直接创建泛型数组，一般想要达到相同效果的方法是在任何想要创建泛型数组的地方都使用ArrayList。
2.如果一定要创建一个泛型数组，唯一的方式就是创建一个被擦除类型的新数组，然后对其转型：
class Generic {}
class ArrayOfGeneric {
static Generic gia;
public static void main(String... args) {
gia = (Generic[]) new Generic[10];
}
}
3.因为有了擦除数组的运行时类型就只能是Object[]。如果我们立即将其转型为T()，那么在编译期该数组的实际类型就将丢失。因此，最好时机在集合内部使用Object[]，然后当你使用数组元素时，添加一个对T[]对转型：
class GenericArray {
private Object[] array;
public GenericArray(int size) {
array = new Object[size];
}
public void put(int index, T item) {
array[index] = item;
}
@SupressWarnings("unchecked")
public T get(int index) {
return (T) array[index];
}
}
但如果试着将Object[]转型为T[]是不行的，因为，没有任何方式可以推翻底层数组类型，它只能是Object[]。
4.下面是对上面代码对一种改进，ArrayList中就使用了这种形式对转型：
public class GenericArrayWithTypeToken {
private T[] array;
@SupressWarnings("unchecked")
public GenericArrayWithTypeToken(Class type, int size) {
array = (T[]) Array.newInstance(size, type);
}
public void put(int index, T item) {
array[index] = item;
}
public T get(int index) {
return (T) array[index];
}
}
边界
1.边界使得我们可以在用于泛型的类型参数类型上设置限制条件。因为擦除了类型信息，所以可以用无界泛型参数调用的方法只是那些可以用 Object调用的方法。但是，如果能够将这个参数限制为某个类型子集，那就可以用类型子集来调用方法。
2.为了执行对泛型参数的限制，Java重用了extends关键字。
3.对泛型进行参数限制也有多继承，并且也可以通过继承消除冗余：
interface A{}
interface B {}
class C{}
class D extends C implements A, B {}
class E {}
class F {
public F() {
E e = new E();
}
}
4.下面的程序展示了如何在继承的每个层次上添加边界限制：
class A {
void set();
}
class B {
T item;
public B(T item) {
this.item = item;
}
}
class C extends B {
T item;
public C(T item) {
this,item = item;
item.set();
}
}
上面的程序中B直接持有一个对象，因此这种行为被继承到了C中，它也要求其参数与A一致。