1、什么是泛型
泛型，是“参数化类型”的概念，代码可以适用于多种类型。参数化类型是指把具体的类型参数化，就像方法中使用的参数一样。
void hello(String str){
System.out.println("str是个变量参数，String是个具体类型");
}
<T> void hello(T str){
System.out.println("str是个变量参数，T是个类型参数");
}
2、为什么使用泛型
泛型出现最引人注目的一个原因，是为了创造使用容器类。
List arrayList=new ArrayList();
arrayList.add("hello");
arrayList.add(110);
for(Object obj:arrayList){
String s=(String)obj;//java.lang.ClassCastException
}
有些情况下，我们希望容器能够持有多种类型的对象，但是，大部分情况我们只会使用容器存储一种类型的对象，泛型可以在编译阶段就可以防止错误的发生。
List<String> arrayList=new ArrayList<String>();
arrayList.add(110);//编译时报错
另外，一般的类和方法，只能使用具体的类型。如果要编写可以应用于多种类型的代码，这种刻板的限制就会对代码造成束缚。
return语句只能返回一个对象，但是有很多功能要求一个方法需要返回多个对象，怎么办？
解决方法就是创建一个对象，用它来持有返回的多个对象。可以在每次使需要时，专门创建一个类，而使用泛型则能够一次性解决该问题，同时在编译期间就能确保类型安全。
public class TwoTuple <A,B>{
public final A a;
public final B b;
public TwoTuple(A a,B b) {
this.a=a;
this.b=b;
}
}
例：获取一个学生的信息和导师的姓名。
public class TupleTest{
public static void main(String[] args) {
TwoTuple<Student,String> tt=new TwoTuple<Student, String>(new Student(), "张大侠");
}
}
class Student{}
3、泛型特性
泛型只在编译阶段有效
List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();
Class<? extends List> classStringArrayList = stringArrayList.getClass();
Class<? extends List> classIntegerArrayList = integerArrayList.getClass();
if(classStringArrayList.equals(classIntegerArrayList)){
System.out.println("类型相同");
}
输出：
类型相同
泛型不强制使用，泛型也无法显示用于运行时类型的操作，例如转型、instanceof和new表达式。
public void testClass(){
GenricClass<Integer> gci=new GenricClass<Integer>(10086);
// GenricClass<String> gcs=new GenricClass<String>(10086);
GenricClass<String> gcs=new GenricClass<String>("hello");
GenricClass g1=new GenricClass(10086);
GenricClass g2=new GenricClass("hello");
GenricClass g3=new GenricClass(66.666);
GenricClass g4=new GenricClass(true);
System.out.println(g1.getField());
System.out.println(g2.getField());
System.out.println(g3.getField());
System.out.println(g4.getField());
if(g2 instanceof GenricClass<?>){//if(g2 instanceof GenricClass<String>) 编译错误
System.out.println("true");
}
}
Java泛型是使用擦除来实现的，意思是当你使用泛型的时候，任何具体的类型信息都被擦除了，你唯一知道的就是你在使用一个对象。List<String> 和List<Integer>在运行时是相同的类型，都被擦除成他们的原生类型，即List。
擦除默认会把类型擦除到Object，如果需要使用具体类的某些特性，需要协助泛型类，给泛型类定个边界。
class Shape{int length() {return 0;}}
class Rectangle extends Shape{}
class Circle extends Shape{}
class Painter<T extends Shape>{
private T t;
public Painter(T t) {this.t=t;}
public void draw(){
t.length();
}
}
在上面这个例子中，泛型并没有贡献什么好处，只要把T替换成Shape就可以很容易创建出没有泛型的类，这也说明一点：只有当你是用的类型参数比某个具体类型更加通用时，泛型才有帮助。
4、怎么用泛型
泛型有三种使用方式：泛型类、泛型接口、泛型方法。
public interface GenricInterface<T> {
public T getField();
}
public class GenricClass<T> implements GenricInterface<T>{
private T field;
public GenricClass(T f) {field=f;}
public T getField() {return field;}
// 静态泛型方法无法访问类中定义的类型。必须额外声明
public static <T> T genricMethod(Class<T> tc) throws InstantiationException, IllegalAccessException{
T t=tc.newInstance();
return t;
}
public void show1(T t){System.out.println(t.toString());}
public <E> void show2(E e){System.out.println(e.toString());}
public <T> void show3(T t){System.out.println(t.toString());}
}
前面说过了泛型无法通过new T( )创建对象实例，Java的解决方案是使用工厂对象来创建新的实例，最便利的工厂对象就是Class对象，可以通过newInstance（）来创建该类型新对象。
public void testGenricMethod(){
System.out.println("泛型方法测试----------------------------------------------------------");
try {
NormalClass nc= GenricClass.genricMethod(NormalClass.class);
} catch (InstantiationException | IllegalAccessException e ) {
e.printStackTrace();
}
GenricClass<Integer> g1=new GenricClass<Integer>(10086);
g1.show1(100);
// g1.show1(100.1);
g1.show2(100); g1.show2(100.1);
g1.show3(100); g1.show3(100.1);
}
泛型通配符
public void testWildcard(){//通配符测试
System.out.println("通配符测试----------------------------------------------------------");
GenricClass<Integer> g1=new GenricClass<Integer>(10086);
GenricClass<Number> g3=new GenricClass<Number>(66.666);
// show(g1);//参数不匹配
show(g3);
show2(g1); show2(g3);
show3(g1); show3(g3);
// show4(g1); show4(g3);//参数不匹配 <?>可理解为所有泛型父类<? extends Object>
}
public void show(GenricClass<Number> gc){
System.out.println("show:"+gc.getField());
}
public void show2(GenricClass<? extends Number> gc){
System.out.println("show2:"+gc.getField());
}
public void show3(GenricClass<?> gc){
System.out.println("show3:"+gc.getField());
}
public void show4(GenricClass<Object> gc){
System.out.println("show4:"+gc.getField());
}
