Геттеры и сеттеры в Java: концепция JavaBeans

Класс с двумя открытыми полями выглядит безобидно — до первого вызова вроде этого:

CircleWrong circle = new CircleWrong();
circle.diam = 25;
circle.radius = 10;   // компилятор молчит, объект в невозможном состоянии

Диаметр 25 при радиусе 10 — геометрически невозможно, но Java такое рассогласование не заметит: она проверяет типы, а не смысл. Именно от подобных молчаливых поломок инвариантов и защищают геттеры и сеттеры.

Геттер — это public метод, который возвращает значение поля класса. Сеттер — это public метод, который присваивает полю новое значение. Поля при этом объявляют с модификатором private, поэтому обратиться к ним напрямую извне класса нельзя — только через эти методы. Такой класс, где приватные поля закрыты парами get/set, называют JavaBean.

Что такое геттеры и сеттеры

Если поле объявлено как private, оно видно только внутри своего класса. Но данные объекта всё равно нужно читать и изменять снаружи, иначе такое поле бессмысленно. Поэтому доступ открывают через специальные public методы:

• геттер (getter, метод доступа) — возвращает значение поля;
• сеттер (setter, метод изменения) — записывает в поле новое значение.

Поле, к которому есть такая пара методов, называют свойством (property) класса. Важно, что имя свойства определяется именно именами методов, а не именем поля: для фреймворков вроде Jackson или Hibernate класс — это набор его геттеров и сеттеров, а как называется поле внутри, они не знают.

Правила именования: get, set и is

Имя метода строится по строгой схеме: берётся имя свойства, его первая буква переводится в верхний регистр и к результату добавляется префикс.

Требования к сигнатурам:

1. Геттер объявляется как public, не принимает параметров и возвращает значение типа свойства.
2. Сеттер объявляется как public, возвращает void и принимает ровно один параметр типа свойства.

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

Ключевое слово this в сеттере обязательно: параметр age перекрывает поле age, и без this. строка age = age присвоит параметр самому себе, а поле останется нулевым. Компилятор такую строку пропустит — предупреждение выдаст только IDE или статический анализатор.

Концепция JavaBeans: требования к классу

JavaBean — это обычный Java-класс, оформленный по соглашению, которое позволяет внешним инструментам работать с ним, ничего не зная о его устройстве. Соглашение состоит из четырёх пунктов.

На это соглашение опирается практически весь Java-экосистемный инструментарий: Jackson и Gson при работе с JSON, JPA/Hibernate при отображении объектов на таблицы БД, Spring при внедрении зависимостей через сеттеры, JSP и Expression Language при обращении ${person.fullName}, JavaFX при привязке свойств к элементам интерфейса. Подробности описаны в документации класса Introspector.

Пример: класс Person

Класс Person с тремя приватными полями и полным набором методов доступа. Обратите внимание на isRetired(): поле имеет примитивный тип boolean, поэтому префикс is здесь допустим.

import java.io.Serializable;

public class Person implements Serializable {
    private String fullName;
    private int age;
    private boolean retired;

    public Person() {
    }

    public Person(String fullName, int age, boolean retired) {
        this.fullName = fullName;
        this.age = age;
        this.retired = retired;
    }

    public String getFullName() {
        return fullName;
    }

    public void setFullName(String fullName) {
        this.fullName = fullName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public boolean isRetired() {
        return retired;
    }

    public void setRetired(boolean retired) {
        this.retired = retired;
    }
}

public class PersonExample {
    public static void main(String[] args) {
        Person person = new Person();
        person.setFullName("Петров Иван Иванович");
        person.setAge(56);
        person.setRetired(false);

        System.out.println("Полное имя: " + person.getFullName());
        System.out.println("Возраст: " + person.getAge());
        System.out.println("Пенсионер? " + person.isRetired());
    }
}

Полное имя: Петров Иван Иванович
Возраст: 56
Пенсионер? false

Для чего нужны геттеры и сеттеры

Геттеры и сеттеры делают код многословнее, поэтому вопрос «зачем они, если можно объявить поле public» возникает у всех. Ответ виден на примере класса, где два поля связаны между собой.

public class CircleWrong {
    int radius;   // модификатор не указан: поле видно всему пакету
    int diam;
}

Любой класс из того же пакета может изменить эти поля напрямую. Значения должны быть согласованы — диаметр вдвое больше радиуса, — но ничто этого не гарантирует:

public class CircleWrongExample {
    public static void main(String[] args) {
        CircleWrong circle = new CircleWrong();
        circle.diam = 25;
        circle.radius = 10;

        System.out.println("Диаметр: " + circle.diam);   // 25
        System.out.println("Радиус: " + circle.radius);  // 10  — противоречие
    }
}

Объект хранит бессмысленную комбинацию, и все дальнейшие вычисления по нему будут неверными. Причём ошибка проявится не здесь, а где-нибудь в отчёте через три модуля — искать её придётся долго.

Перепишем класс по концепции JavaBeans и добавим в сеттеры логику: каждый из них пересчитывает второе поле, а заодно отсекает отрицательные значения.

public class Circle {
    private double radius;
    private double diam;

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        if (radius < 0) {
            throw new IllegalArgumentException("Радиус не может быть отрицательным: " + radius);
        }
        this.radius = radius;
        this.diam = radius * 2;
    }

    public double getDiam() {
        return diam;
    }

    public void setDiam(double diam) {
        if (diam < 0) {
            throw new IllegalArgumentException("Диаметр не может быть отрицательным: " + diam);
        }
        this.diam = diam;
        this.radius = diam / 2;
    }
}

public class CircleExample {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.setDiam(25);

        System.out.println(circle.getDiam());    // 25.0
        System.out.println(circle.getRadius());  // 12.5 — согласовано
    }
}

Теперь состояние объекта нельзя привести в противоречивый вид: какой бы сеттер ни вызвали, второе поле пересчитается автоматически. Это и есть главный смысл сеттера — не «присвоить значение», а сохранить инвариант класса.

Логика внутри геттера

Геттер тоже не обязан быть однострочником return field;. Он может отдавать вычисленное или урезанное представление данных. Классический пример — пароль, который нельзя показывать целиком: возвращаем первый символ, остальное заменяем звёздочками.

public class User {
    private String login;
    private String password;

    public User(String login, String password) {
        this.login = login;
        this.password = password;
    }

    public String getLogin() {
        return login;
    }

    public void setLogin(String login) {
        this.login = login;
    }

    public String getMaskedPassword() {
        if (password == null || password.isEmpty()) {
            return "";
        }
        return password.charAt(0) + "*****";
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

public class UserExample {
    public static void main(String[] args) {
        User user = new User("mylogin", "mypassword");
        System.out.println("Логин: " + user.getLogin());
        System.out.println("Пароль: " + user.getMaskedPassword());
    }
}

Логин: mylogin
Пароль: m*****

IDE и Lombok: не писать это руками

Методы доступа никто не набирает вручную. В IntelliJ IDEA их генерирует Alt + Insert → Getter and Setter, в Eclipse — Source → Generate Getters and Setters. IDE сама расставит префиксы, включая is для примитивного boolean.

Второй вариант — библиотека Lombok, которая генерирует методы на этапе компиляции по аннотациям:

import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Getter
@Setter
@NoArgsConstructor
public class Person {
    private String fullName;
    private int age;
    private boolean retired;
}

В байт-коде появятся getFullName(), setFullName(String), isRetired() и остальные — обращаться к ним можно как к обычным методам. Аннотации можно ставить и над отдельным полем, если нужен, например, только геттер.

Records вместо JavaBeans

Начиная с Java 16, для классов, единственная задача которых — хранить данные, есть record:

public record Person(String fullName, int age, boolean retired) {
}

Компилятор сам создаёт приватные final поля, конструктор со всеми параметрами, equals(), hashCode() и toString(), а также методы доступа. Но обращение к ним выглядит иначе:

Person person = new Person("Петров Иван Иванович", 56, false);
System.out.println(person.fullName());  // не getFullName()
System.out.println(person.retired());   // не isRetired()

Формально record не является JavaBean: у него нет ни сеттеров, ни конструктора без аргументов, а имена методов не соответствуют соглашению. Современные библиотеки научились с этим работать напрямую (Jackson поддерживает records с версии 2.12), а вот Hibernate использовать record как сущность не позволяет — там по-прежнему нужен изменяемый класс с конструктором без аргументов. Подробности — в JEP 395.

На чём чаще всего ошибаются

1. Геттер возвращает изменяемую коллекцию. Метод getRoles(), отдающий сам List, полностью сводит инкапсуляцию на нет: вызывающий код может сделать person.getRoles().clear() и опустошить внутреннее состояние объекта. Возвращайте List.copyOf(roles) или Collections.unmodifiableList(roles).
2. Поле начинается с одной строчной буквы перед заглавной. Для поля sName IDE сгенерирует getsName(), и стандартный интроспектор увидит свойство sName вместо ожидаемого. Соглашение декапитализации: если первые два символа имени метода после префикса — заглавные (getURL()), имя свойства остаётся как есть — URL; во всех остальных случаях первая буква переводится в нижний регистр.
3. Сеттер, который только присваивает. Пара пустых get/set над каждым полем ничем не лучше public поля — только длиннее. Смысл появляется, когда внутри есть валидация, пересчёт связанных полей или защитное копирование. Если для поля не нужно ни того, ни другого и меняться оно не должно — сеттер не пишите вовсе.
4. Вызов сеттера из конструктора. Если наследник переопределит сеттер, он выполнится до инициализации полей подкласса и увидит их со значениями по умолчанию. В конструкторе присваивайте полям значения напрямую.
5. Забытый конструктор без аргументов. Как только в классе появляется конструктор с параметрами, конструктор по умолчанию исчезает — и Hibernate падает с InstantiationException, а Jackson с InvalidDefinitionException. Объявляйте его явно, как в примере с Person.