使用泛型的目的
当我们第一次接触泛型时，第一个问题肯定会是，为什么要使用泛型？最直接的答案是为了避免转型，使得编译器能够在编译期就发现转型错误而不用等到运行时。
比如说，当我们声明了一个泛型为Integer的列表，那么该列表的元素就只能是Integer，当我们往里面放非Integer的元素时，编译器就能够发现，
List<Integer> intList = new ArrayList<>();
intList.add("abc"); //编译期错误，不能存放String对象到intList中
同理，当我们从列表中获取元素时，我们也不再需要使用强制转型将列表中的元素转型成Integer
Integer i = intList.get(0);
Integer i = (Integer)intList.get(0);//不再需要进行强制转型
然而，泛型却有一些容易令人困惑的地方，第一个就是关于泛型的带有通配符的上下界。
带有通配符的上下界
Java泛型现在支持两种带有通配符的上下界的表达方式，
- ? extends T - 这里的?表示类型T的任意子类型，包括类型T本身。
- ? super T - 这里的?表示类型T的任意父类型，包括类型T本身。
这两者的含义都很容易理解和区分，难点在于我们什么时候该用 ? extends T, 什么时候改用? super T.
比如说，由于? extends T表示类型T和它的任意子类型，那么我们可以说List<? extends Number> 实例可以添加任意为Number子类的元素吗？
List<? extends Number> intList = new ArrayList<>();
intList.add(1); //complier error
intList.add(3.14); //compiler error
从上述的代码来看，它并不像我们所理解的那样工作。那么，我们在什么时候需要使用? extends T和? super T呢？ 这里有一条简单的规则 (Get and Put Rule)：
当你需要从一个数据结构中获取数据时(get), 那么就使用? extends T. 如果你需要存储数据(put)到一个数据结构时，那么就使用? super T. 如果你又想存储数据，又想获取数据，那么就不要使用通配符? . 即直接使用具体泛型T。
所以，根据Get&Put规则，在上面的例子中，我们是需要往数据结构里面存储数据的，所以需要使用? super T. 修改上面的例子，你可以发现程序可以工作了。
List<? super Number> intList = new ArrayList<>();
intList.add(1); //it works
intList.add(3.14); //it works
第二个比较让人困惑的是关于泛型的类型系统。
泛型的类型系统
泛型的类型系统中最令人困惑的地方就是，Integer类是Number类的子类，而List<Integer>却不是List<Number>的子类。也就是说，你不能将List<Integer>实例对象直接赋值给List<Number>实例对象。 List<Integer>不是List<Number>子类的原因我们只能通过反证法推理出来：
List<Integer> ints = new ArrayList<Integer>();
ints.add(1);
ints.add(2);
List<Number> nums = ints; // compile-time error
nums.add(3.14);
assert ints.toString().equals("[1, 2, 3.14]"); // uh oh!
从上面的例子中，假设List<Integer>是List<Number>的子类，那么List<Integer>实例对象ints就可以赋值给List<Number>实例对象nums。接着我们可以往nums实例添加非Integer对象，如float对象3.14。但是这个是不允许的，因为nums实例实际上是List<Integer>实例对象，它不能接受任何非Integer对象。由此可证，List<Integer>并不是List<Number>的子类。但是，List<Integer>是Collection<Integer>的子类。
所以对于泛型的类型系统来讲，它应当遵循以下一些规则，摘抄自Java深度历险-Java泛型
引入泛型之后的类型系统增加了两个维度：一个是类型参数自身的继承体系结构，另外一个是泛型类或接口自身的继承体系结构。第一个指的是对于List<String>和List<Object>这样的情况，类型参数String是继承自Object的。而第二种指的是List接口继承自Collection接口。对于这个类型系统，有如下的一些规则：
- 相同类型参数的泛型类的关系取决于泛型类自身的继承体系结构。即List<String>是Collection<String> 的子类型，List<String>可以替换Collection<String>。这种情况也适用于带有上下界的类型声明。
- 当泛型类的类型声明中使用了通配符的时候，其子类型可以在两个维度上分别展开。如对Collection<? extends Number>来说，其子类型可以在Collection这个维度上展开，即List<? extends Number>和Set<? extends Number>等；也可以在Number这个层次上展开，即Collection<Double>和 Collection<Integer>等。如此循环下去，ArrayList<Long>和 HashSet<Double>等也都算是Collection<? extends Number>的子类型。
- 如果泛型类中包含多个类型参数，则对于每个类型参数分别应用上面的规则。
最后我们来看看在Java泛型参数是如何进行推断的。
泛型参数的自动推断
有两种方式可以指定泛型参数的类型，一种是显示的指定，比如对于下面的方法，
public class GenericUtil {
public static <T> List<T> asList(T... array) {
List<T> tlist = new ArrayList<>();
for (T t : array) {
tlist.add(t);
}
return tlist;
}
}
我们可以显示的指定泛型参数的类型，
System.out.println(GenericUtil.<String>asList("a","b","c"));
除了显示的指定之外，我们还可以隐式的指定， 实际上就是让编译器自己去推断。
System.out.println(GenericUtil.asList("a","b","c"));
编译器可以通过asList方法接收的参数类型来推断出T实际上就是String。 如果从方法接收的参数类型推断不出来的话，那么编译器还会从方法赋值的目标参数来推断，比如说下面的newObject方法，
public class GenericUtil {
public static <T> T newObject(String className) throws Exception {
Class clz = Class.forName(className);
return (T) clz.newInstance();
}
}
从方法接收参数上编译器并不能推断出T是什么类型。这个时候可以从方法赋值的目标参数进行推断，
Person p = GenericUtil.newObject("com.kevin.hibernate01.Person");
从方法赋值的目标参数p可以得知，newObject方法中定义的泛型参数T类型应该为Person类型。
