了解引入泛型的动机，就先从语法糖开始了解。
语法糖
语法糖（Syntactic Sugar），也称糖衣语法，是由英国计算机学家Peter.J.Landin发明的一个术语，指在计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。Java中最常用的语法糖主要有泛型、变长参数、条件编译、自动拆装箱、内部类等。虚拟机并不支持这些语法，它们在编译阶段就被还原回了简单的基础语法结构，这个过程成为解语法糖。
泛型的目的： Java 泛型就是把一种语法糖，通过泛型使得在编译阶段完成一些类型转换的工作，避免在运行时强制类型转换而出现ClassCastException，即类型转换异常。
JDK 1.5 时才增加了泛型，并在很大程度上都是方便集合的使用，使其能够记住其元素的数据类型。
在泛型（Generic type或Generics）出现之前，是这么写代码的：
public static void main(String[] args)
{
List list = new ArrayList();
list.add("123");
list.add("456");
System.out.println((String)list.get(0));
}当然这是完全允许的，因为List里面的内容是Object类型的，自然任何对象类型都可以放入、都可以取出，但是这么写会有两个问题：
1、当一个对象放入集合时，集合不会记住此对象的类型，当再次从集合中取出此对象时，该对象的编译类型变成了Object。
2、运行时需要人为地强制转换类型到具体目标，实际的程序绝不会这么简单，一个不小心就会出现java.lang.ClassCastException。
所以，泛型出现之后，上面的代码就改成了大家都熟知的写法：
public static void main(String[] args)
{
List<String>
list = new ArrayList<String>();
list.add("123");
list.add("456");
System.out.println(list.get(0));
}这就是泛型。泛型是对Java语言类型系统的一种扩展，有点类似于C++的模板，可以把类型参数看作是使用参数化类型时指定的类型的一个占位符。引入泛型，是对Java语言一个较大的功能增强，带来了很多的好处。
①类型安全。类型错误现在在编译期间就被捕获到了，而不是在运行时当作java.lang.ClassCastException展示出来，将类型检查从运行时挪到编译时有助于开发者更容易找到错误，并提高程序的可靠性。
②消除了代码中许多的强制类型转换，增强了代码的可读性。
③为较大的优化带来了可能。
下面是JDK 1.5 以后，List接口，以及ArrayList类的代码片段。
//定义接口时指定了一个类型形参，该形参名为E
public interface List<E> extends Collection<E> {
//在该接口里，E可以作为类型使用
public E get(int index) {}
public void add(E e) {}
}
//定义类时指定了一个类型形参，该形参名为E
public class ArrayList<E> extends AbstractList<E> implements List<E> {
//在该类里，E可以作为类型使用
public void set(E e) {
.......................
}
}这就是泛型的实质：允许在定义接口、类时声明类型形参，类型形参在整个接口、类体内可当成类型使用，几乎所有可使用普通类型的地方都可以使用这种类型形参。
下面具体讲解泛型类的使用。泛型接口的使用与泛型类几乎相同，可以比对自行学习。
泛型类
定义一个容器类，存放键值对key-value，键值对的类型不确定，可以使用泛型来定义，分别指定为K和V。
public class Container<K, V> {
private K key;
private V value;
public Container(K k, V v) {
key = k;
value = v;
}
public K getkey() {
return key;
}
public V getValue() {
return value;
}
public void setKey() {
this.key = key;
}
public void setValue() {
this.value = value;
}
}在使用Container类时，只需要指定K，V的具体类型即可，从而创建出逻辑上不同的Container实例，用来存放不同的数据类型。
public static void main(String[] args) {
Container<String,String> c1=new Container<String ,String>("name","hello");
Container<String,Integer> c2=new Container<String,Integer>("age",22);
Container<Double,Double> c3=new Container<Double,Double>(1.1,1.3);
System.out.println(c1.getKey() + " : " + c1.getValue());
System.out.println(c2.getKey() + " : " + c2.getValue());
System.out.println(c3.getKey() + " : " + c3.getValue());
}在JDK 1.7 增加了泛型的“菱形”语法：Java允许在构造器后不需要带完成的泛型信息，只要给出一对尖括号（<>）即可，Java可以推断尖括号里应该是什么泛型信息。
如下所示：
Container<String,String> c1=new Container<>("name","hello");
Container<String,Integer> c2=new Container<>("age",22);泛型类派生子类
当创建了带泛型声明的接口、父类之后，可以为该接口创建实现类，或者从该父类派生子类，需要注意：使用这些接口、父类派生子类时不能再包含类型形参，需要传入具体的类型。
错误的方式：
public class A extends Container<K, V>{}正确的方式：
public class A extends Container<Integer, String>{}也可以不指定具体的类型，如下：
public class A extends Container{}此时系统会把K,V形参当成Object类型处理。
前面在介绍泛型类和泛型接口中提到，可以在泛型类、泛型接口的方法中，把泛型中声明的类型形参当成普通类型使用。 如下面的方式：
public class Container<K, V>
{
........................
public K getkey() {
return key;
}
public void setKey() {
this.key = key;
}
....................
}但在另外一些情况下，在类、接口中没有使用泛型时，定义方法时想定义类型形参，就会使用泛型方法。如下方式：
public class Main{
public static <T> void out(T t){
System.out.println(t);
}
public static void main(String[] args){
out("hansheng");
out(123);
}
}所谓泛型方法，就是在声明方法时定义一个或多个类型形参。 泛型方法的用法格式如下：
修饰符<T, S> 返回值类型 方法名（形参列表）｛
方法体
｝注意： 方法声明中定义的形参只能在该方法里使用，而接口、类声明中定义的类型形参则可以在整个接口、类中使用。
class Demo{
public <T> T fun(T t){ // 可以接收任意类型的数据
return t ; // 直接把参数返回
}
};
public class GenericsDemo26{
public static void main(String args[]){
Demo d = new Demo() ; // 实例化Demo对象
String str = d.fun("汤姆") ; // 传递字符串
int i = d.fun(30) ; // 传递数字，自动装箱
System.out.println(str) ; // 输出内容
System.out.println(i) ; // 输出内容
}
};当调用fun()方法时，根据传入的实际对象，编译器就会判断出类型形参T所代表的实际类型。
正如泛型方法允许在方法签名中声明类型形参一样，Java也允许在构造器签名中声明类型形参，这样就产生了所谓的泛型构造器。
和使用普通泛型方法一样没区别，一种是显式指定泛型参数，另一种是隐式推断，如果是显式指定则以显式指定的类型参数为准，如果传入的参数的类型和指定的类型实参不符，将会编译报错。
public class Person {
public <T> Person(T t) {
System.out.println(t);
}
}public static void main(String[] args){
//隐式
new Person(22);
//显示
new<String> Person("hello");
}这里唯一需要特殊注明的就是，如果构造器是泛型构造器，同时该类也是一个泛型类的情况下应该如何使用泛型构造器：
因为泛型构造器可以显式指定自己的类型参数（需要用到菱形，放在构造器之前），而泛型类自己的类型实参也需要指定（菱形放在构造器之后），这就同时出现了两个菱形了，这就会有一些小问题，具体用法再这里总结一下。
以下面这个例子为代表
public class Person<E> {
public <T> Person(T t) {
System.out.println(t);
}
}这种用法：Person<String> a = new <Integer>Person<>(15);这种语法不允许，会直接编译报错！
顾名思义就是匹配任意类型的类型实参。
类型通配符是一个问号（？)，将一个问号作为类型实参传给List集合，写作：List<?>（意思是元素类型未知的List）。这个问号（？）被成为通配符，它的元素类型可以匹配任何类型。
public void test(List<?> c){
for(int i =0;i<c.size();i++){
System.out.println(c.get(i));
}
}现在可以传入任何类型的List来调用test()方法，程序依然可以访问集合c中的元素，其类型是Object。
List<?> c = new ArrayList<String>();
//编译器报错
c.add(new Object());但是并不能把元素加入到其中。因为程序无法确定c集合中元素的类型，所以不能向其添加对象。
下面就该引入带限通配符，来确定集合元素中的类型。
简单来讲，使用通配符的目的是来限制泛型的类型参数的类型，使其满足某种条件，固定为某些类。
主要分为两类即：上限通配符和下限通配符。
如果想限制使用泛型类别时，只能用某个特定类型或者是其子类型才能实例化该类型时，可以在定义类型时，使用extends关键字指定这个类型必须是继承某个类，或者实现某个接口，也可以是这个类或接口本身。
它表示集合中的所有元素都是Shape类型或者其子类
List<? extends Shape>这就是所谓的上限通配符，使用关键字extends来实现，实例化时，指定类型实参只能是extends后类型的子类或其本身。
例如：
//Circle是其子类
List<? extends Shape> list = new ArrayList<Circle>();这样就确定集合中元素的类型，虽然不确定具体的类型，但最起码知道其父类。然后进行其他操作。
如果想限制使用泛型类别时，只能用某个特定类型或者是其父类型才能实例化该类型时，可以在定义类型时，使用super关键字指定这个类型必须是是某个类的父类，或者是某个接口的父接口，也可以是这个类或接口本身。
它表示集合中的所有元素都是Circle类型或者其父类
List <? super Circle>这就是所谓的下限通配符，使用关键字super来实现，实例化时，指定类型实参只能是extends后类型的子类或其本身。
例如：
//Shape是其父类
List<? super Circle> list = new ArrayList<Shape>();Class c1=new ArrayList<Integer>().getClass();
Class c2=new ArrayList<String>().getClass();
System.out.println(c1==c2);程序输出：
true。
这是因为不管为泛型的类型形参传入哪一种类型实参，对于Java来说，它们依然被当成同一类处理，在内存中也只占用一块内存空间。从Java泛型这一概念提出的目的来看，其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。
在静态方法、静态初始化块或者静态变量的声明和初始化中不允许使用类型形参。由于系统中并不会真正生成泛型类，所以instanceof运算符后不能使用泛型类。