看JDK源码的时候发现好多地方都在使用泛型，但是平常项目开发过程中很少使用到泛型，鉴于自己对泛型也一知半解，所以趁这个机会系统的学习一遍
什么是泛型
泛型即参数化类型，就是声明的类型参数在使用的时候用具体的类型参数来替换。
为什么使用泛型
使用泛型的好处：例如，定义一个泛型类型的方法，可以处理String，Integer类型的参数而不用针对每种参数都实现一个方法
总所周知Object类是所有类的超类，那么为什么不定义一个参数类型是Object的方法呢，这样方法也可以处理String，Integer类型的参数？
参考如下代码，实例化一个Student类的对象并放入定义为List
这种强制类型转换是不安全的转换方式，例如，在list中分别放入了String和Integer类型的参数，但是取值的时候将String类型的参数强制转换成Integer类型就会报错抛异常。
所以通过Object类型的引用变量引用所有类型的对象不具有安全性，泛型可以扩展了重用代码的能力，并且可以安全、容易的重用代码。
泛型类
定义一个泛型类Gen:
package com.victor.technology.generic;
public class Gen
{
private T ob;
public Gen(T ob)
{
this.ob = ob;
}
public T getob()
{
return this.ob;
}
public void showType()
{
System.out.println("The type of T is: " + ob.getClass().getName());
}
public void showValue()
{
System.out.println("The value of ob is: " + ob);
}
}
定义一个测试类：
package com.victor.technology.generic;
public class GenericTest
{
public static void main(String[] args)
{
Gen iob = new Gen(88);
iob.showType();
iob.showValue();
Gen strob = new Gen("Generic Test");
strob.showType();
strob.showValue();
}
}
执行结果如下：
The type of T is: java.lang.Integer
The value of ob is: 88
The type of T is: java.lang.String
The value of ob is: Generic Test
1.泛型只能使用封装类型
如下声明是错误非法的：
Gen iob = new Gen(88);
2.基于不同类型参数的泛型参数是不同的
如下写法也是错误的：
iob = strob
虽然iob和strob都是Gen
3.泛型提升类型安全性
使用泛型可以将运行时错误转换成编译时错误，这是泛型的主要优势
有界类型
可以再具体的限定一下泛型T的类型，主要有两种形式：
1.T extends MyClass
例如 Class Gen
通过类MyClass和接口MyInterface对T进行了限制，因此，所有传递给T的类型参数都必须继承MyClass类和实现MyInterface接口
2.T super MyCalss
例如 Class Gen
所有传递给T的类型参数都必须属于MyClass类的超类
使用通配符参数
在泛型中，？表示通配符，代表位置类型。表示上边界限定通配符，表示下边界限定通配符。
？与T的区别：
T：作用在模板上，用于将数据类型进行参数化，不能用于实例化对象
？：不能用在模板上，在实例化对象的时候，不确定泛型参数的具体类型时，可以使用通配符进行对象定义
例如，实例化泛型对象，我们不能够确定eList存储的数据类型是Integer还是Long，因此我们使用List定义变量的类型：
List list = null;
list = new ArrayList();
list = new ArrayList();
泛型方法
泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。
泛型方法的定义：
public T getValue(T ob)
{
...
}
其中
1.泛型方法的基本用法
定义一个泛型方法getValue()并使用：
package com.victor.technology.generic;
public class GenericTest
{
public static void main(String[] args)
{
GenericTest gen = new GenericTest();
System.out.println(gen.getValue(5));
System.out.println(gen.getValue("Generic test"));
}
public T getValue(T t)
{
return t;
}
}
执行结果：
5
Generic test
2.类中的泛型方法
定义如下泛型类：
package com.victor.technology.generic;
public class Gen
{
private T ob;
public Gen(T ob)
{
this.ob = ob;
}
public T getob()
{
return this.ob;
}
public void getValue(E t)
{
//...
}
public void showResult(T t)
{
//...
}
}
getValue：在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。由于泛型方法在声明的时候会声明泛型
showResult：在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
3.泛型方法与可变参数
定义printMsg方法，该方法接收可变参数：
package com.victor.technology.generic;
public class GenericTest
{
public static void main(String[] args)
{
GenericTest gen = new GenericTest();
gen.printMsg("111", 222, "aaaa", "2323.4", 55.55);
}
public void printMsg(T... args)
{
for (T t : args)
{
System.out.println(t);
}
}
}
4.静态方法与泛型
1.静态方法无法访问类上定义的泛型，否则会报错
2.静态方法跟普通方法一样，需要使用泛型的话，必须将静态方法也定义成泛型方法。
泛型接口
定义泛型接口：
package com.victor.technology.generic;
public interface Generic
{
public T getValue();
}
使用例子：
public class GenericTest implements Generic
{
//...
}
类型擦除
类型擦除的概念
类型擦除（Type Erasure）： Java中的泛型基本上是在编译期这个层次来实现的，在生成的Java字节码中是不包含泛型中的类型信息。使用泛型的时候加上的类型参数会被编译器在编译的时候去掉，这个过程就被称为类型擦除。
例如，List
package com.victor.technology.generic;
import java.util.ArrayList;
import java.util.List;
public class GenericTest
{
public static void main(String[] args)
{
List strList = new ArrayList();
List intList = new ArrayList();
System.out.println(strList.getClass());
System.out.println(strList.getClass() == intList.getClass());
}
}
执行结果如下：
class java.util.ArrayList
true
List
List
List、List 擦除后的类型为 List
List
类型擦除的原因
为什么使用类型擦除这种伪泛型？主要是为了兼容之前的版本，如果把在运行期实现泛型，JVM需要大换血改动量太大
类型擦除的影响
1.泛型不支持协变
数组是支持协变的，即Object[] arr = new Integer[5];语法是正确的，但是List
使用instanceof的时候也报错：
3.对数组的限制
首先不能创建元素类型为类型参数的数组，其次不能创建特定类型的泛型引用数组。
即在泛型类中new T[]是会报错的，因为编译器无法知道具体创建成什么类型的数组
其次List