Java: Why is this Subclass valid?

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

Generic type arguments are optional. If you use a class with generic arguments without those argument it is called a raw type. So yes you can use A without generic arguments.

See Raw Types from the Java Generics FAQ.

Answer 2

When generics were added, Java wanted to keep backward compatibility with previous versions. So, generics are options optional, AND the generic info is used at compile time, but completely dropped at runtime (it's called type erasure).

Answer 3

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)
}

Answer 4

Sidestepping a bit from the original question here but this declaration bugs me. Not to say that it is fundamentally wrong but it does raise question here as to the use of generics.

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

looks to me like a generic object that does operations on instances of itself, the only possible use of generics would be so that the parent instance can auto-cast to one of it's child decided at compile time... One way to make method signature declared in the parent auto-cast in child objects to the child-itself...

Maybe I am just thinking too much for a Monday morning !!