标签：
1. 泛型类
泛型类就是具有一个或者多个类型变量的类，在Java集合框架中大量使用了泛型类。通过泛型编程可以使编写的代码被很多不同的类型所共享，大大提高了代码的重用性。
下面给出一个自定义泛型类的例子：
public class Pair<T> { private T first; private T second; 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 first) { this.first = first; } public void setSecond(T second) { this.second = second; } }
使用普通的类名替换类型变量T就可以实例化泛型类型，如：Pair<String>，Java的泛型类类似于C++的模板类。
2. 泛型方法
Java还可以定义带有类型参数的方法，即泛型方法，泛型方法可以定义在泛型类中，也可以定义在普通类中。
public class ArrayHelper { public static <T> T getMiddle(T[] array) { return array[array.length / 2]; } }
上述的泛型方法，参数是泛型数组，返回值是泛型变量，在修饰符后面跟有<T>表示这是泛型方法。调用一个泛型方法时在方法名前的"<>"加入具体类型，如：ArrayHelper.<String>getMiddle(new String[]{"left","middle","right"}) ，其实大多数情况下也可以省略<String>。
3. 类型变量的限定
有些时候，我们希望能使用不同的类型，但又希望这类型能满足某些约束条件，这就要依靠对类型变量的限定。
public class ArrayHelper { public static <T> T max(T[] array) { T max = array[0]; for(int i = 1; i < array.length; i++) if(array[i].compareTo(max) > 0) max = array[i];
return max; } }
我们希望使用compareTo方法来比较泛型数组中的每个元素，从而选择出最大的那个元素，而这就要求类型必须实现了Comparable接口，我们就可以对类型变量T作出如下限定:
public class ArrayHelper { public static <T extends Comparable> T max(T[] array) { T max = array[0]; for(int i = 1; i < array.length; i++) if(array[i].compareTo(max) > 0) max = array[i];
return max; } }
一个类型变量可以有多个限定，如: <T extends Comparable & Serializable> 。
4. 类型擦除
我们定义一个泛型类型后，就可以适配多种不同的类型，然而实际上虚拟机只知道一个原始类型，例如，对于上面定义个Pair<T>，其对应的原始类型如下:
public class Pair { private Object first; private Object second; 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 first) { this.first = first; } public void setSecond(Object second) { this.second = second; } }
即将T替换成了Object类，实际上是将T替换成限定的类型。假设<T extends Comparable>，则就会将T替换成Comparable，如果有多个限定类型，则替换成第一个限定类型。如果没有限定类型，就替换成Object类，这个过程即类型擦除。
所以泛型类编译成字节码后就是一个普通的类。
5. 泛型类的继承规则
（1）假设有一个print方法打印雇员对，参数是Pari<Employee>
public void print(Pair<Employee>) { ..... }
Manager类是Employee类的子类，那么Pair<Manager>是Pair<Employee>的子类么？，可以传入print方法么？答案是不行，Pair<Manager>不是Pair<Employee>的子类。
（2） 永远可以将参数化类型转换成原始类型，如：Pair pair = new Pair<Manager>("Jack","Mike"); 这是为了与泛型之前的遗留代码能够保持衔接。
（3）泛型类可以像普通类一样继承其他类，实现接口。如： class Pair<T> implements Comparable 。
6. 通配符类型
Pair<? extends Fruit> 表示任何泛型Pair类型，它的类型参数是Fruit的子类。Pair<Fruit>和Pair<Apple>都是Pair<? extends Fruit>的子类型。
Pair<? super Apple>表示任何泛型Pair类型，它的类型参数是Apple的父类。Pair<Fruit>和Pair<Object>都是Pair<? super Apple>的子类型。
这样，就可以利用参数多态了，修改上面的print方法：
public void print(Pair<? extends Fruit>) { ..... }
现在就可以传入Pair<Apple>和Pair<Banana>等作为参数了。
但是对于通配符类型的多态，使用父类变量引用子类实例时，需要注意以下的问题：
Pair<Apple> apples = new Pair<Apple>(new Apple("apple1"),new Apple("apple2")); Pair<? extends Fruit> fruits = apples; //下面两句调用setFirst方法编译报错，因为编译器只知道Pair中保存类型的是Fruit的子类，但不知道具体是什么类型。 fruits.setFirst(new Apple("apple3")); fruits.setFirst(new Banana("banana1")); //下面调用getFirst方法不会出错，因为编译器知道Pair中保存的类型一定是Fruit的子类，转换成Fruit类不会出错。 Fruit first = frutis.getFirst();
即对于<? extends Type> 通配符类型，使用父类变量引用子类实例时，不能对子类实例进行写，只能读。
Pair<Apple> apples = new Pair<Apple>(new Apple("apple1"),new Apple("apple2")); Pair<? super Apple> fruits = apples; fruits.setFirst(new GoodApple("apple3")); //这一句调用setFirst方法不会出错，因为编译器知道Pair中保存的类型一定是Apple类的父类，因此，传入Apple类对象或者Apple类的子类对象都是可以的
fruits.setFirst(new Fruit("banana1")); //传入Apple类的父类对象就会编译错误
Fruit first = frutis.getFirst(); //编译不通过，因为编译器知道Pair中保存的类型是Apple类的父类，但不知道具体是什么类，因此，只能赋值给Object类的变量
即对于<? super Type> 通配符类型，使用父类变量引用子类实例时，不能对子类实例进行读，只能写。
标签：
原文地址：http://www.cnblogs.com/jqctop1/p/4717582.html
