Klasy w Javie: pola, metody i obiekty

Klasa to plan

Do tej pory twój kod żył w metodach, które przekazują sobie zwykłe wartości. Klasa pozwala połączyć powiązane dane i działające na nich zachowanie w jeden nazwany typ. Klasa jest planem, a rzeczy, z którymi faktycznie pracujesz, to utworzone z niej obiekty.

Klasa deklaruje dwa rodzaje składowych: pola (dane, które przechowuje każdy obiekt) i metody (to, co każdy obiekt potrafi zrobić).

class Dog {
    String name;          // pole: każdy Dog ma imię
    int age;              // kolejne pole

    void bark() {         // metoda: zachowanie, które ma każdy Dog
        System.out.println(name + " says woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();    // tworzy obiekt na podstawie planu
        d.name = "Rex";       // ustawia jego pola
        d.age = 3;
        d.bark();             // wywołuje jego metodę
    }
}

new Dog() buduje obiekt w pamięci i zwraca referencję do niego. d.name i d.bark() sięgają do tego konkretnego obiektu.

Każdy obiekt ma własny stan

Cały sens klasy polega na tym, że możesz utworzyć wiele niezależnych obiektów, z których każdy ma własne wartości pól. Zmiana jednego nigdy nie dotyka innego.

class Dog {
    String name;

    void bark() {
        System.out.println(name + " barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog rex = new Dog();
        rex.name = "Rex";

        Dog bella = new Dog();
        bella.name = "Bella";

        rex.bark();     // Rex barks
        bella.bark();   // Bella barks
    }
}

rex i bella to dwa osobne obiekty. Każdy ma własne name, więc każde bark() wypisuje inną wartość. Takie dane należące do konkretnego obiektu to stan instancji.

Pola i metody działają razem

Metody w klasie mogą bezpośrednio odczytywać i zmieniać pola swojego obiektu, bez przekazywania ich jako parametrów. Metoda już „żyje” w obiekcie, którego dane zmienia.

class Counter {
    int count;            // domyślnie zaczyna od 0

    void increment() {
        count++;          // zmienia pole tego obiektu
    }

    int value() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c = new Counter();
        c.increment();
        c.increment();
        c.increment();
        System.out.println(c.value());   // 3
    }
}

Zauważ, że increment() nie przyjmuje argumentów. Działa na polu tego obiektu Counter, na którym ją wywołano. To właśnie różni metodę klasy od swobodnej metody statycznej: metoda ma niejawny obiekt, na którym działa.

Słowo kluczowe this

Wewnątrz metody this to referencja do obiektu, na którym wywołano metodę. Zwykle go nie potrzebujesz: napisanie count już oznacza this.count. this staje się jednak niezbędne, gdy nazwa parametru koliduje z nazwą pola, co zdarza się ciągle w setterach i konstruktorach.

class Point {
    int x;
    int y;

    void move(int x, int y) {
        this.x = x;       // this.x to pole, x to parametr
        this.y = y;
    }

    void show() {
        System.out.println("(" + x + ", " + y + ")");
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point();
        p.move(4, 7);
        p.show();         // (4, 7)
    }
}

Częsty błąd początkujących to napisanie x = x; w move. To po prostu przypisuje parametr samemu sobie i nie zmienia pola. Kompilator nie ostrzeże, a obiekt po cichu zachowa stare wartości. Pole faktycznie aktualizuje dopiero this.x = x;.

Domyślne wartości pól i referencje null

Gdy tworzysz obiekt, jego pola nie zawierają śmieci: Java ustawia im wartości domyślne, czyli 0 dla liczb, false dla boolean i null dla referencji do obiektów, takich jak String. Ta domyślna wartość null to źródło klasycznej awarii.

class User {
    String name;          // nieprzypisane, więc domyślnie null
}

public class Main {
    public static void main(String[] args) {
        User u = new User();
        System.out.println(u.name.length());   // NullPointerException
    }
}

u.name to null, bo nikt go nie ustawił, więc wywołanie na nim .length() rzuca NullPointerException. Zawsze przypisuj sensowne wartości, zanim użyjesz pól obiektu. Właśnie ten problem rozwiązują konstruktory.

Organizowanie kodu wokół klas

Prawdziwe programy modelują swoją dziedzinę jako klasy, które trzymają razem dane i operacje na nich. Tutaj jedna klasa BankAccount przechowuje saldo i pilnuje, jak się ono zmienia:

class BankAccount {
    String owner;
    double balance;

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;     // za mało środków
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount acc = new BankAccount();
        acc.owner = "Sam";
        acc.deposit(100.0);
        boolean ok = acc.withdraw(30.0);

        System.out.println(acc.owner + " balance: " + acc.balance);  // 70.0
        System.out.println("withdrawal succeeded: " + ok);
    }
}

Dane (balance) i zasady ich zmiany (deposit, withdraw) są w jednym miejscu. Kod w innych miejscach prosi konto o wykonanie operacji, zamiast bezpośrednio zmieniać jego liczby. To podstawa czystego projektu, który łatwo utrzymać.

Dalej: konstruktory

Ustawianie każdego pola ręcznie po new jest żmudne i łatwo o nim zapomnieć, a jak widać, zapomniane pole zostawia null, który czeka, by wywołać awarię. Konstruktor pozwala wymagać i inicjalizować pola obiektu w chwili jego utworzenia, dzięki czemu BankAccount nigdy nie istnieje bez właściciela. To temat następnej strony.