Konstruktory w Javie: inicjalizacja obiektów przez new

Po co są konstruktory

Na poprzedniej stronie budowałeś klasy i tworzyłeś obiekty przez new. Konstruktor to kod, który faktycznie wykonuje się podczas wywołania new. Jego jedynym celem jest zwrócenie obiektu gotowego do użycia: ze wszystkimi wymaganymi polami ustawionymi i bez częściowo zainicjalizowanego stanu.

Konstruktor wygląda jak metoda, ale z dwiema różnicami: ma taką samą nazwę jak klasa i nie ma typu zwracanego, nawet void.

class Point {
    int x;
    int y;

    Point(int x, int y) {     // konstruktor: ta sama nazwa co klasa, bez typu zwracanego
        this.x = x;
        this.y = y;
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(3, 4);   // tu wykonuje się konstruktor
        System.out.println(p.x + ", " + p.y);
    }
}

new Point(3, 4) przydziela pamięć na obiekt, a potem wykonuje ciało konstruktora z x = 3 i y = 4. Zanim new zwróci wynik, p jest w pełni zainicjalizowany.

Słowo kluczowe this

W konstruktorze powyżej parametry nazywają się x i y, tak samo jak pola. this.x oznacza „pole x należące do tego obiektu”, a samo x odnosi się do parametru. Bez this zapis x = x przypisałby parametr samemu sobie i nie zmieniłby pola.

class Account {
    String owner;
    double balance;

    Account(String owner, double balance) {
        this.owner = owner;       // pole = parametr
        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 jest konieczne tylko wtedy, gdy parametr przesłania pole, ale wiele osób używa go wszędzie dla przejrzystości. Częsty błąd to zapomnienie o nim przy kolizji nazw: kod się kompiluje, działa i po cichu zostawia pola z wartościami domyślnymi (null, 0, false).

Konstruktor domyślny

Jeśli nigdy nie napiszesz konstruktora, Java po cichu dostarcza konstruktor domyślny: publiczny, bezargumentowy konstruktor, który nie robi nic dodatkowego. Dlatego new działało dla klas, które w ogóle nie miały konstruktora.

Haczyk: gdy tylko napiszesz jakikolwiek konstruktor, darmowy znika.

class Box {
    int size;

    Box(int size) {       // teraz NIE ma konstruktora bezargumentowego
        this.size = size;
    }
}

new Box();   // błąd kompilacji: nie istnieje konstruktor Box()

Jeśli nadal chcesz, by działało new Box(), sam zadeklaruj konstruktor bezargumentowy:

class Box {
    int size;

    Box() {               // jawny konstruktor bezargumentowy
        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
    }
}

Przeciążanie konstruktorów

Klasa może mieć kilka konstruktorów, o ile różnią się listą parametrów: to po prostu przeciążanie metod zastosowane do konstruktorów. Każdy z nich oferuje inny sposób zbudowania obiektu.

class Rectangle {
    int width;
    int height;

    Rectangle() {                 // domyślny kwadrat 1x1
        this.width = 1;
        this.height = 1;
    }

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

    Rectangle(int width, int height) {   // pełny prostokąt
        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 wybiera pasujący konstruktor na podstawie liczby i typów argumentów przekazanych do new.

Łańcuchowanie przez this()

Zauważ powtórzenia powyżej: każdy konstruktor sam przypisuje pola. Możesz tego uniknąć, gdy jeden konstruktor wywołuje inny przez this(...). To wywołanie musi być pierwszą instrukcją w konstruktorze.

class Rectangle {
    int width;
    int height;

    Rectangle() {
        this(1, 1);          // przekazuje pracę konstruktorowi z dwoma argumentami
    }

    Rectangle(int side) {
        this(side, side);    // również przekazuje
    }

    Rectangle(int width, int height) {   // jedyny "prawdziwy" konstruktor
        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
    }
}

Teraz właściwa inicjalizacja jest w jednym miejscu. Mniejsze konstruktory tylko uzupełniają wartości domyślne i przekazują pracę dalej. Jeśli spróbujesz umieścić jakąś instrukcję przed this(...), kompilator to odrzuci.

Konstruktory i super()

Każdy konstruktor najpierw niejawnie wywołuje konstruktor nadklasy. Jeśli nic nie napiszesz, Java wstawia na początku ciała ukryte super() (bezargumentowy konstruktor nadklasy). Zaczniesz z tym pracować bezpośrednio, gdy zaczniesz tworzyć podklasy, a to temat następnej strony.

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

class Dog extends Animal {
    Dog(String name) {
        super(name);   // tu trzeba jawnie wywołać konstruktor rodzica
    }
}

Animal nie ma konstruktora bezargumentowego, więc Dog musi jawnie wywołać super(name): nie ma darmowego super(), na którym mógłby polegać. Podobnie jak this(), wywołanie super(...) musi być pierwszą instrukcją w konstruktorze.

Dalej: dziedziczenie

Konstruktory inicjalizują pojedynczy obiekt, ale super() już zasugerowało coś większego: klasy mogą budować na innych klasach i ponownie wykorzystywać ich pola, metody i konstruktory. Ta relacja, w której jedna klasa rozszerza inną, to dziedziczenie. Omawia je następna strona.