什么是 Java 构造方法？
在 Java 中，当我们创建一个对象时，往往需要为这个对象赋予初始状态。比如你买了一台新手机，它出厂时可能已经预装了系统、设置了默认名称、电量是 100%。这个“初始化”的过程，就是通过 Java 构造方法来完成的。
构造方法是一种特殊的方法，它的名字必须与类名完全一致，并且没有返回类型（连 void 都不能写）。每当使用 new 关键字创建对象时，Java 会自动调用对应的构造方法，完成对象的初始化。
想象一下：你走进一家餐厅，服务员问你“要吃点什么？”你点了一份“红烧肉套餐”。这个“点餐”过程，就是构造方法在起作用——它决定了你拿到的是什么“状态”的食物。而服务员（Java 虚拟机）会根据你的选择，立刻为你准备好一份完整的餐品。
我们来看一个最简单的例子：
public class Phone {
// 成员变量：手机的品牌和电量
private String brand;
private int battery;
// 这就是构造方法！名字与类名一致，无返回类型
public Phone(String brand, int battery) {
this.brand = brand; // 初始化品牌
this.battery = battery; // 初始化电量
}
// getter 方法，用于获取成员变量的值
public String getBrand() {
return brand;
}
public int getBattery() {
return battery;
}
}
在这个例子中，Phone 类的构造方法接受两个参数：品牌和初始电量。当我们用 new Phone("华为", 80) 创建对象时，Java 会自动调用这个构造方法，把参数值赋给 this.brand 和 this.battery。
💡 小贴士：
this关键字代表当前对象，this.brand就是“当前这个 Phone 对象的 brand 变量”。
构造方法的特性与规则
构造方法虽然看起来简单，但有一些硬性规则必须遵守，否则代码无法编译通过。
1. 方法名必须与类名完全一致
这是一条铁律。比如类名叫 Student，构造方法就必须叫 Student，不能叫 initStudent 或 createStudent。
public class Student {
private String name;
private int age;
// ✅ 正确：方法名与类名一致
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// ❌ 错误：方法名不一致，编译报错
// public void Student(String name, int age) { } // 有返回类型，不是构造方法
}
2. 不能有返回类型
连 void 都不能写。如果写了，Java 会把它当成普通方法，而不是构造方法。
public class Car {
private String color;
// ✅ 正确：无返回类型
public Car(String color) {
this.color = color;
}
// ❌ 错误：写了 void，不再是构造方法
// public void Car(String color) { this.color = color; }
}
3. 可以重载，但不能重写
Java 支持构造方法重载，即一个类可以有多个构造方法，只要参数列表不同。这就像你去餐厅，可以点“套餐 A”、“套餐 B”、“套餐 C”，但每种套餐的配置不同。
public class Coffee {
private String type;
private int size;
// 无参构造方法：默认是美式咖啡，中杯
public Coffee() {
this.type = "美式";
this.size = 300;
}
// 有参构造方法：指定类型，中杯
public Coffee(String type) {
this.type = type;
this.size = 300;
}
// 有参构造方法：指定类型和杯型
public Coffee(String type, int size) {
this.type = type;
this.size = size;
}
}
此时你可以这样使用：
Coffee c1 = new Coffee(); // 使用无参构造方法
Coffee c2 = new Coffee("拿铁"); // 使用单参数构造方法
Coffee c3 = new Coffee("卡布奇诺", 400); // 使用双参数构造方法
⚠️ 注意：构造方法不能被子类“重写”（override），只能被“重载”（overload）。重写是针对普通方法的，构造方法由父类决定，子类只能通过
super()调用。
默认构造方法与手动定义
如果你在类中没有定义任何构造方法，Java 会自动为你提供一个默认构造方法，也就是无参的构造方法。
public class Book {
private String title;
private String author;
// 你没有写构造方法，Java 会自动提供：
// public Book() { }
}
此时你可以这样创建对象：
Book b = new Book(); // ✅ 合法，使用默认构造方法
但一旦你手动添加了任意一个构造方法，Java 就不会再自动生成默认构造方法。这很关键！
public class Book {
private String title;
private String author;
// 手动定义了一个有参构造方法
public Book(String title, String author) {
this.title = title;
this.author = author;
}
// ❌ 此时再调用 new Book() 会编译错误！
// 因为默认构造方法已经没了
// Book b = new Book(); // 编译错误：找不到匹配的构造方法
}
所以，如果你希望类既能用 new Book() 也能用 new Book("Java 入门", "张三")，就必须显式定义无参构造方法：
public Book() {
// 可以什么都不做，或者设置默认值
this.title = "未知";
this.author = "未知";
}
构造方法中的 this 与 super
在构造方法中，this 和 super 是两个非常重要的关键字，它们的使用有严格的顺序。
this：调用本类的其他构造方法
this() 可以用来调用本类中另一个构造方法，实现代码复用。但必须放在第一行。
public class Rectangle {
private double width;
private double height;
// 无参构造方法：默认宽高为 1.0
public Rectangle() {
this(1.0, 1.0); // 调用另一个构造方法
}
// 有参构造方法：指定宽高
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
}
这里 this(1.0, 1.0) 必须是第一行，否则编译会报错。
super：调用父类构造方法
当类有继承关系时，子类构造方法必须先调用父类构造方法。否则会报错。
public class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
}
public class Dog extends Animal {
private String breed;
// 子类构造方法
public Dog(String name, String breed) {
super(name); // 必须第一行，调用父类构造方法
this.breed = breed;
}
}
✅ 重要规则：
this()和super()都必须是构造方法的第一条语句，且只能出现一次。
实际应用：创建复杂对象
构造方法在实际项目中非常实用。比如你正在开发一个电商系统，需要创建一个订单对象。
public class Order {
private String orderId;
private String customerName;
private double totalAmount;
private String status; // 状态：待支付、已发货、已完成
// 构造方法：创建新订单时初始化关键信息
public Order(String orderId, String customerName, double totalAmount) {
this.orderId = orderId;
this.customerName = customerName;
this.totalAmount = totalAmount;
this.status = "待支付"; // 默认状态
}
// getter 方法
public String getOrderId() {
return orderId;
}
public String getCustomerName() {
return customerName;
}
public double getTotalAmount() {
return totalAmount;
}
public String getStatus() {
return status;
}
// 修改状态的方法
public void setStatus(String status) {
this.status = status;
}
}
使用方式：
Order order = new Order("ORD20240405", "李四", 299.99);
System.out.println("订单号：" + order.getOrderId());
System.out.println("客户：" + order.getCustomerName());
System.out.println("金额：" + order.getTotalAmount());
System.out.println("状态：" + order.getStatus()); // 输出：待支付
这样，你通过一次 new Order(...) 操作，就完成了对象的完整初始化，代码简洁又安全。
小结：Java 构造方法的核心价值
Java 构造方法是对象生命周期的起点。它确保了每个对象在创建时都处于一个合法且一致的初始状态。
- 它是对象“出生”的仪式，决定你拿到的是什么样子的初始状态。
- 它支持重载，让你可以灵活地创建不同配置的对象。
- 它必须遵循规则：名字一致、无返回类型、不能重写。
- 它与
this和super密切配合，是实现代码复用和继承的关键。
掌握 Java 构造方法，就等于掌握了创建对象的“钥匙”。无论是新手还是有经验的开发者，理解并正确使用它，都能写出更健壮、更清晰的代码。
当你下次写一个类时，不妨先问自己：“这个对象在创建时，需要哪些初始数据？”——答案，往往就是构造方法的参数。