Why is it important to create a default constructor explicitly when we create a parametrized constructor explicitly??

So first off, the code you are showing is not Java. It might be Grrovy or Kotlin or some other Java-like language that compiles to the JVM. But it is not pure Java.

Secondly:

we should keep in mind that every subclass calls super class constructor first

Not true. Calling the superclass's constructor is a choice that you, the developer, makes.

You do not need to define a default constructor unless you actually call the default constructor explicitly.

It is also just bad practice to leave an implicit definition of a constructor. Be explicit. The implicit default constructor is only useful in two cases:

• The class is the main entrypoint, is static, and therefore needs no constructor
• You are quickly writing some mockup code

In all other cases, declare your constructor explicitly, even if it does nothing.

The superclass constructor is not called implicitly when a subclass is instantiated. Superclass constructors always need to be called explicitly. Constructors are not inhereted.

Your example code is a too large, it looks like you missed something.

Consider the following:

Contents of ./cons/Sub.java

package cons;

import cons.Super;

public class Sub {
    public Sub(String text) {
        System.out.println("Sub called with "+text);
    }

    public static void main(String[] args) {
        Sub s1 = new Sub("hi");
        Sub s2 = new Sub();
    }
}

Contents of ./cons/Super.java

package cons;

public class Super {
    public Super(String text) {
        System.out.println("Super called with "+text);
    }
}

Compile and run:

$ javac cons/*.java
$ java cons.Sub
Sub called with hi
Default sub called.

So if you are getting an error by which a constructor has been called without being defined, then it is because you actually called a constructor without defining it.

Simplify your example code. And actually state the correct language.