例如，在selenium自动化中，你有一个PageObject，它可以像这样使用它的父类构造函数:

public class DeveloperSteps extends ScenarioSteps {

public DeveloperSteps(Pages pages) {
    super(pages);
}........

我已经看到了所有的答案。但大家都忘了提一个非常重要的问题:

Super()应该在构造函数的第一行中调用或使用。

super关键字可用于调用超类构造函数和引用超类的成员

当您使用正确的参数调用super()时，实际上调用了构造函数Box，它通过使用相应参数的值来初始化变量width、height和depth。你只剩下初始化它的增值权重。如果有必要，现在可以将类变量Box设为私有。放在Box类私有修饰符的字段中，并确保您可以毫无问题地访问它们。

在超类中可以有多个重载版本的构造函数，因此可以使用不同的参数调用方法super()。程序将执行与指定参数匹配的构造函数。

public class Box {

    int width;
    int height;
    int depth;

    Box(int w, int h, int d) {
        width = w;
        height = h;
        depth = d;
    }

    public static void main(String[] args){
        HeavyBox heavy = new HeavyBox(12, 32, 23, 13);
    }

}

class HeavyBox extends Box {

    int weight;

    HeavyBox(int w, int h, int d, int m) {

        //call the superclass constructor
        super(w, h, d);
        weight = m;
    }

}

来源文章:Java:调用super()

是的。Super(…)将调用超类的构造函数。

说明:

独立的例子:

class Animal {
    public Animal(String arg) {
        System.out.println("Constructing an animal: " + arg);
    }
}

class Dog extends Animal {
    public Dog() {
        super("From Dog constructor");
        System.out.println("Constructing a dog.");
    }
}

public class Test {
    public static void main(String[] a) {
        new Dog();
    }
}

打印:

Constructing an animal: From Dog constructor
Constructing a dog.

我们可以用SUPER做什么?

访问超类成员

如果你的方法覆盖了它的一些超类的方法，你可以通过使用关键字super来调用被覆盖的方法，比如super. methodname ();

调用超类构造函数

如果构造函数没有显式调用超类构造函数，Java编译器会自动插入对超类的无参数构造函数的调用。如果超类没有无参数构造函数，则会得到编译时错误。

看看下面的代码:

class Creature {
    public Creature() {
        system.out.println("Creature non argument constructor.");
    }
}

class Animal extends Creature {
    public Animal (String name) {
        System.out.println("Animal one argument constructor");
    }
    public Animal (Stirng name,int age) {
        this(name);
        system.out.println("Animal two arguments constructor");
    }
}

class Wolf extends Animal {
    public Wolf() {
        super("tigerwang",33);
        system.out.println("Wolf non argument constructor");
    }
    public static void main(string[] args) {
        new Wolf();
    }
}

When creating an object,the JVM always first execute the constructor in the class of the top layer in the inheritance tree.And then all the way down the inheritance tree.The reason why this is possible to happen is that the Java compiler automatically inserts a call to the no-argument constructor of the superclass.If there's no non-argument constructor in the superclass and the subclass doesn't explicitly say which of the constructor is to be executed in the superclass,you'll get a compile-time error.

类的构造函数，在上面的代码中，如果我们想成功地创建Wolf对象 类必须执行。在这个过程中，Animal中的双参数构造函数 类被调用。同时，它显式地调用同一个参数中的单参数构造函数 类和单参数构造函数隐式调用生物中的非参数构造函数 类和非参数构造函数再次隐式调用Object中的空构造函数 类。

如前所述，在默认构造函数内部，在构造函数的第一行调用隐式super()。

这个super()自动调用从类层次结构顶部开始的构造函数链，并向下移动层次结构。

如果程序的类层次结构中有两个以上的类，顶层类的默认构造函数将首先被调用。

下面是一个例子:

class A {
    A() {
    System.out.println("Constructor A");
    }
}

class B extends A{

    public B() {
    System.out.println("Constructor B");
    }
}

class C extends B{ 

    public C() {
    System.out.println("Constructor C");
    }

    public static void main(String[] args) {
    C c1 = new C();
    }
} 

以上将输出:

Constructor A
Constructor B
Constructor C