generics - Java Type Erasure: Rules of cast insertion?

Question

The Java tutorial on type erasure doesn't seem to detail the specific rules of cast insertion by the compiler. Can someone please explain the specific rules that cause the transformation detailed by the tutorial (reproduced below):

public class Node<T> {
    public T data;

    public Node(T data) { this.data = data; }

    public void setData(T data) {
        System.out.println("Node.setData");
        this.data = data;
    }
}
public class MyNode extends Node<Integer> {
    public MyNode(Integer data) { super(data); }

    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }
}

MyNode mn = new MyNode(5);
Node n = (MyNode)mn;         // A raw type - compiler throws an unchecked warning
n.setData("Hello");
Integer x = (String)mn.data; // Causes a ClassCastException to be thrown.

Specifically, I'm wondering what rules cause the insertion of (MyNode) and (String). When is a cast inserted, and how is the type chosen for the cast?

Answer 1

The ClassCastException would be throw when a call is made to

n.setData("Hello");

This is because the compiler builds bridge methods to preserve polymorphism. The bridge method will look like:

 public void setData(Object data) {
       setData((Integer)data);   //the exception is thrown here
  }

since an instance of a string cannot be converted to Integer, the ClassCastException would be thrown.

You can read about bridge methods here.