本文以Java的官方文档为参考，辅以代码示例，尽可能详尽的叙述泛型的每一个特性
什么是泛型
泛型（Generics）也称为参数化类型（parameterized types），也就是将类型本身作为接口、类、方法中的参数，相应地声明泛型接口、泛型类、泛型方法，在具体调用时再传入类型参数。从而实现同一种接口、类、方法适用于不同的类型。
为什么要有泛型
- 代码重用
泛型程序设计，意味着代码可以针对不同类型重用，你不可能希望针对String和Integer分别编写一个ArrayList
- 编译时类型检查
Java5之前，如果想实现泛型就需要这样做：例如定义一个包含Object数组的ArrayList
List v = new ArrayList();
v.add("test"); // 不会做类型检查
Integer i = (Integer)v.get(0); // 运行时异常（Runtime error）
这里其实利用了多态，编译时对set操作不会做类型检查，也不会报get操作的异常。强转的错误在运行时才会抛异常（向下转型不安全）
如果一个错误没有被发现，那么系统会进入不可预知的状态，会产生更严重的后果，并且使得错误更难被发现，所以，一个鲁棒的系统应该尽可能早地和多地报告异常。这个哲学思想也可以叫做“故障导向安全原则”。
java5之后引入泛型，实现方式：加入类型参数，（类型本身作为一个参数），好处在于
- 更易读：代码会有很好的可读性，人们就知道ArrayList存的是什么类型
- 更安全：而且编译时set的时候会有类型检查，get的时候也不用手工强转了
泛型类
泛型类的声明和使用
假设有一个Box类，我希望可以set和get任意类型的object，在没有泛型机制时的定义如下：
public class Box {
private Object object;
public void set(Object object) { this.object = object; }
public Object get() { return object; }
}
显然，如上节中提到，get方法调用时可能会出现运行时异常，因此我们利用泛型来实现Box类
首先，泛型类的定义格式如下：
class name<T1, T2, ..., Tn>
尖括号中是类型参数，可以被用在类中的任意位置，包括对象类型，方法入参类型，返回值类型。
由此，Box类的定义如下：
public class Box<T> {
// T stands for "Type"
private T t;
public void set(T t) { this.t = t; }
public T get() { return t; }
}
可以看出这里就是将原来Object类型全部换成了类型参数T
创建类对象，将T替换为实际的类型参数即可（就像给方法传参一样，将形参T变为实参Integer）
Box<Integer> integerBox = new Box<Integer>();
简化的使用方式：类型推断
Java 7之后可以利用类型推断，省略构造器后面的泛型：
Box<Integer> integerBox = new Box<>();
泛型接口
泛型接口的声明和使用
泛型接口与泛型类的定义大同小异，以一个简化的List接口为例
public interface List<E> {
boolean add(E e);
E get(int index);
}
实现或者继承泛型接口，有两种情况:
一种是不替换泛型形参E，即不指定具体的类型。这时类名后面必须也把泛型实参添加上，以ArrayList为例
public class ArrayList<E> extends AbstractList<E>
implements List<E> { //ArrayList后面必须添加<E>
boolean add(E e);
E get(int index);
}
另一种就是替换泛型形参E。这时实现类中所有形参出现的地方必须替换为实参，例如我定义了一个只存String类型的StringArrayList
public class StringArrayList extends ArrayList<String> {
boolean add(String e); //方法重写
String get(int index);
}
泛型方法
泛型方法的声明和使用
泛型方法是带类型参数的方法，注意类型参数在修饰符后面，返回类型前面。
泛型方法的作用范围只在本方法中，因此可以作为方法入参类型，或者返回值类型
典型例子就是Arrays.asList方法（泛型方法其实在Collections, Arrays等工具类中应用的很广泛）
public static <T> List<T> asList(T... a) { //这里返回List<T>，其实就相当于T用在了泛型方法的返回值类型中
return new ArrayList<>(a);
}
这时如何使用上面的泛型方法？有以下两种：
- 替换尖括号内的类型参数（相当于传参）
String[] stringArr = new String[]{"abc", "123", "opq"};
List<String> StringList = Arrays.<String>asList(stringArr);
- 编译器自行推断 一般我们在使用工具类的泛型方法时基本没见过上面的语法，其实编译器可以通过传入参数进行推断
List<String> StringList = Arrays.asList(stringArr);
注意事项：静态方法使用泛型
上面提到类型形参T可以用在类中的任意位置，但实际上不可以作为静态方法的入参和返回值类型，如果想让静态方法用到泛型，就得让静态方法自身变为泛型方法。
public class Box<T> {
//这里Box后面的泛型<T>和静态方法的泛型<T>并不是一个类型
public static <T> void show(T t){
}
}
限定类型参数
泛型上边界的使用
有时你会希望泛型的类型有一定的限制，比如希望定义一个只能存Number类型的Box，就可以这样声明
public class Box<T extends Number>
这时的Number就是泛型类型T的上边界，T也被称作限定类型参数（Bounded Type Parameters）
注意，你可以定义多个上边界，语法如下：
<T extends A & B & C>
需要注意的是，上边界可能是class，也可能是interface，class要放在interface的前面，否则编译不过
限定类型参数有什么好处
其实限定了参数的边界，也是为了利用泛型在编译期检查类型的特点，如果你希望T继承了某种类型，你就可以在编译时发现传入的参数是否正确，可以用以下这个例子来理解：
官方的教程中提到：限定类型参数尤其在泛型方法的实现中应用广泛，一般是要求T类型的对象本身具备一些功能，以Collections接口的sort方法为例（先忽视通配符？和下边界super）：
public static <T extends Comparable<? super T>> void sort(List<T> list) {
list.sort(null);
}
public static <T> void sort(List<T> list, Comparator<? super T> c) {
list.sort(c);
}
这两种方法其实也就对应了序列排序的两种常见办法：
- 序列中的对象继承Comparable接口，并且在compare方法中实现比较逻辑
- 外部传入Comparator接口的实现类，并且要实现其中compare方法（更松耦合，不要求对象具备Comparable接口的功能了）
问题来了，list.sort()其实就能实现这两种排序了（传参为null就是第一种，不为null就是第二种），为什么还要用Collections接口包装一下呢？
试想这样一个反例：自定义了Box类作为序列的元素，Box很简单，没有继承Comparable接口，sort方法也没传入Comparator比较器，这时你没办法给序列排序，因为你根本就没指定Box对象的比较逻辑。
此时运行sort会抛出ClassCastException异常，因为boxList.sort()方法的逻辑是：传入的Comparator实现类为null，就会认为对象继承了Comparable接口，将对象向上转型为Comparable类型，而Box并没有继承Comparable接口，所以会抛异常
ArrayList<Box> boxList = new ArrayList<>();
//省略添加元素的过程...
boxList.sort(null); //运行时抛出ClassCastException
而这时，如果用的是Collections.sort()方法，就可以在编译时利用限定边界的特性发现Box并没有继承Comparable，从而将异常转为编译期异常，你就直接会在IDE中发现一条红线了
Collections.sort(boxList)
总之，还是为了在编译时提早发现类型参数不符合限定边界的情况，也让T类型的对象在做强转的时候更加安全
（关于泛型的下边界，之后会和泛型通配符一起讲解）
