Java编程思想：擦除的神秘之处

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
//        ErasureAndInheritance.test();
//        ArrayMaker.test();
        FilledListMaker.test();
    }
}

/*
    15.7 擦除的神秘之处

    Class.getTypeParameters()将返回一个TypeVariable对象数组，表示有
    泛型声明所声明的类型参数。我之前确实有过这种需求，但是这个方法不可能给
    我想要的结果

    问题：
        因此，你可以知道诸如类型参数标识符和泛型类型边界这类的信息——你却无法知道用来
        创建某个特定实例的实际的类型参数。Java泛型是使用擦除来实现的，这意味着当你在
        使用泛型的时候，任何具体的类型信息都被擦除了，你唯一知道的就是你在使用一个对象
        因此List<String>和List<Integer>在运行时事实上是相同的类型。这两种类型都被
        擦除成了它们的“原生”类型，即List。理解擦除以及应该如何处理它，是你在学习Java
        泛型时面临的最大障碍。

            ——既然被擦除了，为什么我们还能取到我们想要的类型

            ——C++中如果你用了泛型，编译器就会对应的生成这个类，这一点还是蛮
            舒服的。
 */

/*
    15.7.1 C++的方式
    C++：
        template<class T> class Manipulator
        {
            T obj;
            public:
            Manipulator(T x) { obj = x;}
            void manipulator() { obj.f();}
        }

    Java: 无法通过编译
        class Manipulator<T>
        {
            T obj;
            public Manipulator(T x) { obj = x; }
            void manipulator() { obj.f();}
        }

    解决问题：
        为了调用f()，我们必须协助泛型类，给定泛型类的边界，以此告知
        编译器只能接受这个边界的类型。这里重用了extends关键字

    <T extends HasF> : 声明T必须具有类型HasF或者从HasF导出的类型，
    我们说泛型类型参数将擦除到它的第一个边界（可能会有多个边界）。
 */
class HasF {
    public void f() {}
}
class Manipulator<T extends HasF>
{
    T obj;
    public Manipulator(T x) { obj = x; }
    void manipulator() { obj.f();}
}

/*
    在我们的案例中，泛型没有任何贡献。我们完全可以自己执行泛型擦除。这一点很重要：
    只有当你希望使用的类型参数比某个具体类型（以及它的所有子类型）更加“泛化”时——
    也就是说，当你希望代码能够跨多个类工作时，使用泛型才有所帮助。
        ——额，为什么不用接口呢？接口不也是这种功能么，甚至比这个还有强大一点

    因此，类型参数和它们在有用的泛型代码中的应用，通常比简单的类替换要更复杂。但是，
    不能因此而认为<T extends HasF>形式的任何东西都是有缺陷的。例如，如果某个类有
    一个返回T的方法，那么泛型就有所帮助，因此它们之后将返回确切的类型。
        ——我想知道，既然类型已经被擦除了，那返回时是如何返回成T的了，
        难道是编译器私下里进行了一次强制转换？
 */

/*
    15.7.3 擦除的问题

    擦除的主要的正当理由是非泛型的代码到泛型到泛型代码的转变过程。擦除的代价是
    显著的。泛型不能用于显式的引用运行时类型的操作之中，例如转型、instanceof
    操作和new表达式。因为所有关于参数的类型的信息都丢失了。
 */

class GenericBase<T>{
    private T element;
    public void set(T arg) { element = arg;}
    public T get(){return  element;}
}

class Dervied1<T> extends GenericBase<T> {}
class Dervied2 extends GenericBase {}

class ErasureAndInheritance{
    static void test() {
        Dervied2 d = new Dervied2();
        Object obj = d.get();
        d.set(obj);
    }
}

/*
    17.5.4 边界处的动作
 */

/*
    编译器不会给出任何警告，尽管我们从擦除中知道在create()内部的new ArrayList<T>
    中的<T>被移除了——在运行时，这个类的内部没有任何的<T>。但是，即使编译无法知道有
    关create()中的T的任何信息，但是它仍旧可以在编译期间确保你放置到result中的对象
    具有T类型，使其适合ArrayList<T>。
 */
class ArrayMaker<T>{
    //运行时实际保存的是Class<Object>
    private Class<T> kind;

    public ArrayMaker(Class<T> kind) {
        //这个地方在运行时，把一个Class<T>赋给了Class<Object>
        this.kind=kind;
    }

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

    public static void test() {
        ArrayMaker<String> s = new ArrayMaker<>(String.class);
        String[] stringArray = s.create();
//        System.out.println(Arrays.toString(stringArray));
    }
}
class ListMaker<T>{
    List<T> create(){return new ArrayList<T>();}

    public static void test() {
        ListMaker<String> s = new ListMaker<>();
        List<String> strs = s.create();
    }
}
class FilledListMaker<T> {
    List<T> create(T t, int n) {
        List<T> result = new ArrayList<T>();
        ; i < n; i++) {
            result.add(t);
        }
        return  result;
    }

    public static void test() {
        FilledListMaker<String> stringMaker = new FilledListMaker<>();
        List<String> list = stringMaker.create();
        System.out.println(list);
    }
}

/*
    因为擦除在方法体中移除了类型信息，所以在运行时的问题就是边界：即对象进入和
    离开方法的地点。这些正是编译器在编译期执行类型检查并插入转型代码的地点。
 */