Классы в Java: определение полей, методов и объектов

Класс — это чертёж

До сих пор ваш код жил в методах, которые передавали друг другу простые значения. Класс позволяет объединить связанные данные и работающее с ними поведение в единый именованный тип. Класс — это чертёж; настоящие сущности, с которыми вы работаете, — это объекты, созданные по нему.

Класс объявляет два вида членов: поля (данные, которые хранит каждый объект) и методы (то, что каждый объект умеет делать).

class Dog {
    String name;          // поле: у каждого Dog есть имя
    int age;              // ещё одно поле

    void bark() {         // метод: поведение, которое есть у каждого Dog
        System.out.println(name + " says woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();    // создать объект по чертежу
        d.name = "Rex";       // задать его поля
        d.age = 3;
        d.bark();             // вызвать его метод
    }
}

new Dog() создаёт объект в памяти и возвращает вам ссылку на него. d.name и d.bark() обращаются именно к этому объекту.

У каждого объекта своё состояние

Весь смысл класса в том, что вы можете «штамповать» множество независимых объектов, каждый из которых несёт собственные значения полей. Изменение одного никогда не касается другого.

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 и bella — два отдельных объекта. У каждого своё name, поэтому каждый bark() печатает разное значение. Эти данные, привязанные к объекту, называют состоянием экземпляра.

Поля и методы работают вместе

Методы внутри класса могут напрямую читать и обновлять собственные поля объекта — их не нужно передавать как параметры. Метод уже «живёт на» том объекте, чьи данные он трогает.

class Counter {
    int count;            // по умолчанию начинается с 0

    void increment() {
        count++;          // обновляет поле этого объекта
    }

    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
    }
}

Обратите внимание, что increment() не принимает аргументов. Он работает с полем, принадлежащим тому Counter, на котором вы его вызвали. В этом и состоит разница между методом класса и свободным статическим методом: у метода есть неявный объект, над которым он действует.

Ключевое слово this

Внутри метода this — это ссылка на объект, на котором был вызван метод. Обычно оно вам не нужно: запись count уже означает this.count. Но this становится незаменимым, когда имя параметра сталкивается с именем поля, что постоянно случается в сеттерах и конструкторах.

class Point {
    int x;
    int y;

    void move(int x, int y) {
        this.x = x;       // this.x — это поле; x — это параметр
        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)
    }
}

Частая ошибка новичков — написать x = x; внутри move. Это лишь присваивает параметр самому себе и оставляет поле нетронутым: компилятор вас не предупредит, а ваш объект молча сохранит свои прежние значения. Именно this.x = x; действительно обновляет поле.

Значения полей по умолчанию и ссылки null

Когда вы создаёте объект, его поля не остаются мусором — Java инициализирует их значениями по умолчанию: 0 для чисел, false для boolean и null для ссылок на объекты вроде String. Это значение null по умолчанию и есть источник классического сбоя.

class User {
    String name;          // не присвоено, поэтому по умолчанию null
}

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

u.name равно null, потому что его никто не задал, поэтому вызов .length() на нём выбрасывает NullPointerException. Всегда присваивайте объекту осмысленные значения, прежде чем использовать его поля, — именно эту проблему и решают конструкторы.

Организация кода вокруг классов

Реальные программы моделируют свою предметную область как классы, которые держат вместе данные и операции над ними. Здесь единственный класс BankAccount хранит баланс и контролирует, как он меняется:

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;     // недостаточно средств
    }
}

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);
    }
}

Данные (balance) и правила их изменения (deposit, withdraw) живут в одном месте. Код из других частей просит счёт что-то сделать, а не ковыряется напрямую в его числах, — это основа чистого и поддерживаемого дизайна.

Далее: конструкторы

Задавать каждое поле вручную после new утомительно и легко забыть — и, как вы только что видели, забытое поле оставляет null, ожидающий сбоя. Конструктор позволяет требовать и инициализировать поля объекта в самый момент его создания, так что BankAccount никогда не сможет существовать без владельца. Об этом — следующая страница.