Java 构造方法：用 new 初始化对象

为什么需要构造方法

上一页你创建了类，并用 new 创建了对象。构造方法就是在 new 调用期间真正运行的代码。它唯一的目的是交回一个可以直接使用的对象：所有必需的字段都已设置，没有初始化到一半的状态。

构造方法看起来像方法，但有两点不同：它与类同名，并且没有返回类型，连 void 都没有。

class Point {
    int x;
    int y;

    Point(int x, int y) {     // constructor: same name as class, no return type
        this.x = x;
        this.y = y;
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(3, 4);   // the constructor runs here
        System.out.println(p.x + ", " + p.y);
    }
}

new Point(3, 4) 先分配对象，然后以 x = 3 和 y = 4 运行构造方法体。到 new 返回时，p 已经完全初始化好了。

this 关键字

在上面的构造方法中，参数名是 x 和 y，与字段同名。this.x 表示“这个对象的字段 x”，而单独的 x 指的是参数。没有 this，x = x 只会把参数赋给它自己，字段保持不变。

class Account {
    String owner;
    double balance;

    Account(String owner, double balance) {
        this.owner = owner;       // field = parameter
        this.balance = balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account("Sam", 100.0);
        System.out.println(a.owner + " has " + a.balance);
    }
}

只有当参数遮蔽了字段时才必须写 this，但很多人为了清晰到处都写。常见的错误是名字冲突时忘了写它：代码能编译、能运行，却悄悄让字段保持默认值（null、0、false）。

默认构造方法

如果你从没写过构造方法，Java 会悄悄提供一个默认构造方法：一个公有的、无参数的、不做任何额外事情的构造方法。这就是为什么在完全没有构造方法的类上也能使用 new。

问题在于：只要你写了任何一个构造方法，这个免费的就没有了。

class Box {
    int size;

    Box(int size) {       // now there is NO no-arg constructor
        this.size = size;
    }
}

new Box();   // compile error: no constructor Box() exists

如果你仍希望 new Box() 能用，就自己声明无参构造方法：

class Box {
    int size;

    Box() {               // explicit no-arg constructor
        this.size = 1;
    }

    Box(int size) {
        this.size = size;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Box().size);     // 1
        System.out.println(new Box(10).size);   // 10
    }
}

构造方法重载

一个类可以有多个构造方法，只要它们的参数列表不同。这其实就是把方法重载用在了构造方法上。每个构造方法都提供了一种创建对象的不同方式。

class Rectangle {
    int width;
    int height;

    Rectangle() {                 // a default 1x1 square
        this.width = 1;
        this.height = 1;
    }

    Rectangle(int side) {         // a square
        this.width = side;
        this.height = side;
    }

    Rectangle(int width, int height) {   // a full rectangle
        this.width = width;
        this.height = height;
    }

    int area() { return width * height; }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Rectangle().area());        // 1
        System.out.println(new Rectangle(5).area());       // 25
        System.out.println(new Rectangle(2, 3).area());    // 6
    }
}

Java 会根据你传给 new 的参数个数和类型，选择匹配的构造方法。

用 this() 链式调用

注意上面的重复：每个构造方法都自己给字段赋值。你可以让一个构造方法用 this(...) 调用另一个，从而避免重复。这个调用必须是构造方法中的第一条语句。

class Rectangle {
    int width;
    int height;

    Rectangle() {
        this(1, 1);          // delegates to the two-arg constructor
    }

    Rectangle(int side) {
        this(side, side);    // also delegates
    }

    Rectangle(int width, int height) {   // the single "real" constructor
        this.width = width;
        this.height = height;
    }
}

public class Main {
    public static void main(String[] args) {
        Rectangle r = new Rectangle(4);
        System.out.println(r.width + "x" + r.height);   // 4x4
    }
}

现在真正的初始化只集中在一处。较简单的构造方法只是填上默认值，再把工作转交出去。如果你试图在 this(...) 之前放一条语句，编译器会拒绝。

构造方法与 super()

每个构造方法都会先隐式调用父类的构造方法。如果你什么都不写，Java 会在方法体开头插入一个隐藏的 super()（父类的无参构造方法）。等你开始编写子类时，就会直接用到它，这也是下一个主题。

class Animal {
    String name;
    Animal(String name) { this.name = name; }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);   // must call the parent constructor explicitly here
    }
}

因为 Animal 没有无参构造方法，Dog 必须显式调用 super(name)：没有免费的 super() 可以兜底。和 this() 一样，super(...) 调用也必须是构造方法中的第一条语句。

下一步：继承

构造方法负责初始化单个对象，但 super() 已经暗示了更大的东西：类可以建立在其他类之上，复用它们的字段、方法和构造方法。这种一个类扩展另一个类的关系就是继承，也就是下一页的内容。