Interfaces and defining Generics

Question

This could be a sophisticated question. At least it drives me crazy. ;)
We define the following generic class:
public class Generic2 <E extends TestClass & TestInterface> {
     public E getTheGenericType() {
          return null;
}So it is assured that E is is of type 'TestClass' AND from type 'TestInterface', right?
Now I could use Generic2 like this:
Generic2 myGen = new Generic2<TestDataClass>();
TestClass test =  myGen.getTheGenericType();That works fine! Also it should be possible to define:
TestInterface inter = myGen.getTheGenericType();But this line generates the compiler-error:
Type mismatch: cannot convert from TestClass to TestInterface
Can somebody please explain what's going wrong here?

Answer 1

The compiler is correct. When you use
Generic2 myGenthe type of the myGen will be raw type Generic2, but not a generic type (JLS 4.8). As declared in JLS
The type of a constructor (�8.8), instance method (�8.8, �9.4), or non-static field (�8.3) M of a raw type C that is not inherited from its superclasses or superinterfaces is the erasure of its type in the generic declaration corresponding to C. The type of a static member of a raw type C is the same as its type in the generic declaration corresponding to C.
And, from JLS 4.6
The erasure of a type variable (�4.4) is the erasure of its leftmost bound.
So, when method getTheGenericType is used in the context of raw type, it have return type "erasure of E", which is "leftmost bound", i.e. TestClass. And TestClass does not implements TestInterface, which leads to type mistmatch.
But when myGen is declared as instance of generic type (like Generic2<TestDataClass> or Generic2<?>), then all compiles fine (because return type of getTheGenericType is E (not TestClass, as was in the case of the row type), and E implements TestInterface, as declared in the E bound).
See the following code:
public class Test {
     static interface TestInterface {
     static class TestClass {
     static class Generic2 <E extends TestClass & TestInterface> {
          public E getTheGenericType() {
               return null;
     class TestDataClass extends TestClass implements TestInterface {
     public static void main(String [] args) {
          //this declaration lead to compilation error
          //Generic2 myGen = new Generic2<TestDataClass>();
          //and this declaration does not
          //Generic2<TestDataClass> myGen = new Generic2<TestDataClass>();
          //and this does not too
          Generic2<?> myGen = new Generic2<TestDataClass>();
          TestClass test = myGen.getTheGenericType();
          TestInterface inter = myGen.getTheGenericType();
}The first declaration (commented) gives type mistmatch, but both other compiles filne.
P.S. JLS is "Java Language Specification, 3rd edition"