Статические члены в Java: static-поля и методы

Принадлежность классу, а не объекту

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

Это единственное различие объясняет static-поля, static-методы, константы и даже то, почему main всегда static.

Общее static-поле

Нестатическое поле даёт каждому объекту собственную ячейку. static-поле даёт классу одну ячейку, общую для всех. Классический пример — счётчик, отслеживающий, сколько объектов было создано:

class User {
    static int count = 0;     // одна общая ячейка на весь класс
    String name;              // по одной на объект

    User(String name) {
        this.name = name;
        count++;              // увеличиваем общий счётчик при каждом создании
    }
}

public class Main {
    public static void main(String[] args) {
        new User("Ada");
        new User("Linus");
        new User("Grace");

        System.out.println("users created: " + User.count);
    }
}

Обратите внимание, что вы читаете счётчик как User.count — через имя класса, потому что значение не принадлежит ни одному конкретному User. Каждое name, напротив, живёт внутри своего объекта. Измените count через любой экземпляр — и все экземпляры увидят новое значение, потому что оно одно.

static-методы

static-метод тоже принадлежит классу, поэтому вы вызываете его на классе без объекта:

class MathUtils {
    static int square(int x) {
        return x * x;
    }

    static int max(int a, int b) {
        return a > b ? a : b;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(MathUtils.square(7));
        System.out.println(MathUtils.max(3, 9));
    }
}

Именно этот приём лежит в основе стандартной библиотеки: Math.max, Integer.parseInt, Arrays.sort и List.of — все они static, это служебное поведение, которому не нужен объект для работы. Прибегайте к static-методу, когда работа зависит только от аргументов, а не от состояния какого-либо объекта.

Главная ловушка: static не видит instance

static-метод выполняется без какого-либо объекта, поэтому this отсутствует. Это значит, что он не может напрямую обращаться к полям экземпляра или вызывать методы экземпляра — нет конкретного объекта, из которого их прочитать. Это самая частая ошибка новичков со static:

class Account {
    int balance = 100;          // поле экземпляра

    static int show() {
        return balance;         // ОШИБКА КОМПИЛЯЦИИ: к нестатическому полю 'balance'
    }                           // нельзя обратиться из статического контекста
}

Исправление: либо сделать метод методом экземпляра (убрать static, чтобы у него появился this), либо передать объект явно:

class Account {
    int balance = 100;

    static int show(Account a) {     // принимаем объект как параметр
        return a.balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account();
        System.out.println(Account.show(a));
    }
}

Обратное направление работает без проблем: метод экземпляра может свободно читать static-поля и вызывать static-методы, потому что общие данные уровня класса существуют всегда.

Константы со static final

Сочетайте static с final — и получите константу: одно общее значение, которое никогда не может измениться. По соглашению их называют в стиле UPPER_SNAKE_CASE:

class Circle {
    static final double PI = 3.14159265;

    double radius;

    Circle(double radius) { this.radius = radius; }

    double area() {
        return PI * radius * radius;   // метод экземпляра, использующий static-константу
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.printf("%.2f%n", new Circle(2).area());
    }
}

static final — идиоматичный способ выразить «фиксированное значение, принадлежащее типу», как, например, Integer.MAX_VALUE или Math.PI в стандартной библиотеке. Сделать его static — значит не тратить по копии на каждый объект; сделать его final — значит никто не сможет его переприсвоить.

Статические блоки инициализации

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

import java.util.HashMap;
import java.util.Map;

class Roman {
    static final Map<Character, Integer> VALUES = new HashMap<>();

    static {                       // выполняется один раз, при загрузке класса
        VALUES.put('I', 1);
        VALUES.put('V', 5);
        VALUES.put('X', 10);
        VALUES.put('L', 50);
    }

    static int valueOf(char c) {
        return VALUES.get(c);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Roman.valueOf('X') + Roman.valueOf('I'));
    }
}

Блок срабатывает ровно один раз, сколько бы раз вы ни использовали класс, что делает его подходящим местом для разовой настройки в масштабе всего класса.

Когда использовать static

Быстрое правило:

• Используйте static-поле только для данных, которые действительно общие для всех экземпляров — счётчик, кеш, константа. Если два объекта могут разумно хранить разные значения, это должно быть поле экземпляра.
• Используйте static-метод, когда результат зависит только от аргументов, а не от состояния какого-либо объекта (чистые служебные функции).
• По умолчанию выбирайте члены экземпляра. Злоупотребление static незаметно превращает программу в кучу глобального состояния, которое трудно тестировать и понимать. static — это исключение, а не отправная точка.

Далее: перечисления (Enum)

Константа static final хороша для одного фиксированного значения, но когда у вас есть небольшой фиксированный набор связанных значений — направления, дни недели, статусы заказа — в Java есть специально созданный тип, более безопасный и выразительный, чем разрозненные константы. Это enum, и о нём — следующая страница.