Java泛型理解

#什么是泛型
泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。通俗讲就是使得代码可以适应多种类型。

#泛型优点
1.提高了代码的通用性：对于一段代码，我们更喜欢后期决定他的类型，要达到这种目的，就使用泛型和泛型的类型参数
2.消除强制类型转换：消除了代码中大量的类型转换，使得代码可读性更高，使代码更加优雅
3.类型安全：通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设

#擦除

通过一段代码实例及输出结果：

public class Test {
    public static void main(String[] args) {
        Class c1 = new ArrayList<Integer>().getClass();
        Class c2 = new ArrayList<String>().getClass();
        System.out.println(c1 == c2);
    }
}

结果如下：true

大家会觉得奇怪！明明c1是Integer的，c2是String的，为什么打印结果为true？因为在泛型代码内部，无法获取任何有关泛型参数类型的任何信息！，Java的泛型就是使用擦除来实现的，当你在使用泛型的时候，任何信息都被擦除，你所知道的就是你在使用一个对象。所以List< Integer>和List< String>在运行时，会被擦除成他们的原生类型List。

再通过下面例子加深一下擦除的理解：


class Student{
    public String  getName(){
        System.out.println("张三");
    }
}
class TestStudent <T>{
    private T t;
    public TestStudent(T t){
        this.t = t;
    }
    public void getStudent(){
        t. getName();//这里不能编译
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        TestStudent < Student > testStudent = new TestStudent <>(student);
        testStudent.getStudent();
    }
}

我们可以看到，t. getName()这里是不能够编译的。因为擦除的存在，main中传入的泛型，在TestStudent中编程了Object，因此并不能跟Student这个类绑定，也就调用不了Student方法。那能够怎么让Object调用Student的方法？可以给定泛型的边界，把类TestStudent < T>改为TestStudent < T extends Student >，这个边界声明了T必须具有类型Student或者从Student导出的类型。

#擦除带来的问题

泛型不能用于显性地引用运行时类型的操作之中，例如转型，instanceof和new操作（包括new一个对象，new一个数组），因为所有关于参数的类型信息都在运行时丢失了，所以任何在运行时需要获取类型信息的操作都无法进行工作。

不能进行如下：

1 2	if(obj instanceof T); T t = new T();

#解决擦除带来的问题

###1.解决instanceof

使用instanceof会失败，是因为类型信息已经被擦除，因此我们可以引入类型标签Class< T>，就可以转用动态的isInstance()。

class A{}
class B extends A{}
public class TestInstance<T> {
    private Class<T> t;
    public TestInstance(Class<T> t){
        this.t = t;
    }
    public boolean compare(Object obj){
        return t.isInstance(obj);
    }
    public static void main(String[] args) {
        TestInstance<A> test= new TestInstance<A>(A.class);
        System.out.println(test.compare(new A()));
        System.out.println(test.compare(new B()));
    }
}

结果如下：
true
true

2.解决创建类型实例

解决办法是使用工厂

interface Factory<T>{
    T create();
}
class Test<T>{
    public <F extends Factory<T>> Test(F factory){
        factory.create();
    }
}
class TestFactory implements Factory<Integer>{
    public Integer create(){
        Integer integer = new Integer(10);
        System.out.println(integer);
        return integer;
    }
}
public class TestNew {
    public static void main(String[] args) {
        new Test(new TestFactory());
    }
}

结果如下：
10

#边界

正是因为有了擦除，把类型信息擦除了，所以，用无界泛型参数调用的方法只是那些可以用object调用的方法。但是，如果给定边界，将这个参数限制为某个类型的子集，就可以使用这些类型子集来调用方法。

interface Bird{
    void fly();
}
public class TestBorder<T extends Bird > {
    T t;
    public TestBorder(T t){
        this.t = t;
    }
    public void test(){
        t.fly();
    }
}

可见，类型T已经可以调用Bird的fly()方法了。

当然，也可以指定多个边界

interface Bird{
    void fly();
}
interface Cat{
    void run();
}
interface Pig{
    void eat();
}
public class TestBorder<T extends Bird & Cat & Pig> {
    T t;
    public TestBorder(T t){
        this.t = t;
    }
    public void test(){
        t.fly();
        t.run();
        t.eat();
    }
}

这里需要注意的是，extends 后面跟的第一个边界，可以为类或接口

#通配符和泛型上界和下界

###1.上界< ? extends Class>

class Fruit{}
class Apple extends Fruit{}
class Orange extends Fruit{}
public class TestBuChang<T>{
    public static void main(String[] args) {
        List<? extends Fruit> list = new ArrayList<>();
        //list.add(new Apple());
        //list.add(new Orange());
        //list.add(new Fruit());
        list.add(null);
        list.contains(new Apple());
        list.indexOf(new Apple());
        Apple apple = list.get(0);
    }
}

可见，指定了上边界，却不能add任何类型，甚至Object都不行，除了null，因为null代表任何类型。List< ? extends Fruit>可以解读为，“具有任何从Fruit继承的类型”，但实际上，它意味着，它没有指定具体类型。对于编译器来说，当你指定了一个List< ? extends Fruit>，add的参数也变成了“? extends Fruit”。因此编译器并不能了解这里到底需要哪种Fruit的子类型，因此他不会接受任何类型的Fruit。

然而，contain和indexof却能执行，这是因为，这两个方法的参数是Object，不涉及任何的通配符，所以编译器允许它调用。

list.get(0)能够执行是因为，当item在此list存在时，编译器能够确定他是Apple的子类，所以能够安全获得。

2.下界< ? super Class>

< ? super Class>表示，指定类的基类。

class Fruit{}
class Apple extends Fruit{}
class Apple1 extends Apple{}
class Orange extends Fruit{}
public class TestBuChang<T>{
    public static void main(String[] args) {
        List<? super Apple> list = new ArrayList<>();
        list.add(new Apple());
        list.add(new Apple1());
        //list.add(new Fruit());
        Object apple = list.get(0);
    }
}

这里可以看到，list.add(new Fruit())这句不能编译成功，这是因为，List< ? super Apple>表示“具有Apple的父类的列表”。但是为什么add(new Fruit())不能成功呢？正是因为？代表Apple的父类，但是编译器不知道你要添加哪种Apple的父类，因此不能安全地添加。
对于super，get返回的是Object，因为编译器不能确定列表中的是Apple的哪个子类，所以只能返回Object。

3.PECS原则

如果要从集合中读取类型T的数据，并且不能写入，可以使用 ? extends 通配符；(Producer Extends)
如果要从集合中写入类型T的数据，并且不需要读取，可以使用 ? super 通配符；(Consumer Super)
如果既要存又要取，那么就不要使用任何通配符。