java Cast Exception

以下都是错误的。问题是我对运行时泛型擦除机制理解不够，太low。

Pair<Employee> pair
List<String> list = new ArrayList<String>();

这里给List设置String,能在编译阶段起到检查的功能，也就是如果如下，编译的时候会报错。

list.add(100)

但是一旦通过编译到了运行阶段，泛型String会被擦除，就没有String 之分了，只有一个单纯的List。

更进一步说，什么能够在编译阶段检查出来呢？
就如同上面，代码调用含泛型参数的接口，传入一个参数，会对这个参数的类型进行检查。但是别指望运行期间给你做什么了。

但是对于工作代码，就要谨慎了。比如方法中有一句代码是这样的：

T t =（T）obj；

那么实际的情况，这就没有作用，类型强转发生在代码运行中的。在class文件的形式就是:
Object t = (Object) obj;

记住这种实例方式

List<String> list = new ArrayList<String>();

到了Class那里就变成

List list = new ArrayList();

也就是在运行中跟String 没有半点联系。

但如果你是这样的

class MyArrayList extends ArrayList<String> {

}

那么在MyArrayList.class 中所有的泛型都会被替换为String .那么此时如果运行代码中出现

T t =（T）obj；

就是我们期望的结果了。

综上 ，这是我所碰到的问题，也是一个陷阱

 public class TestOne<T> {
    Listener<T> listener = null;
    T str;

    public void setListener(Listener<T> listener) {
        this.listener = listener;
    }

    public void setValue(String v) {
        str = (T) v;
    }

    public void run() {
        listener.onChanged(str);
    }


    public static void main(String[] args) {
        TestOne<String> test = new TestOne<String>();
        test.setListener(new MyListener());
        test.setValue("hello");
        test.run();
    }
}

class MyListener implements Listener<String> {
    public void onChanged(String... addr) {
        System.out.println("onChanged:" + addr);
    }
}

interface Listener<T> {
    void onChanged(T... addr);
}

TestOne是个公共类，其实现和具体的String类没有任何关联， 而其实例化过程被

        TestOne<String> test = new TestOne<String>();

被蒙蔽了，在运行过程中，其内部的泛型全部替换为Object,那么在其对象中跑的数据也都是Object,所以传入到onChanged也为Object类型，这样发生Cast Exception在所难免，看class文件，在传递给onChanged函数前，会进行Object[] 强转。但是如果将数组更改为ArrayList就是ok的。：

public class TestTwo<T> {
    ListenerTwo<T> listener = null;
    T str;

    public void setListener(ListenerTwo<T> listener) {
        this.listener = listener;
    }

    public void setValue(String v) {
        str = (T) v;
    }

    public void run() {
        ArrayList<T> list = new ArrayList<T>();
        list.add(str);
        listener.onChanged(list);
    }


    public static void main(String[] args) {
        TestTwo<String> test = new TestTwo<String>();
        test.setListener(new MyListenerTwo());
        test.setValue("hello");
        test.run();
    }
}

class MyListenerTwo implements ListenerTwo<String> {
    public void onChanged(ArrayList<String> addr) {
        System.out.println("onChanged:" + addr.get(0));
    }
}

interface ListenerTwo<T> {
    /**
     * 如果使用... 就会出现[Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
     */
    void onChanged(ArrayList<T> addr);
}

背景:

interface A<T> {  //T是泛型
    void method(T data) ;
}

class B  implement A<D> {
    void method(D data)  {
        ...
    }
}

调用:

class Caller {
        E  data; // E是D的抽象类，为什么不直接用D呢，因为Caller自身是个共用类，所以E选用的是抽象类，不跟具体业务类D挂钩。
        B  b;
        void call(E data) {
            b.method(data);//在调用这个的时候，出现cast异常。
    }
}

问题：

这个和Integer及int的自动装箱完全没有关联，你将一个E对象赋给D对象，而中间没有经过强转，当然是有问题的。

如何解决：

方法一:反射

class Caller {
        E  data; 
        B  b;
        void call(E data) {
        //通过反射获取得到b.method的参数类类型Class classOfD
        //data经过类型强转  classOfD.cast(data)
        b.method(data);
    }
}

方法二：泛型

class Caller<T> { 
        T  data; 
        B  b;
        void call(T data) {
            b.method(data);
    }
}

//实际调用时
Caller<D> caller = new Caller();

总结：