目录

  1. Java 构造方法概述
  2. 构造方法的特点
  3. Java 构造方法的分类
  4. 构造方法的重载
  5. 构造方法与 this 关键字
  6. 构造方法与 super 关键字
  7. 私有构造方法与单例模式
  8. 静态代码块与构造方法的执行顺序
  9. 参考资料
  10. 出站链接

1. Java 构造方法概述

构造方法（Constructor） 是一种特殊的方法，在创建对象时自动调用，用于初始化对象的状态。

class Person {
    String name;

    // 构造方法
    public Person() {
        System.out.println("构造方法被调用");
        name = "未命名";
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person(); // 创建对象时自动调用构造方法
        System.out.println("姓名: " + p.name);
    }
}

输出：

构造方法被调用
姓名: 未命名

2. 构造方法的特点

  • 方法名与类名相同。
  • 没有返回类型（甚至不能写 void）。
  • 在创建对象时自动调用，无需手动调用。
  • 可以有参数，用于初始化对象的不同状态。

3. Java 构造方法的分类

默认构造方法

如果没有显式定义构造方法，Java 会提供一个默认构造方法，它不执行任何操作。

class Animal {
    String name;

    // 默认构造方法（编译器自动生成）
    public Animal() {
        System.out.println("Animal 的默认构造方法被调用");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal a = new Animal();
    }
}

输出：

Animal 的默认构造方法被调用

有参构造方法

带参数的构造方法用于初始化对象时传递参数。

class Dog {
    String name;

    // 有参构造方法
    public Dog(String dogName) {
        name = dogName;
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy");
        System.out.println("狗的名字是: " + myDog.name);
    }
}

输出：

狗的名字是: Buddy

4. 构造方法的重载

Java 允许构造方法重载，即同一个类中可以有多个构造方法，但参数不同。

class Car {
    String brand;
    int year;

    // 无参构造方法
    public Car() {
        brand = "未知";
        year = 0;
    }

    // 有参构造方法（重载）
    public Car(String brandName, int carYear) {
        brand = brandName;
        year = carYear;
    }
}

public class Main {
    public static void main(String[] args) {
        Car car1 = new Car();
        System.out.println(car1.brand + " - " + car1.year);

        Car car2 = new Car("Toyota", 2022);
        System.out.println(car2.brand + " - " + car2.year);
    }
}

输出：

未知 - 0
Toyota - 2022

5. 构造方法与 this 关键字

在构造方法中，this 关键字可以：

  • 区分成员变量和局部变量。
  • 调用当前类的另一个构造方法。
class Student {
    String name;
    int age;

    // 构造方法
    public Student(String name, int age) {
        this.name = name; // 使用 this 区分成员变量
        this.age = age;
    }

    public void display() {
        System.out.println("姓名: " + name + ", 年龄: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Student s = new Student("Alice", 20);
        s.display();
    }
}

输出：

姓名: Alice, 年龄: 20

6. 构造方法与 super 关键字

  • super 用于调用父类的构造方法，必须放在构造方法的第一行。
class Parent {
    public Parent() {
        System.out.println("父类构造方法");
    }
}

class Child extends Parent {
    public Child() {
        super(); // 调用父类构造方法
        System.out.println("子类构造方法");
    }
}

public class Main {
    public static void main(String[] args) {
        Child c = new Child();
    }
}

输出：

父类构造方法
子类构造方法

7. 私有构造方法与单例模式

  • 单例模式 确保一个类只有一个实例，构造方法设为 private。
class Singleton {
    private static Singleton instance;

    // 私有构造方法
    private Singleton() {}

    // 获取唯一实例
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class Main {
    public static void main(String[] args) {
        Singleton obj1 = Singleton.getInstance();
        Singleton obj2 = Singleton.getInstance();

        System.out.println(obj1 == obj2); // true
    }
}

8. 静态代码块与构造方法的执行顺序

class Demo {
    static {
        System.out.println("静态代码块执行");
    }

    {
        System.out.println("实例代码块执行");
    }

    public Demo() {
        System.out.println("构造方法执行");
    }
}

public class Main {
    public static void main(String[] args) {
        new Demo();
        new Demo();
    }
}

输出：

静态代码块执行
实例代码块执行
构造方法执行
实例代码块执行
构造方法执行

执行顺序：

  1. 静态代码块（只执行一次）。
  2. 实例代码块（每次创建对象时执行）。
  3. 构造方法。

9. 参考资料

10. 出站链接