Question

Here, I have an abstract class:

abstract class A<E extends A> {
    abstract void foo(E x);
}

Here’s a class that extends A:

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

And here’s another (E is B here on purpose):

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

Both of those classes are valid, and the reasoning for that makes sense to me.

However what confuses me is how this could possibly be valid:

class D extends A{
    void foo(A x){}
}

Since when are generics optional like that? I thought the extending class (subclass) of A would be required to specify an E?

---

Edit:

The two answers received so far say that E defaults to an Object if no argument is provided.

Alright – well then why doesn’t this work (below)?

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

Answer 1

well then why doesn’t this work (below)?

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

Because you defined class A<E extends A>; you’ve raised the floor to A instead of Object. This works fine:

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

---

You can use reflection/bytecode decompilation to examine what the generic types/methods actually compile to at run time.

import java.lang.reflect.*;

public static void listMethods(Class<?> klazz) {
    System.out.println("Declared methods for " + klazz);
    for (Method m : klazz.getDeclaredMethods()) {
        System.out.println(m);
    }       
}
public static void main(String args[]) {
    listMethods(A.class);
    // Declared methods for class A
    // abstract void A.foo(A)
}