1， 泛型机制是JAVA5才支持，使用泛型机制编写的代码比那些杂乱地使用Object变量，然后再强制类型转换的代码具有更好的安全性和可读性。
泛型程序设计意味着编写的代码可以被很多不同类型的对象所重用，在泛型出来以前，泛型程序设计是继承Object来实现的。但是有缺点：1，当获取一个值必须要强制类型转换。2，没有类型检查错误，运行时才会出错。泛型提供了类型参数，解决了此问题。
2， 定义泛型类（generic class）。格式：
public class Pair<T, U>{.....}
T ,U 为类型变量
类定义中的类型变量指定方法的返回类型以及域和局部变量的类型，如
private T var;
public T getFirst( T a) {
return var;
}
调用时：Pair<String, Integer>
泛型方法，格式：
class ArrayLog {
public static <T> getmiddle(T ...a)
{
return a[a.length];
}
}
这是在普通类中定义的，不是在泛型类中定义的，这是一个泛型方法。类型变量放在修饰符的后面，返回类型的前面。(既可以定义在普通类中，也可以定义在泛型类中)。
调用时，在方法名前加入具体的类型(大多数情况下，编译器能够推断出来，寻找共同的超类型）。
3， 类型变量的限定，类和方法需要对类型变量加以约束。
T extends Parents ; 上限定，表示T是Parents的子类型。
有多个限定可以用"&"符号隔离类型变量，可以有多个接口，但是至多只有一个类。
4， 虚拟机中没有泛型类型，所有的对象都是普通类。
无论什么时候定义个泛型类型，都提供了一个原始类型(raw type)，原始数据类型名字就是删去类型参数后的泛型类型名。擦出类型变量，并替换限定类型(无限定替换为Object).
原始类型用第一个限定的类型变量来替换，如果没有就用Object来替换。
翻译类型表达式：
当调用泛型方法时，如果擦出返回类型，编译器将会插入强制类型转换。例：
Pair <Employer> budies =...
Employer buddy = buddies.getFirst()；
编译器将会插入强制类型转换代码。
当存取一个泛型域时也要强制插入类型转换代码。
翻译泛型方法，方法的擦出带来了两个问题。例子：
class DateInterval extends Pair<Date> {
public void setSecond(Date second)
{
.....
}
...}
然而当擦出后，变成：
class DateInteval extends Pair {
public void setSecond(Date second) {
}
}
然而还存在着父类中继承的setSecond方法，public void setSecond(Object second);
希望调用具有多态性，所以需要生成一个桥方法（brige method）。
public void setSecond(object second) {
setSecond((Date) second);
}
还有可能存在两个返回值类型不同的方法：
Date getSecond() {
return (Date) super.getSecond().clone() ;
} 自己定义
Ojbect getSecond()覆盖继承。
不能这样写代码，但是编译器能正确处理，虚拟机也能正确处理,比如clone方法。
总之：需呀记住以下 泛型转化事实
虚拟机中没有泛型类型
所有的类型参数都用他们的限定类型代替
桥方法被合成保持多态
为保持类型安全，必须要插入强制类型转换
5， 约束和局限性
不能用基本类型数据作为类型化参数。
运行时类型查询只适用与原始数据，只要使用instaceof或者强制类型转换涉及到泛型类型时，都会有一个都会有一个编译器警告。
不能创建参数化类型的数组，但是允许声明类型化数组。Pair<String> [] p = new Pair<String>[10];//ERROR
可变参数传递一个泛型参数，只会产生警告，而不是出错。
不能实例化类型变量，如new T().T.class等。
first = T.class.newInstance()//error
但可以这样设计： pulic static <T> Pair<T> makePair (Class<T> cl) {
{
try { return new Pair<> (cl.newInstance(), cl.newInstance()) }
catch(Exception ex) { return null;}
}
Pair<String>p = Pair.makePair(String.class);
不能创建泛型数组：T [] P = new T[10]//error; 相当于 object [] p = new object [10];
如果有类型变量，可以这样，如：
public static <T extends Comparable> T[] minamx(T ...a) {
T[] mm = (T[]) Array.newInstance(a.getClass.getComponentType(), 10);
}
例如Arrays类中的，Object[] toArray(); T[] toArray(T[] result);
不能再静态域或方法中引用类型变量。
不能抛出或捕获泛型类的实例。Public class Problem<T exents exceptino>{...}//error
Catch字句不能使用类型变量。catch (T e) //error .
不过在异常规范中使用是正常的。
public static <T extends Throwable> void doWork(T t) throw T
{
try {
do work;
} catch (Throw realcautse) {
t.initCase(realcasu) ;
throw t;
}
}
可以用来消除对已检查异常的检查。必须为每个已检查异常提供一个处理器，在线程中麻烦。可以简化：
public Block{
public static <T extends Throwable> void throwAs(Throwable e ) throw T
{
throw (T) e;
}
}
以下代码将会转化为未检查异常：
try {
do work
} catch ( Throwable t ) {
Block.<Exceptions>throwAs(t);
}
在多线程中非常有用：用户只需要覆盖body方法来提供一个具体调用toThread时，会得到Thread类的对象，它的run方法不会介意已检查的异常。欺骗了编译器。
public abstract class Block{
publci abstract void body() throws Exception;
public Thread toThread() {
return new Thread() {
public void run() {
try {
body();
}
catch (Throwable t) {
Block.<RuntimeException> throwAs(t);
}
};
}
public static <T extends Throwable> void throwAs(Throwable e ) throw T
{
throw (T) e;
}
}
当泛型类型擦出时，无法创建引发冲突的条件。
class Pair<T>{
public boolean equals( T o){ //error
return true;
}
类型擦除后，并没有覆盖Ojbect中的equals方法。是重载，但是两个有冲突。
要想支持擦出转换，就需要强行限制一个类或类型变量不能同时成为两个接口类型的子类，而这两个接口是同一接口的不同参数。
6， 泛型通配符：？extends Parents ：上限： ？ super Son :下限，超类型。