Question

public class MyGeneric<T, E> {}

public class Extend1<T, E> extends MyGeneric<T, E> {}

public class Extend2 extends MyGeneric<String, Object> {}

As far as I am aware, both of the subclasses in the above example are valid. I was wondering how Java knows when the types given in the superclass are going to be defined when the subclass is instantiated, and when they are actual class names (i.e. How does it know T, E are not class names)?

A side note, is it permissible (even if uncommon) to use more than one letter for the generic types? What if (through some sever error of planning) The types conflict with an existing class e.g.

public class E{}
public class Foo<E>{}

what happens then?

Edit: Thanks for answering so promptly.
To answer my first question, Joachim’s answer is most effective.

To answer the side point, aioobe’s answer is clearer

Answer 1

Let’s look at this definition:

public class Extend1<T, E> extends MyGeneric<T, E> {}

Here T and E are each present twice and in two different roles

• in Extend1<T,E> you define type arguments. This means that the type Extend1 has two (unbounded) type arguments T and E. This tells the Java compiler that those who use Extend1 need to specify the types.
• in extends MyGeneric<T,E> you use the previously defined type arguments. If T and E were not known to be type arguments here, then T and E would be simple type references, i.e. the compiler would look for classes (or interfaces, …) named T and E (and most likely not find them).

Yes, type arguments follow the same syntactic rules as any other identifier in Java, so you can use multiple letters ABC or even names that can be confusing (using a type argument called String is legal, but highly confusing).

Single-letter type argument names are simply a very common naming strategy.