Какие знаешь требования к полям класса?

Требования к полям класса в Java

Поля класса (Class Fields/Member Variables) — это переменные, которые определяют состояние объекта. Правильное проектирование полей критично для надежности, безопасности и масштабируемости приложения.

1. Инкапсуляция (Encapsulation)

Требование: Поля должны быть private по умолчанию.

// Плохо: public поля
public class User {
    public String name; // Любой может изменить
    public int age;     // Невозможно валидировать
}

// Хорошо: private поля с методами доступа
public class User {
    private String name;
    private int age;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        if (name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException("Name cannot be empty");
        }
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("Invalid age");
        }
        this.age = age;
    }
}

Преимущества инкапсуляции:

• Валидация данных
• Защита инвариантов класса
• Возможность менять реализацию без изменения API
• Lazy loading или computed properties

2. Инициализация и не-null гарантии

Требование: Поля должны быть инициализированы в конструкторе или иметь дефолтное значение.

// Плохо: null-pointer исключения
public class Order {
    private String orderId;  // null по умолчанию
    private List<Item> items; // null по умолчанию
    
    public void addItem(Item item) {
        items.add(item); // NullPointerException!
    }
}

// Хорошо: инициализация в конструкторе
public class Order {
    private final String orderId;
    private final List<Item> items;
    
    public Order(String orderId) {
        if (orderId == null || orderId.isEmpty()) {
            throw new IllegalArgumentException("OrderId required");
        }
        this.orderId = orderId;
        this.items = new ArrayList<>();
    }
    
    public void addItem(Item item) {
        items.add(item); // Безопасно
    }
}

Использование Optional для nullable полей:

public class User {
    private final String name;           // Обязательное
    private final Optional<String> email; // Опциональное
    
    public User(String name, Optional<String> email) {
        this.name = Objects.requireNonNull(name);
        this.email = Objects.requireNonNull(email);
    }
    
    public void sendEmail(String message) {
        email.ifPresent(e -> mailer.send(e, message));
    }
}

3. Immutability (Неизменяемость)

Требование: Поля, которые не должны изменяться, должны быть final.

// Плохо: можно случайно изменить
public class Address {
    private String street;
    private String city;
    private String zipCode;
}

// Хорошо: неизменяемый класс
public final class Address {
    private final String street;
    private final String city;
    private final String zipCode;
    
    public Address(String street, String city, String zipCode) {
        this.street = Objects.requireNonNull(street);
        this.city = Objects.requireNonNull(city);
        this.zipCode = Objects.requireNonNull(zipCode);
    }
    
    public String getStreet() { return street; }
    public String getCity() { return city; }
    public String getZipCode() { return zipCode; }
    
    // Нет setters!
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Address)) return false;
        Address address = (Address) o;
        return street.equals(address.street) &&
               city.equals(address.city) &&
               zipCode.equals(address.zipCode);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(street, city, zipCode);
    }
}

Преимущества immutable полей:

• Потокобезопасность без синхронизации
• Безопасно использовать как ключи в HashMap
• Легче тестировать
• Понятнее намерение

4. Типизация (Type Safety)

Требование: Использовать правильные типы для полей.

// Плохо: используются примитивные типы небезопасно
public class User {
    private int userId;     // -1 означает "нет"?
    private int age;        // может быть -5?
    private String status;  // "A", "I", "D"? Magic strings
}

// Хорошо: семантически правильные типы
public class User {
    private final UserId userId;           // Strongly typed
    private final Age age;                 // Value object
    private final UserStatus status;       // Enum
}

// Value objects для type safety
public class UserId {
    private final Long value;
    
    public UserId(Long value) {
        if (value == null || value <= 0) {
            throw new IllegalArgumentException("Invalid user ID");
        }
        this.value = value;
    }
    
    public Long getValue() { return value; }
}

public class Age {
    private final int value;
    
    public Age(int value) {
        if (value < 0 || value > 150) {
            throw new IllegalArgumentException("Invalid age");
        }
        this.value = value;
    }
    
    public int getValue() { return value; }
}

public enum UserStatus {
    ACTIVE, INACTIVE, DELETED
}

5. Коллекции должны быть immutable или protected

Требование: Не возвращай mutable коллекции напрямую.

// Плохо: коллекция может быть изменена извне
public class Order {
    private List<Item> items;
    
    public List<Item> getItems() {
        return items; // Кто-то может сделать items.clear()
    }
}

// Хорошо: возвращай immutable copy
public class Order {
    private final List<Item> items;
    
    public List<Item> getItems() {
        return Collections.unmodifiableList(items);
        // или в Java 10+:
        return List.copyOf(items);
    }
    
    public void addItem(Item item) {
        items.add(item);
    }
}

6. Валидация на уровне полей

Требование: Валидировать данные при присвоении.

public class Product {
    private final String name;
    private final BigDecimal price;
    private final int stockQuantity;
    
    public Product(String name, BigDecimal price, int stockQuantity) {
        this.name = validateName(name);
        this.price = validatePrice(price);
        this.stockQuantity = validateQuantity(stockQuantity);
    }
    
    private String validateName(String name) {
        if (name == null || name.trim().isEmpty()) {
            throw new IllegalArgumentException("Product name cannot be empty");
        }
        if (name.length() > 255) {
            throw new IllegalArgumentException("Product name too long");
        }
        return name.trim();
    }
    
    private BigDecimal validatePrice(BigDecimal price) {
        if (price == null || price.compareTo(BigDecimal.ZERO) <= 0) {
            throw new IllegalArgumentException("Price must be positive");
        }
        return price;
    }
    
    private int validateQuantity(int quantity) {
        if (quantity < 0) {
            throw new IllegalArgumentException("Quantity cannot be negative");
        }
        return quantity;
    }
}

7. Поля и транзакции (для Hibernate/JPA)

Требование: Учитывай lifecycle управляемых сущностей.

// Плохо: lazy loading может случиться вне транзакции
@Entity
public class User {
    @OneToMany
    private List<Order> orders; // Может быть null
    
    public void processOrders() {
        for (Order order : orders) { // LazyInitializationException!
            process(order);
        }
    }
}

// Хорошо: инициализируй при загрузке
@Entity
public class User {
    @OneToMany(fetch = FetchType.EAGER) // или fetch join
    private final List<Order> orders;
    
    public User() {
        this.orders = new ArrayList<>();
    }
    
    public List<Order> getOrders() {
        return Collections.unmodifiableList(orders);
    }
}

8. Сериализация и версионирование

Требование: Если класс сериализуемый, определи serialVersionUID.

public class User implements Serializable {
    private static final long serialVersionUID = 1L; // ОБЯЗАТЕЛЬНО
    
    private String name;
    private int age;
    
    // При изменении поля увеличивай версию
    // private String email; // serialVersionUID должен измениться
}

9. Поля и Equals/HashCode

Требование: Все поля, влияющие на identity, должны быть в equals/hashCode.

public class User {
    private final String username;
    private final String email;
    private String lastLogin; // transient state
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        // Включай только неизменяемые поля
        return username.equals(user.username) &&
               email.equals(user.email);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(username, email);
    }
}

10. Documentation и аннотации

Требование: Документируй семантику полей.

public class PaymentMethod {
    /**
     * Уникальный идентификатор платежного метода.
     * Используется для идемпотентности платежей.
     */
    private final String paymentId;
    
    /**
     * Сумма в копейках. Никогда не null.
     * Умножь на 100 если работаешь с рублями.
     */
    @NotNull
    @Positive
    private final Long amountCents;
    
    /**
     * Статус платежа. Может быть null до завершения обработки.
     */
    @Nullable
    private PaymentStatus status;
}

Чеклист требований к полям

✓ Все поля private (или package-private если очень причина)
✓ Поля инициализированы или @Nullable задокументированы
✓ Critical fields final (не должны изменяться)
✓ Коллекции возвращаются как unmodifiable
✓ Валидация при присвоении через конструктор или setter
✓ Type-safe: enum вместо String, value objects вместо примитивов
✓ Equals/HashCode согласованны с полями
✓ Документированы с JavaDoc
✓ Для Serializable классов: serialVersionUID
✓ Для Hibernate: учитывай lazy loading

Современный подход: Records (Java 16+)

// Вместо 50 строк кода — одна строка!
public record User(
    @NotNull String name,
    @NotNull @Email String email,
    int age
) {
    // Автоматически:
    // - private final поля
    // - getters (getName(), getEmail(), getAge())
    // - equals() и hashCode()
    // - toString()
    // - конструктор
    
    // Можно добавить компактный конструктор для валидации
    public User {
        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("Name required");
        }
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("Invalid age");
        }
    }
}

Заключение

Требования к полям класса:

1. Инкапсуляция — private с методами доступа
2. Инициализация — не-null гарантии
3. Immutability — final где возможно
4. Type-safety — правильные типы
5. Валидация — проверка при присвоении
6. Collections — immutable возвращаемые значения
7. Documentation — JavaDoc и аннотации

Эти требования обеспечивают надежность, безопасность и масштабируемость.