Thread: type erasure

Note: This may not be the appropriate subforum, but I found no way to select one for my thread. I apologize in advance.

I am quite familiar with C and C++, but new to Java. With some trivial modifications for brevity, I find the following example of type erasure in Oracle's The Java Tutorials perplexing:

Given the following two classes:

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

Consider the following code:

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

After type erasure, the code becomes:

     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.

End of example

Type erasure merely adds the two type casts to the original code. The author writes that "trying to assign a String to an Integer (my note: in the final line of the type erasure code) causes a ClassCastException from a cast inserted at the assignment by a Java compiler."

To me, though, the two type casts are superfluous. (MyNode) type casts a MyNode object to a MyNode. How does this contribute anything? And the ClassCastException should be thrown at run-time even without the (String) type cast.

What am I missing?

Thanks in advance.

This is just an example of how the compiler catches misuses of generic types. I just don't see why the two compiler casts in the type erasure code are needed at all here--especially why the misuse wouldn't be caught at runtime without the (String) cast in the erasure code, which the author of the example said was needed for this purpose.