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());
    }