Why superclass constructor must be called with super() and not with its class name?

For starters, rules are simple. Can the child exist before the parent? No. That is why we always call super() when creating a subclass. In that way, every member of the superclass gets "copied" to the subclass.

So I will give example:

  class Duck extends Animal {
    int size;

        public Duck(int size) {
            super();
            this.size = size;
        }
    }

My question is why can't we call Animal constructor with Animal() and not super(). Or, why can't we do this:

class Duck extends Animal {
    int size;

        public Duck(int size) {
            Animal();
            this.size = size;
        }
    }

Shouldn't both codes compile? I mean there is technically no difference between them and the compiler can pretty much know that Duck IS-A Animal by the keyword extends. So what is the problem then?

> Why superclass constructor must be called with super() and not with its class name?

Simple. It is because that is how the Java syntax was designed.

Hypothetically, they could have designed the Java syntax so that you could also¹ use the name of the superclass rather than super. But they didn't. End of story, really. (The design decisions were made prior to 1995, and it is way too late to change them.)

For the record, the relevant syntax is specified in JLS 8.8.7.1 and the grammar production is ExplicitConstructorInvocation.

^{1 - We don't know the details of why they chose super over other possibilities. It was a long time ago, and the meetings were private. However, as a general rule providing two ways to say the same thing in a programming language does not achieve anything practical. In fact, it probably only serves to make the language more difficult to read ... and learn.}

A good programming language is one that lets the author be expressive about their intent with as few syntactical variations as possible in which to achieve that. The more variations there are, the more rules a programmer has to carry around in their head, and the more complex a compiler has to be to support all those variations.

Suppose I eschew Java naming conventions and use a capital letter in the name of a static method:

class Duck extends Animal {
    int size;

    public Duck(int size) {
        Animal();       //super or static method?
        this.size = size;
    }

    private static void Animal() {
        System.out.println("I'm a static method");
    }
}

Is the Duck constructor calling the Animal constructor or the static method? We could introduce a new rule which covers this case but it would be introducing more complexity.

What you are suggesting is two ways to achieve exactly the same thing. There is no reason to support that when super fulfills that purpose perfectly well on its own.

Why don't they also allow us to use parent() or superconstructor() or superclass()? The onus is on you to provide a compelling reason why it should be supported.

>That is why we always call super() when creating a subclass.

I think the answer is in the question:
Because you're creating a subclass.

>My question is why can't we call Animal constructor with Animal() and not super().

From within your subclass you have no access to the "Animal()" constructor.

If you want to read more about your dilemma: https://www.w3schools.com/java/java_inheritance.asp