Java——擦除

直接代码分析一波：

import java.util.*;

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

这里的c1 c2 c3 c4将分别得到Double、Integer、ArrayList<String>、ArrayList<Integer>的类，输出是：

false
true

c1 == c2很明显是不一样的，这里的ArrayList<String>和ArrayList<Integer>很容易认为是不同的类型，但是其实他两是相同类型的，

import java.util.*;

class test1<T>{}
class test2<T,Q>{}
public class Ex12 {
    public static void main(String[] args) {
        test1<Double> t1 = new test1<Double>();
        test2<Double, Double> t2 = new test2<Double, Double>();
        System.out.println(Arrays.toString(t1.getClass().getTypeParameters()));
        System.out.println(Arrays.toString(t2.getClass().getTypeParameters()));
    }
}

Class.getTypeParameters()将返回一个泛型声明所声明的类型参数数组，但是只能看到T，Q，得不到Double,这是因为在java泛型是使用擦除来实现的，这就意味这当你在使用泛型的时候，任何具体点的类型信息都被擦除了，唯一知道的就是你在使用一个对象，因此List<String>和List<Integer>是相同的类型。

1、边界

class HasF{
    public void f() {System.out.println("f()");}
}
class Ma<T>{
    T obj;
    Ma(T t){ obj = t;}
    public void maf(){obj.f();}//这里是错的
}

假如你有一个HasF类，这个类中有一个f()方法，然后你想创建一个泛型类，并且想将obj的f()方法，这是java编译器无法实现的，因为擦除。为了调用f()，我们必须协助泛型类，给定泛型的边界，以此告知编译器只能接受遵循这个边界的类型。

用extends关键字，就能设置边界。

import java.util.*;

class HasF{
    public void f() {System.out.println("f()");}
}
class Ma<T extends HasF >{
    T obj;
    Ma(T t){ obj = t;}
    public void maf(){obj.f();}//这里是错的
}
public class Ex12 {
    public static void main(String[] args) {
        HasF hasf = new HasF();
        Ma<HasF> ma = new Ma<HasF>(hasf);
        ma.maf();
    }
}

边界<T extends HasF >声明T必须具有类型HasF或者从HasF导出的类型。

泛型类型参数将擦除到它的第一个边界，实际上编译器会把类型参数替换为它的擦除，上面的示例就是T擦除到HasF。

2、擦除的问题

泛型不能显式的引用运行时类型的操作中，例如转型、instanceof操作和new表达式，因为所有关于参数的类型信息都丢失了。例如：

class Foo<T>{
    T var;
}
class Cat{}

定义这样两个类，Foo是一个泛型类，Cat是一个普通类

Foo<Cat> foo = new Foo<Cat>();

这里看起来class Foo中的所有操作都像是使用Cat来操作，泛型好像也在告诉我们所有的类型T都将会被替换，但事实上我们必须提醒自己，被擦除了，它只是一个Object，也就是说这里没有边界，应该说边界就是Object。

import java.lang.reflect.Array;
import java.util.Arrays;

class ArrayMaker<T>{
    private Class<T> kind;
    ArrayMaker(Class<T> kind){ this.kind = kind;}
    T[] create(int size) {
        return (T[])Array.newInstance(kind, size);//这里会有警告
    }
}

public class Ex13 {
    public static void main(String[] args) throws Exception{
        ArrayMaker<String> stringMaker =
                new ArrayMaker<String>(String.class);
        String[] stringArray = stringMaker.create(9);
        System.out.println(Arrays.toString(stringArray));
    }    
}

输出：

[null, null, null, null, null, null, null, null, null]

即使这里的泛型被指定为Class<T>擦除就意味这kind实际被储存的是Class，由此在使用的时候，Array.newInstance(kind, size)并为拥有kind的类型信息，就是不知道kind是String.class，所以需要转型。

但是在创建一个容器情况稍有不同

public class Ex13<T> {
    List<T> create(){return new ArrayList<T>();}
    public static void main(String[] args) throws Exception{
        Ex13<String> ex = new Ex13<String>();
        List<String> stringList = ex.create();
    }    
}

这里的编译器 不会给出任何的警告，尽管我们知道create中的<T>被移除了。这样就能这样操作：

public class Ex13<T> {
    List<T> create(T t , int n){
        List<T> result = new ArrayList<T> ();
        for(int i = 0; i < n; i++) 
            result.add(t);
        return result;
        }
    public static void main(String[] args) throws Exception{
        Ex13<String> ex = new Ex13<String>();
        List<String> stringList = ex.create("hello", 4);
        System.out.println(stringList);
    }    
}

输出：

[hello, hello, hello, hello]

但是数组就不能这样做：

public class Ex13<T> {
    T[] create(T t , int n){
        T[] result = new T[n];//这里编译器无法编译
        for(int i = 0; i < n; i++) 
            result[i] = t;
        return result;
        }
    
    public static void main(String[] args) throws Exception{
        Ex13<String> ex = new Ex13<String>();
        List<String> stringList = ex.create("hello", 4);
        System.out.println(stringList);
    }    
}

因为T的类型被擦除了。一般都使用Array.newInstance()方法或者使用List。

3、擦除的补偿

public class Ex13<T> {
    public void f(Object o) {
        if(o instanceof T) {}//编译出错
        T var = new T();//编译出错
        T[] ts = new T[10];//编译出错
        T[] tss = (T)new Object[10];//编译出错
    }    
}

因为擦除使泛型代码失去某些执行某些操作的能力，想要绕过这些问题进行编程需要引入类型标签对擦除进行补偿。

• instanceof的使用失败 可以使用动态的ISinstance）　　

public class Ex13<T> {
    Class<T> kind;
    Ex13(Class<T> kind){
        this.kind = kind;
    }
    public boolean f(Object o) {
        return kind.isInstance(o);
    }
    public static void main(String[] args) {
        Ex13<String> ex = new Ex13<String>(String.class);
        System.out.println(ex.f("233"));
        System.out.println(ex.f(233));
    }
}

输出：

true
false

• T var = new T()；创建类型实例无法实现，一部分原因是因为擦除了，另一部分原因是因为编译器不能验证T具有默认（无参）的构造器，解决方法还是同样的使用Class对象。

public class Ex13<T> {
    Class<T> kind;
    Ex13(Class<T> kind){
        this.kind = kind;
    }
    public T f() {
        try {
            return kind.newInstance();
        } catch(Exception e) {
            throw new RuntimeException(e);
        }        
    }
    public static void main(String[] args) {
        String a = new Ex13<String>(String.class).f();
    }
}

调用用Class的newInstance()方法即可，但是如果在main中这样使用

    public static void main(String[] args) {
        Integer b = new Ex13<Integer>(Integer.class).f();
    }

就会失败，因为Integer是没有任何的默认的构造器。

可以使用显式的工厂，并限制其类型，使得只能接受实现这个类。

interface Factoryi<T>{
    T create();
}

先创建一个泛型接口，create()方法将返回一个T类对象。

可以

class IntegerFactory implements Factoryi<Integer>{

    public Integer create() {
        return new Integer(0);
    }
    
}

可以直接实现这个接口。

class Widest{
    public static class Factory implements Factoryi<Widest>{
        public Widest create() {
            return new Widest();
        }
    }
}

可以在这个类中创建一个内部类去实现这个接口，

class Foo2<T>{
    private T x;
    public <F extends Factoryi<T>> Foo2(F factory){
        x = factory.create();
    }
}

这就是实际上的泛型类了，因为Integer和Widest都没有任何默认的构造器，所以就创建一个类实现Factoryi<T>接口，实现其中的create()方法然后在泛型类从使用这个Factoryi<T>作为边界，使用其中的create()方法，从而实现在泛型类从创建泛型类型实例。

• 泛型数组

　　不能创建泛型数组，一般的解决方案是使用Araayist：

public class Ex13<T> {
    public List<T> array = new ArrayList<T>();
    public void add(T item) {
        array.add(item);
    }
    public T get(int index) {
        return array.get(index);
    }
}

这样和数组其实也能实现和数组差不多的功能。

还能通过传入Class类型对象，然后使用Array.newInstance()方法创建一个数组

class ArrayMaker<T>{
    private Class<T> kind;
    ArrayMaker(Class<T> kind){ this.kind = kind;}
    T[] create(int size) {
        return (T[])Array.newInstance(kind, size);//这里会有警告
    }
}

public class Ex13 {
    public static void main(String[] args) {
        String[] s = new  ArrayMaker<String>(String.class).create(10);
    }
}

5、通配符

先看一个数组的特殊行为：

class Fruit{}
class Apple extends Fruit{}
class Orange extends Fruit{}
class Jon extends Apple{}
public class Ex14 {
    public static void main(String[] args) {
        Fruit[] fruit = new Apple[10];
        fruit[0] = new Apple();
        fruit[1] = new Jon();
        try {
        fruit[2] = new Fruit();
        }catch(Exception e) {
            System.out.println(e.toString());
        }
        try {
        fruit[3] = new Orange();
        }catch(Exception e) {
            System.out.println(e.toString());
        }
    }
}

这里的输出是：

java.lang.ArrayStoreException: Fruit
java.lang.ArrayStoreException: Orange

这里创建了一个Apple数组，并将其赋值给一个Fruit数组。你可以将一个Apple或者Apple的子类对象放入数组，并不会有警告，和错误。

但是当你想要放入一个Fruit或是Orange对象的时候，编译器不会有警告但是运行的时候却能捕获到java.lang.ArrayStoreException异常，编译器不会给出警告是因为数组有一个Fruit[]引用，但是运行的时候数组机制知道这是一个Apple[]数组，所以就会抛出异常 。

类似的当我们试图使用泛型容器来代替数组的时候：

public class Ex14 {
    public static void main(String[] args) {
        List<Fruit> flist = new ArrayList<Apple>();
    }
}

这时编译器会直接给出警告，讲道理Apple是Fruit的子类，这应该属于向上转型，然而实际上这里并不是根本不是向上转型这里是两个List，Apple可以算是Fruit类型的，但是Apple的List并不是Fruit的List，这时如果想要建立某种类型的向上转型关系，就需要使用通配符了。

public class Ex14 {
    public static void main(String[] args) {
        List<? extends Fruit> flist = new ArrayList<Apple>();
        flist.add(new Orange());
        flist.add(new Apple());
        flist.add(new Jon());
    }
}

然后创建List就不会报错了，但是后面的调用add()方法还是会给出警告。

flist的类型现在是List<? extends Fruit>，可以将其读为“具有任何从Fruit继承的类型的列表”，但是并不就意味着这个List就可以持有任何类型的Fruit。通配符指定的是没有指定具体类型，其实就是只能接受不能修改。

public class Ex14 {
    public static void main(String[] args) {
        List<Apple> list = new ArrayList<Apple>();
        list.add(new Apple());
        list.add(new Jon());
        List<? extends Fruit> flist = list;
    }
}

这样的使用就是没错的。