java中如何对父类构造函数重写

在Java中，父类的构造函数是不能被子类重写的。 这是因为构造函数在Java中并不是真正的方法，而是一种特殊的代码块，用于初始化对象。构造函数的名称与类名相同，并且没有返回类型。虽然子类不能重写父类的构造函数，但子类可以通过使用 super 关键字调用父类的构造函数，并在其自身的构造函数中添加额外的初始化逻辑。

下面将详细解释如何在Java中通过构造函数实现父类和子类的初始化，以及在子类中调用父类的构造函数。

一、构造函数的基本概念

构造函数的定义

在Java中，构造函数用于创建对象并初始化其状态。每个类都有一个默认的无参构造函数，如果开发者没有提供任何构造函数，编译器会默认提供一个无参构造函数。

public class Parent {
    public Parent() {
        System.out.println("Parent constructor called");
    }
}
public class Child extends Parent {
    public Child() {
        System.out.println("Child constructor called");
    }
    public static void main(String[] args) {
        Child child = new Child();
    }
}

在上述代码中，创建 Child 对象时，首先调用父类 Parent 的无参构造函数，然后调用子类 Child 的无参构造函数。

调用父类构造函数

在子类的构造函数中，可以使用 super 关键字来调用父类的构造函数。super 关键字必须是子类构造函数中的第一个语句。

public class Parent {
    public Parent(String message) {
        System.out.println("Parent constructor called with message: " + message);
    }
}
public class Child extends Parent {
    public Child(String message) {
        super(message);
        System.out.println("Child constructor called with message: " + message);
    }
    public static void main(String[] args) {
        Child child = new Child("Hello");
    }
}

在上述代码中，Child 的构造函数调用了 Parent 的带参构造函数，并传递了一个字符串参数。

二、在子类中调用父类构造函数的规则和最佳实践

`super` 关键字的使用

在子类构造函数中，使用 super 关键字来调用父类构造函数是非常常见的做法。它允许子类在进行自身特定的初始化之前，首先完成父类的初始化工作。这对于确保对象的正确构造和继承层次结构的正确性非常重要。

public class Parent {
    public Parent() {
        System.out.println("Parent no-arg constructor called");
    }
    public Parent(String message) {
        System.out.println("Parent constructor called with message: " + message);
    }
}
public class Child extends Parent {
    public Child() {
        super();
        System.out.println("Child no-arg constructor called");
    }
    public Child(String message) {
        super(message);
        System.out.println("Child constructor called with message: " + message);
    }
    public static void main(String[] args) {
        Child child1 = new Child();
        Child child2 = new Child("Hello");
    }
}

子类构造函数必须调用父类构造函数

如果父类没有无参构造函数，子类必须显式调用父类的带参构造函数，否则编译器会报错。

public class Parent {
    public Parent(String message) {
        System.out.println("Parent constructor called with message: " + message);
    }
}
public class Child extends Parent {
    public Child() {
        // super(); // 编译错误：父类没有无参构造函数
        super("Default message");
        System.out.println("Child no-arg constructor called");
    }
    public Child(String message) {
        super(message);
        System.out.println("Child constructor called with message: " + message);
    }
    public static void main(String[] args) {
        Child child1 = new Child();
        Child child2 = new Child("Hello");
    }
}

在上述代码中，Child 的无参构造函数显式调用了父类的带参构造函数。

三、构造函数链

在Java中，构造函数链是指在创建对象时，调用一系列的构造函数，直到最顶层的父类构造函数被调用为止。这通常通过使用 super 关键字来实现。

public class Grandparent {
    public Grandparent() {
        System.out.println("Grandparent constructor called");
    }
}
public class Parent extends Grandparent {
    public Parent() {
        super();
        System.out.println("Parent constructor called");
    }
}
public class Child extends Parent {
    public Child() {
        super();
        System.out.println("Child constructor called");
    }
    public static void main(String[] args) {
        Child child = new Child();
    }
}

在上述代码中，创建 Child 对象时，首先调用 Grandparent 的构造函数，然后调用 Parent 的构造函数，最后调用 Child 的构造函数。

四、构造函数中的多态性

构造函数在调用过程中并不遵循多态性原则，也就是说，父类构造函数不会调用子类的重写方法。

public class Parent {
    public Parent() {
        System.out.println("Parent constructor called");
        display();
    }
    public void display() {
        System.out.println("Parent display method called");
    }
}
public class Child extends Parent {
    public Child() {
        super();
        System.out.println("Child constructor called");
    }
    @Override
    public void display() {
        System.out.println("Child display method called");
    }
    public static void main(String[] args) {
        Child child = new Child();
    }
}

在上述代码中，即使 Child 重写了 display 方法，父类构造函数仍然调用的是父类的 display 方法，而不是子类的。

五、构造函数中的异常处理

在构造函数中可以使用异常处理机制来捕获和处理异常。子类构造函数必须遵循父类构造函数的异常声明规则。

public class Parent {
    public Parent() throws Exception {
        System.out.println("Parent constructor called");
        if (true) {
            throw new Exception("Exception in Parent constructor");
        }
    }
}
public class Child extends Parent {
    public Child() throws Exception {
        super();
        System.out.println("Child constructor called");
    }
    public static void main(String[] args) {
        try {
            Child child = new Child();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，Parent 构造函数抛出一个异常，Child 构造函数必须声明同样的异常或其父类异常。

六、总结

在Java中，虽然子类不能重写父类的构造函数，但可以通过使用 super 关键字在子类的构造函数中调用父类的构造函数。这种机制确保了对象在创建时能够正确初始化，并且遵循类的继承层次结构。构造函数在Java中扮演着重要的角色，它们不仅用于对象的初始化，还用于确保对象的构造过程是安全和正确的。

通过理解构造函数的工作原理、如何在子类中调用父类构造函数、构造函数链、多态性和异常处理机制，开发者可以更好地设计和实现Java应用程序，确保代码的健壮性和可维护性。