Что такое статический класс?

Статический класс

Статический класс — это класс или вложенный класс, в котором используются только статические члены (методы, переменные, блоки кода). В Java понятие "статический класс" обычно применяется к вложенным статическим классам (static nested classes), так как верхнеуровневые классы не могут быть объявлены статическими. Статические классы обычно используются для группировки связанной функциональности или константных утилит.

Основные концепции

Статический класс характеризуется:

• Вложенность — объявляется внутри другого класса
• Независимость — не требует экземпляра внешнего класса
• Только статические члены — все методы и переменные статические
• Утилитарность — обычно содержит вспомогательные функции
• Групповые константы — часто используется для группировки констант

Вложенный статический класс

public class OuterClass {
    private static String staticVariable = "статическая переменная";
    private String instanceVariable = "переменная экземпляра";
    
    // Вложенный статический класс
    public static class NestedStaticClass {
        private int value;
        
        public NestedStaticClass(int value) {
            this.value = value;
        }
        
        public int getValue() {
            return value;
        }
        
        // Может обращаться только к статическим членам внешнего класса
        public void printStaticVariable() {
            System.out.println("Внешняя статическая переменная: " + 
                OuterClass.staticVariable);
        }
        
        // НЕ может обращаться к экземплярным членам
        // System.out.println(instanceVariable); // ОШИБКА!
    }
}

public class Main {
    public static void main(String[] args) {
        // Создание экземпляра вложенного статического класса
        // БЕЗ создания экземпляра внешнего класса
        OuterClass.NestedStaticClass nested = 
            new OuterClass.NestedStaticClass(42);
        
        System.out.println(nested.getValue()); // 42
        nested.printStaticVariable(); // статическая переменная
    }
}

Утилитарный статический класс

public final class StringUtils {
    // Приватный конструктор - предотвращает создание экземпляра
    private StringUtils() {
        throw new AssertionError("Этот класс не должен быть инстанцирован");
    }
    
    // Только статические методы
    public static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }
    
    public static String capitalize(String str) {
        if (isEmpty(str)) {
            return str;
        }
        return str.substring(0, 1).toUpperCase() + 
               str.substring(1).toLowerCase();
    }
    
    public static String reverse(String str) {
        return new StringBuilder(str).reverse().toString();
    }
    
    public static String repeat(String str, int times) {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < times; i++) {
            result.append(str);
        }
        return result.toString();
    }
}

// Использование
public class Demo {
    public static void main(String[] args) {
        System.out.println(StringUtils.isEmpty("  ")); // true
        System.out.println(StringUtils.capitalize("hello")); // Hello
        System.out.println(StringUtils.reverse("Java")); // avaJ
        System.out.println(StringUtils.repeat("ab", 3)); // ababab
    }
}

Статический класс с константами

public class Constants {
    // Приватный конструктор
    private Constants() {}
    
    // Константы разделены по категориям в статических классах
    public static final class HTTP {
        public static final int OK = 200;
        public static final int CREATED = 201;
        public static final int BAD_REQUEST = 400;
        public static final int UNAUTHORIZED = 401;
        public static final int NOT_FOUND = 404;
        public static final int INTERNAL_ERROR = 500;
    }
    
    public static final class Database {
        public static final String JDBC_URL = "jdbc:postgresql://localhost/mydb";
        public static final String USERNAME = "admin";
        public static final String PASSWORD = "password";
        public static final int POOL_SIZE = 10;
    }
    
    public static final class Security {
        public static final int PASSWORD_MIN_LENGTH = 8;
        public static final int SESSION_TIMEOUT_MINUTES = 30;
        public static final String ENCRYPTION_ALGORITHM = "SHA-256";
    }
}

// Использование
public class Demo {
    public static void main(String[] args) {
        System.out.println("HTTP Status: " + Constants.HTTP.OK);
        System.out.println("DB URL: " + Constants.Database.JDBC_URL);
        System.out.println("Min Password: " + 
            Constants.Security.PASSWORD_MIN_LENGTH);
    }
}

Сравнение: Статический класс vs Внутренний класс

public class OuterClass {
    private String name = "внешний";
    
    // СТАТИЧЕСКИЙ вложенный класс
    public static class StaticNested {
        public void test() {
            // МОЖЕТ обращаться к статическим членам OuterClass
            // System.out.println(name); // ОШИБКА - name не статический!
        }
    }
    
    // НЕСТАТИЧЕСКИЙ внутренний класс
    public class InnerClass {
        public void test() {
            // МОЖЕТ обращаться ко ВСЕМ членам OuterClass
            System.out.println(name); // OK
            System.out.println(OuterClass.this.name); // OK
        }
    }
}

// Использование
public class Demo {
    public static void main(String[] args) {
        // Статический класс - БЕЗ экземпляра внешнего класса
        OuterClass.StaticNested staticNested = 
            new OuterClass.StaticNested();
        
        // Внутренний класс - ТРЕБУЕТ экземпляра внешнего класса
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
    }
}

Статический класс с Builder паттерном

public class Person {
    private String firstName;
    private String lastName;
    private int age;
    private String email;
    
    private Person(Builder builder) {
        this.firstName = builder.firstName;
        this.lastName = builder.lastName;
        this.age = builder.age;
        this.email = builder.email;
    }
    
    // Вложенный статический класс для создания объектов
    public static class Builder {
        private String firstName = "";
        private String lastName = "";
        private int age = 0;
        private String email = "";
        
        public Builder firstName(String firstName) {
            this.firstName = firstName;
            return this;
        }
        
        public Builder lastName(String lastName) {
            this.lastName = lastName;
            return this;
        }
        
        public Builder age(int age) {
            this.age = age;
            return this;
        }
        
        public Builder email(String email) {
            this.email = email;
            return this;
        }
        
        public Person build() {
            return new Person(this);
        }
    }
    
    @Override
    public String toString() {
        return String.format("%s %s, возраст %d, email %s",
            firstName, lastName, age, email);
    }
}

// Использование
public class Demo {
    public static void main(String[] args) {
        Person person = new Person.Builder()
            .firstName("Иван")
            .lastName("Петров")
            .age(30)
            .email("ivan@example.com")
            .build();
        
        System.out.println(person);
    }
}

Когда использовать статические классы

• Утилиты — сборка статических методов (StringUtils, MathUtils)
• Константы — группировка связанных констант
• Builder паттерн — создание сложных объектов
• Конфигурация — вложенные классы для конфигурации
• Фабрика — создание объектов определённого типа
• Логирование — вспомогательные функции для логирования

Преимущества

• Организация кода — логическая группировка функциональности
• Инкапсуляция — ограничение области видимости
• Производительность — нет overhead экземпляров класса
• Простота — лёгкий доступ через имя класса

Недостатки

• Отсутствие состояния — статические классы не могут хранить состояние
• Тестирование — сложнее тестировать статические методы
• Зависимости — сложнее инъецировать зависимости

Статические классы — полезный инструмент для организации утилитарного кода и констант в Java приложениях.