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