Какие знаешь атрибуты класса?

Атрибуты класса в Java

Атрибуты класса (field modifiers) — это ключевые слова, которые определяют свойства и поведение переменных класса. Разберу все основные атрибуты.

1. Модификаторы доступа (Access Modifiers)

Это самые важные атрибуты класса, определяющие видимость полей:

public class AccessModifiersExample {
    // public — доступен везде, из любого пакета
    public String publicField = "доступен отовсюду";
    
    // protected — доступен в пакете и подклассах
    protected String protectedField = "в пакете и подклассы";
    
    // package-private (по умолчанию) — доступен только в пакете
    String packagePrivateField = "только в пакете";
    
    // private — доступен только в этом классе
    private String privateField = "только в классе";
}

public class AccessExample {
    public static void main(String[] args) {
        AccessModifiersExample obj = new AccessModifiersExample();
        
        obj.publicField = "OK"; // Работает
        obj.protectedField = "OK"; // Работает (одинаковый пакет)
        obj.packagePrivateField = "OK"; // Работает (одинаковый пакет)
        // obj.privateField = "ERROR"; // Ошибка компиляции!
    }
}

Таблица видимости:

2. static — Статические поля

Статические поля принадлежат классу, а не объекту:

public class Counter {
    // Обычное поле — своё для каждого объекта
    private int instanceCount = 0;
    
    // Статическое поле — общее для всех объектов класса
    private static int totalCount = 0;
    
    public Counter() {
        instanceCount++;
        totalCount++; // Увеличится для всех экземпляров
    }
    
    public static void main(String[] args) {
        Counter c1 = new Counter(); // totalCount = 1
        Counter c2 = new Counter(); // totalCount = 2
        Counter c3 = new Counter(); // totalCount = 3
        
        // Доступ через класс, не объект
        System.out.println(Counter.totalCount); // 3
        
        c1.instanceCount = 100; // Только для c1
        c2.instanceCount = 200; // Только для c2
        System.out.println(Counter.totalCount); // Все ещё 3!
    }
}

Использование static полей:

public class ConfigExample {
    // Константы
    public static final String APP_NAME = "MyApp";
    public static final int MAX_CONNECTIONS = 100;
    
    // Глобальное состояние
    private static int sequenceCounter = 0;
    
    public static int getNextId() {
        return ++sequenceCounter;
    }
    
    // Кеш на уровне класса
    private static final Map<String, Object> cache = new HashMap<>();
    
    public static Object getFromCache(String key) {
        return cache.get(key);
    }
}

3. final — Неизменяемость

final поле не может быть изменено после инициализации:

public class FinalFieldsExample {
    // Обязательно инициализировать при объявлении
    private final String id = "constant";
    
    // Или в конструкторе
    private final String name;
    private final List<String> items;
    
    public FinalFieldsExample(String name) {
        this.name = name; // Можно инициализировать один раз
        this.items = new ArrayList<>(); // Один раз
    }
    
    public void test() {
        // this.name = "new name"; // ОШИБКА! Final field
        // this.items = new ArrayList<>(); // ОШИБКА!
        
        // Но можем менять содержимое объекта
        this.items.add("item1"); // OK! Меняем содержимое, не ссылку
    }
}

Важное уточнение про final и объекты:

public class FinalObjectMutation {
    public static void main(String[] args) {
        final User user = new User("John");
        
        // user = new User("Jane"); // ОШИБКА! Менять ссылку нельзя
        
        user.setName("Jane"); // OK! Менять поля объекта можно
        user.setAge(30);      // OK!
    }
}

final с static для констант:

public class Constants {
    // Констант на уровне класса (final static)
    public static final String DATABASE_URL = "jdbc:mysql://localhost:3306/mydb";
    public static final int MAX_RETRY_COUNT = 3;
    public static final double PI = 3.14159;
    
    // Часто с Enum для типизации
    public static final Status DEFAULT_STATUS = Status.ACTIVE;
}

4. transient — Поля, не сохраняемые при сериализации

transient поля пропускаются при сохранении объекта:

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private String name;
    private int age;
    
    // Пароль не будет сохранён при сериализации (секурно!)
    private transient String password;
    
    // Временные данные тоже не сохраняются
    private transient List<String> tempCache = new ArrayList<>();
    
    public static void main(String[] args) throws IOException {
        User user = new User();
        user.name = "John";
        user.password = "secret123"; // Не сохранится
        
        // Сериализация
        FileOutputStream fos = new FileOutputStream("user.ser");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(user);
        oos.close();
        
        // При десериализации password будет null (по умолчанию)
    }
}

5. volatile — Синхронизация при многопоточности

volatile переменная всегда читается и пишется из памяти, не из кеша:

public class VolatileExample {
    // Обычное поле — могут быть проблемы видимости в многопоточности
    private boolean running = true;
    
    // volatile — гарантирует видимость изменений для всех потоков
    private volatile boolean shuttingDown = false;
    
    public void mainLoop() {
        while (!shuttingDown) { // Всегда читает свежее значение
            // Работаем
        }
    }
    
    public void shutdown() {
        shuttingDown = true; // Все потоки это видят
    }
}

public class VolatileCounter {
    /**
     * НЕПРАВИЛЬНО: volatile не гарантирует атомарность
     */
    private volatile int counter = 0;
    
    public void increment() {
        // counter++ это несколько операций: читай, прибавь, напиши
        // Race condition!
        counter++;
    }
    
    /**
     * ПРАВИЛЬНО: используем AtomicInteger
     */
    private final AtomicInteger atomicCounter = new AtomicInteger(0);
    
    public void incrementCorrect() {
        atomicCounter.incrementAndGet(); // Безопасно
    }
}

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

• Flag переменные (shutdown signals)
• Простые значения (boolean, int)
• Когда нужна видимость, но не атомарность

6. synchronized — Блокировка

synchronized блокирует доступ к полю для нескольких потоков:

public class SynchronizedExample {
    private int balance = 0;
    
    // Синхронизированный метод
    public synchronized void deposit(int amount) {
        balance += amount; // Только один поток одновременно
    }
    
    public synchronized int getBalance() {
        return balance;
    }
    
    // Синхронизированный блок (точнее)
    public void transfer(int amount) {
        synchronized(this) {
            balance -= amount;
        }
        // Остаток кода выполняется без блокировки
    }
}

7. strictfp — Строгие операции с float

strictfp гарантирует идентичные результаты float операций на разных платформах:

public strictfp class MathCalculations {
    /**
     * Без strictfp — разные CPU могут давать разные результаты float операций
     * С strictfp — гарантирован одинаковый результат везде
     * 
     * Использование редко, в scientific computing
     */
    
    public double calculatePrecise(double a, double b) {
        return a * b + Math.sqrt(a); // Точные результаты везде
    }
}

Комбинирование атрибутов

public class CombinedModifiers {
    /**
     * Можно комбинировать несколько атрибутов
     */
    
    // public static final — константа
    public static final String VERSION = "1.0.0";
    
    // private static final — приватная константа класса
    private static final Logger logger = LoggerFactory.getLogger(CombinedModifiers.class);
    
    // private final — приватное неизменяемое поле
    private final List<String> items = new ArrayList<>();
    
    // volatile transient — сложное сочетание (редко)
    private volatile transient String cache;
}

Лучшие практики

public class BestPractices {
    /**
     * 1. Используй private по умолчанию
     *    - Скрывай внутренние детали
     *    - Меньше связанности
     */
    private String internalState;
    
    /**
     * 2. Используй final для неизменяемых данных
     *    - Явно показывает намерение
     *    - Помогает анализировать код
     */
    private final String name;
    
    /**
     * 3. static final для констант
     *    - Общие значения для всех объектов
     *    - Экономия памяти
     */
    private static final int DEFAULT_CAPACITY = 10;
    
    /**
     * 4. Не переусложняй
     *    - volatile только где нужна видимость
     *    - static только для действительно глобального
     */
}

Итоговая таблица всех атрибутов

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