Java 构造器重载详解：规则、链式调用与实战代码

什么是 Java 构造器？

构造器 是在内存分配后立即初始化新创建对象的特殊方法。它将对象字段设为期望值，若省略则设为默认值。定义构造器是可选的；若无提供，编译器提供默认构造器，赋标准默认值：

• 数值基本类型（int、double 等） → 0
• char → '\0'
• 对象引用 → null

本教程涵盖：

• 创建构造器的规则
• 构造器重载
• 构造器链

创建 Java 构造器的规则

1. 构造器名称必须与类名完全一致。
2. 不能有返回类型，甚至不能是 void。

示例 1 – 第一个构造器

步骤 1：将以下代码输入 Java 编辑器。

class Demo {
    int value1;
    int value2;
    Demo() {
        value1 = 10;
        value2 = 20;
        System.out.println("Inside Constructor");
    }
    public void display() {
        System.out.println("Value1 === " + value1);
        System.out.println("Value2 === " + value2);
    }
    public static void main(String[] args) {
        Demo d1 = new Demo();
        d1.display();
    }
}

步骤 2：编译运行。输出：

Inside Constructor
Value1 === 10
Value2 === 20

Java 构造器重载

Java 允许类定义多个参数列表不同的构造器。编译器按参数数量和类型区分它们。

Account 类的有效构造器可能如下：

Account(int a);
Account(int a, int b);
Account(String a, int b);

示例 2 – 重载构造器

步骤 1：插入以下代码。

class Demo {
    int value1;
    int value2;
    /* Demo() {
        value1 = 10;
        value2 = 20;
        System.out.println("Inside 1st Constructor");
    } */
    Demo(int a) {
        value1 = a;
        System.out.println("Inside 2nd Constructor");
    }
    Demo(int a, int b) {
        value1 = a;
        value2 = b;
        System.out.println("Inside 3rd Constructor");
    }
    public void display() {
        System.out.println("Value1 === " + value1);
        System.out.println("Value2 === " + value2);
    }
    public static void main(String[] args) {
        Demo d1 = new Demo();
        Demo d2 = new Demo(30);
        Demo d3 = new Demo(30, 40);
        d1.display();
        d2.display();
        d3.display();
    }
}

步骤 2：编译运行。会报错，因为添加了带参构造器后默认构造器 Demo() 缺失。要使用默认构造器，必须显式声明：

Demo() {
    // 默认初始化或自定义逻辑
}

取消注释注释块并重新编译，程序即可正确运行。

构造器链

实例化子类时，其父类构造器先执行——这称为 构造器链。

示例 3 – 父子类链式调用

步骤 1：复制下面代码。

class Demo {
    int value1;
    int value2;
    Demo() {
        value1 = 1;
        value2 = 2;
        System.out.println("Inside 1st Parent Constructor");
    }
    Demo(int a) {
        value1 = a;
        System.out.println("Inside 2nd Parent Constructor");
    }
    public void display() {
        System.out.println("Value1 === " + value1);
        System.out.println("Value2 === " + value2);
    }
    public static void main(String[] args) {
        DemoChild d1 = new DemoChild();
        d1.display();
    }
}
class DemoChild extends Demo {
    int value3;
    int value4;
    DemoChild() {
        // super(5); // 取消注释调用重载父类构造器
        value3 = 3;
        value4 = 4;
        System.out.println("Inside the Constructor of Child");
    }
    public void display() {
        System.out.println("Value1 === " + value1);
        System.out.println("Value2 === " + value2);
        System.out.println("Value3 === " + value3);
        System.out.println("Value4 === " + value4);
    }
}

步骤 2：运行程序。因子类构造器未显式调用 super()，默认 Demo() 先运行。预期输出：

Inside 1st Parent Constructor
Inside the Constructor of Child
Value1 === 1
Value2 === 2
Value3 === 3
Value4 === 4

步骤 3：要调用重载父类构造器 Demo(int a)，在子类构造器首行放 super(5);。取消注释该行并重新运行：

Inside 2nd Parent Constructor
Inside the Constructor of Child
Value1 === 5
Value2 === 0
Value3 === 3
Value4 === 4

当需要特定父类构造器在子类逻辑前运行时，使用 super(...) 是强制的。