What would be the use of accepting itself as type arguments in generics

Question

I saw some code on an unrelated question but it got me curious as I never saw such construct with Java Generics. What would be the use of creating a generic class that can take

Answer 1

Generics aren't just for containers like lists. This sort of "extends itself" type parameter is used to let the superclass refer to the subclass in places like method parameters and return types, even though no actual specific subclass is available when the superclass is compiled. It's analogous to the curiously recurring template pattern in C++.

A subclass of your example would be declared as

class Foo extends A<Foo>

and the inherited foo() method becomes

void foo(Foo x)

See how A defined a method that takes a Foo parameter even though it doesn't actually know about Foo?

Yes, this sort of thing is unusual, but not unheard of: the built-in Enum class uses a similar trick.

Answer 2

Without this, the parameter to the method foo could not be bound to type E.

If you have an implementation B of this abstract class, you can now enforce that method foo also requires its parameter to be of type B.

 class B extends A<B> {
      void foo (B x){}
 }

Without that, foo would have to take any kind of A.

I agree that the syntax for this is less than elegant.