多态算是一种泛化机制，但是拘泥于单继承体系，也会使程序受限太多。JavaSE5中提出了泛型的概念。
泛型概念：泛型实现了参数化类型的概念，使代码可以应用于多种类型。
简单泛型（泛型类）
为了创造容器类，是促成了泛型出现的主要原因。泛型的主要目的之一是用来指定容器要持有什么类型的对象，而且由编译器来保证类的正确性。
public class Holder<T>{
private T a;
Holder(T a){this.a = a;}
public T get(){return a;}
public static void main(String[] args){
Holder<String> h = new Holder<String>(new String("dd"));
String s = h.get(); //自动得到正确类型
}
}
Java泛型的核心概念：告诉编译器想使用什么类型，然后编译器帮你处理一切细节。
- 一个元组类库
元组：它是将一组对象直接打包存储于其中的一个单一对象。
注：可以利用继承机制实现长度更长的元组。
public class TwoTuple<A, B>{
public final A first;
public final B second;
public TwoTuple(A a, B b){
first = a;
second = b;
}
}
- 一个堆栈类
public class LinkedStack<T>{
T item;
public void push(T item){
this.item = item;
}
...
}
泛型接口
泛型也能应用于接口，例如生成器（generator）一种专门负责创建对象的类。
public interface Generator<T>{
T next();
}
public class StrGenerator implements Generator<String>{
public String next(){
return new String();
}
}
接口使用泛型和类使用泛型并没有什么区别。
泛型方法
泛型方法是的该方法能够独立于类而产生变化，如果能用泛型方法代替将整个类泛型化，那应该使用泛型方法。
对于一个static方法而言，无法访问泛型类的类型参数，所以，如果static方法需要使用泛型能力，就必须使其成为泛型方法。
要定义泛型方法，只需将泛型参数列表置于返回值之前。
public <T> void f(T t){
...
}
注意， 当使用泛型类时，必须在创建对象的时候指定类型参数的值，而使用泛型方法的时候，通常不必指明参数类型，因为编译器会为我们找出具体的类型，这称为参数推断。我们可以像使用普通方法一样使用f().
如果参入基本类型，自动打包机制会介入将基本类型值包装成对应对象。
- 利用类型参数推断；
public New{
public static <K,V> Map<K,V> map(){
return new HashMap<K, V>();
}
}
Map<String,List<String>> m = New.map(); //利用类型推断，不用强制转换
在非赋值语句的时候，需要额外的显式指明类型
f(New.<String, List<String>>map());//在.和方法名之间插入声明
- 可变参数与泛型方法；
public static <T> List<T> makeList(T... args){
List<T> resutl = new ArrayList<T>();
for(T item: args){
resulr.add(item);
}
return result;
}
内部类
泛型还可以应用于内部类以及匿名内部类。
构建复杂模型
泛型的一个重要好处就是能够简单而安全的创建复杂的模型。
例如：List元组。
擦除的神秘之处
我们来看一个例子
Class c1 = new ArrayList<Integer>().getClass();
Class c2 = new ArrayList<String>().getClass();
System.out.println(c1==c2); //true
为什么输出是true？
Java泛型是用擦除来实现的，这==意味着当你在使用泛型时，任何具体的类型信息都被擦除了==，在泛型代码内部，无法获得任何有关泛型参数类型的信息。你唯一知道你在使用一个对象。因此List<Integer>和List<String>在运行时事实上是相同的类型，都被擦除成他们的“原生”类型，即List.
有时候我们需要用泛型调用某个具体对象方法，由于有擦除，Java编译器无法知道能否调用。我们必须借助泛型类，给定泛型类的边界，以此告知编译器只能接受遵循此边界的类型。
public class HasF{
public void f(){
...
}
}
class Manipulator<T>{
private T obj;
public void test(){
obj.f();
}
}
上面编译会出错， 编译器不知道obj能否调用f()；
修改，指定边界则可以通过编译
class Manipulator<T extends HasF>{
private T obj;
public void test(){
obj.f();
}
}
边界<T extends HasF>声明T必须具有HasF或子类的类型。泛型类型参数将擦除到它的第一个边界。
擦除的问题
擦除的代价是显著的，泛型不能用于显式地引用运行时类型的操作之中，例如转型、instanceof、new表达式，因为所有关于参数的类型信息都丢失。
擦除的补偿
擦除丢失了在泛型代码中执行某些操作的能力，我们可以通过引入类型标签Class<T>来对擦除进行补偿，这意味着需要显式地传递你的类型的Class对象，以便在表达式中使用。
public class ClassTye<T>{
Class<T> kind;
public ClassType(Class<T> kind){
this.kind = kind
}
}
通配符
通配符：在泛型参数表达式中的问号。
分为两种：
- ==限定通配符==
限定通配符对类型进行了限制，有两种限定通配符，
- 一种是<? extends T>它通过确保类型必须是T或T的子类来设定类型的上界
- 另一种是<? super T>它通过确保类型必须是T或T的父类来设定类型的下界。
泛型类型必须用限定内的类型来进行初始化，否则会导致编译错误。
- ==无界通配符==
无界通配符<?>看起来意味着“任何事物”，因此使用无界通配符好像等价于使用原生类型。
问题
- List<?>和List<? extends Object>的区别？
List<?>可以使用原生类型，而List<? extends Object>必须指定类型。
static List list1;
static List<?> list2;
static List<? extends Object> list3
static void assigne1(List list){
list1 = list;
list2 = list;
// list3 = list; //不行
}
//除了List list不能赋给List<? extends Object> list3，其他都可以互相赋值。
- Java泛型的限制之一，不能将基本类型用作类型参数。需要使用自动包装机制。但是自动包装机制不能应用于数组。
- 数组可以用泛型吗？
==不能直接创建泛型数组==。一般解决方案是在想要创建泛型数组的地方都用ArrayList代替。（创建泛型数组的唯一方式是创建一个被类型擦除的新数组，然后对其转型）
- ==一个类能否实现同一个泛型接口的两种变体==？
不能，由于擦除的原因，这个两个变体会成为相同的接口，相当于重复实现相同的接口。
- 转型
使用带有泛型类型参数的转型或instanceof不会有任何效果。
- 重载
public class UseList<W, T>{
void f(List<T> v){}
void f(List<W> w){}
}
上面的程序是不能编译的。因为由于擦除的原因，重载方法将产生相同的类型签名。
异常
由于擦除的原因，catch语句不能捕获泛型类型的异常，因为在编译期和运行期都必须知道异常的确切类型。泛型类也不能直接或间接继承自Throwable
