泛型边界处的动作

边界处的动作

正因为泛型的擦除，泛型带来了一个事实，可以表示没有任何意义的事物，即可以表示没有任何意义的事物。

public class ArrayMaker<T> {
    private Class<T> kind;

    public ArrayMaker(Class<T> kind) {
        this.kind = kind;
    }

    @SuppressWarnings("unchecked")
    T[] create(int size) {
        return (T[]) Array.newInstance(kind, size);
    }

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

尽管在上面的例子中，kind被存储为Class<T>，但是擦除也意味着它实际将被存储为Class，没有任何的参数。因此当我们将它作为参数传入Array.newInstance时，实际上并没拥有kind的类型信息，因此不会产生具体的结果，所以必须进行转型，并产生一条警告。

---

但是如果创建的是一个容器而不是数组，情况又会变得不一样。例子代码如下。

public class ListMaker<T> {
    List<T> create() {
        return new ArrayList<T>();
    }

    public static void main(String[] args) {
        ListMaker<String> stringMaker = new ListMaker<>();
        List<String> list = stringMaker.create();
    }
}

上面的代码中，编译器不会提出任何警告，尽管在create()内部的new ArrayList<T>中的<T>
被移除了——在运行时，这个类的内部没有任何的<T>，因此看起来毫无意义。但是将代码改为返回new ArrayList()，编译器就会给出警告。
如果在返回list之前，将某些对象放入其中，那么情况就会像下面一样。

public class FilledListMaker<T> {
    List<T> create(T t, int n) {
        List<T> result = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            result.add(t);
        }
        return result;
    }

    public static void main(String[] args) {
        FilledListMaker<String> stringMaker = new FilledListMaker<>();
        List<String> list = stringMaker.create("Hello", 4);
        System.out.println(list);
    }
}

// Outputs
[Hello, Hello, Hello, Hello]

即是上面代码中，编译器无法知道create()中的T的任何信息，但是它仍旧可以在编译器确保代码中放置到result中的对象具有T类型，使其适合ArrayList<T>。因此，即使擦除在方法内部或者类内部移除了有关实际类型的信息，编译器仍可以依旧确保在方法或者类中使用的类型的内部一致性。
因为擦除在方法体中移除了类型信息，所以在运行时的问题就是边界：即对象进入和离开方法的地点。这正是编译器在编译器执行类型检查并插入转型代码的地点。

字节码解析

public class SimpleHolder {
    private Object obj;

    public Object getObj() {
        return obj;
    }

    public void setObj(Object obj) {
        this.obj = obj;
    }

    public static void main(String[] args) {
        SimpleHolder holder = new SimpleHolder();
        holder.setObj("Item");
        String s = (String) holder.getObj();
    }
}

在解析生成的字节码中，可以发现。set()和get()方法将直接存储值和产生值，而转型调用是在get的时候执行检查的。

public class GenericHolder<T> {
    private T obj;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }

    public static void main(String[] args) {
        GenericHolder<String> holder = new GenericHolder<>();
        holder.setObj("Item");
        String s = holder.getObj();
    }
}

字节码中，从get()返回的转型消失了，但是在传递给set()的值在编译器会接受检查。
这与之前所产生的字节码是相同的，而对set()的类型进行检查是不需要的，因为这将由编译器执行，而对get()返回的值进行转型仍然是需要的，但这个与不加泛型执行的操作是一样的。但这将由编译器自动插入，减少了读取与写入的代码噪声。
由于所产生的get()和set()是相同的，所以在泛型中所有的动作都是在边界处发生的，对传入的值做额外的编译期检查，并插入对传递出去的值的转型。要记住的是，边界就是发生动作的地方。