Конструкторы в Java: инициализация объектов с помощью new

Зачем нужны конструкторы

На предыдущей странице вы создавали классы и объекты с помощью new. Конструктор — это код, который фактически выполняется во время этого вызова new. Его единственная цель — вернуть вам готовый к использованию объект: со всеми установленными обязательными полями и без наполовину инициализированного состояния.

Конструктор выглядит как метод, но с двумя отличиями: у него то же имя, что и у класса, и нет типа возвращаемого значения — даже void.

class Point {
    int x;
    int y;

    Point(int x, int y) {     // конструктор: то же имя, что и у класса, без типа возврата
        this.x = x;
        this.y = y;
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(3, 4);   // здесь выполняется конструктор
        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;       // поле = параметр
        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) {       // теперь конструктора без аргументов НЕТ
        this.size = size;
    }
}

new Box();   // ошибка компиляции: конструктор Box() не существует

Если вы всё же хотите, чтобы new Box() работал, объявите конструктор без аргументов самостоятельно:

class Box {
    int size;

    Box() {               // явный конструктор без аргументов
        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() {                 // квадрат 1x1 по умолчанию
        this.width = 1;
        this.height = 1;
    }

    Rectangle(int side) {         // квадрат
        this.width = side;
        this.height = side;
    }

    Rectangle(int width, int height) {   // полноценный прямоугольник
        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);          // делегирует конструктору с двумя аргументами
    }

    Rectangle(int side) {
        this(side, side);    // тоже делегирует
    }

    Rectangle(int width, int height) {   // единственный «настоящий» конструктор
        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);   // здесь нужно явно вызвать конструктор родителя
    }
}

Поскольку у Animal нет конструктора без аргументов, Dog обязан явно вызвать super(name) — нет бесплатного super(), на который можно положиться. Как и this(), вызов super(...) должен быть первым оператором в конструкторе.

Далее: Наследование

Конструкторы инициализируют один объект, но super() уже намекнул на нечто большее: классы могут строиться на основе других классов, повторно используя их поля, методы и конструкторы. Эта связь — один класс расширяет другой — называется наследованием, и ей посвящена следующая страница.