Why won't Java let you inherit from a generic type-variable?

Question

public class MyClass<T> extends T {...}

The above declaration will fail to compile with the error:

error: unexpected type
class MyClass<T> extends T {}
                         ^
  required: class
  found:    type parameter T
  where T is a type-variable:
    T declared in class MyClass

I can't really think of a reason for this to happen, so I am wondering if someone can shed some light on why it is that Java won't let you inherit from a generic type-variable.

There's probably a thousand reasons why this is not allowed... — Sweeper, Jun 09 '18 at 14:43
For people asking "what if" questions, this is allowed in C++, so it's not actually beyond the pale. https://ideone.com/fjzJcN (Or maybe it is and C++ just has features which are beyond the pale. Anyway, the "what ifs" can be dealt with.) — Radiodef, Jun 09 '18 at 14:49
`T` is a type parameter (or variable), not a type on its own. You can only `extend` types (class, interface). — Bhesh Gurung, Jun 09 '18 at 15:04
Also see https://docs.oracle.com/javase/tutorial/java/generics/erasure.html and https://stackoverflow.com/questions/339699/java-generics-type-erasure-when-and-what-happens — Radiodef, Jun 09 '18 at 15:05

score 2 · Answer 1 · answered Jun 09 '18 at 15:05

Java has quite a lot of language restrictions unlike C++ for example. What you want is not possible for many reasons listed in the comments (T might be final or have abstract methods). However, you are allowed to extend from a supertype having the generic type parameter:

public class MyClass<T> extends AnotherClass<T>

You might find the following alternative interesting:

public class MyClass<T extends AnotherClass> extends AnotherClass

What you want to do does make not much sense.

score 2 · Accepted Answer · answered Jun 09 '18 at 15:16

The most obvious reason I can think of isn't even about type-erasure; it is the fact that when you make A a subclass of B, the Java compiler needs to know what constructors B has. If a class does not have a no-arguments constructor, then its sub-classes must call one of its defined constructors. But when you declare

public class MyClass<T> extends T {...}

It is absolutely impossible for the compiler to know what the super constructors are, since T is not fixed at compile-time (that's the whole point of generics after all), which is a situation that cannot be allowed in Java.

score 1 · Answer 3 · answered Jun 09 '18 at 15:11

Your question is not so weird as it may look like :) Consider how would you deal with following:

Suppose your real class for T has a single constructor with 3 parameters. How would you implement the constructor of inherited class, if you don't know how to call the super constructor?
Suppose your real class for T has public final methods and you have defined methods with the same signature in the inherited class. What method would your object have? You cannot resolve such conflict.

score 0 · Answer 4 · answered Jun 09 '18 at 15:00

Simple deductions based on your question.

T is a type.

MyClass extends T - MyClass is enhanced version of T.

MyClass < T> extends T - MyClass is enhanced T, but only for Type T.

there is no reason to state ' I extend T but only for type T'.

If you extend T, MyClass is already a Type of T & definitely not some X,Y or Z.

Generics are needed if you want to ensure Type safety, if you extend it is already type safe.

Why won't Java let you inherit from a generic type-variable?

4 Answers4