Как описать каким поведением будет обладать объект

Описание поведения объекта в Java

Это вопрос о спецификации, контрактах и механизмах описания того, как объект должен себя вести. В Java это реализуется через интерфейсы, договоры (contracts), документацию и типизацию.

1. Интерфейсы (Contracts)

Интерфейс определяет контракт — то, как объект должен себя вести:

// Интерфейс = контракт поведения
public interface PaymentProcessor {
    // Этот метод ожидает:
    // 1. Принять платеж
    // 2. Вернуть результат
    // 3. Выбросить исключение если ошибка
    PaymentResult processPayment(Payment payment) throws PaymentException;
    
    // Проверить, может ли процессор обработать платеж
    boolean canProcess(Payment payment);
    
    // Получить статус платежа
    PaymentStatus getStatus(String transactionId);
}

// Конкретная реализация определяет СПЕЦИФИЧНОЕ поведение
public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public PaymentResult processPayment(Payment payment) {
        // Специфичное поведение для кредитных карт
        validateCardNumber(payment.getCardNumber());
        validateCVV(payment.getCVV());
        validateExpiryDate(payment.getExpiryDate());
        
        // Вызвать платежный шлюз
        PaymentGatewayResponse response = gateway.charge(
            payment.getAmount(),
            payment.getCardNumber()
        );
        
        return mapToPaymentResult(response);
    }
    
    @Override
    public boolean canProcess(Payment payment) {
        return payment.getType() == PaymentType.CREDIT_CARD;
    }
}

public class PayPalProcessor implements PaymentProcessor {
    @Override
    public PaymentResult processPayment(Payment payment) {
        // Специфичное поведение для PayPal
        // Полностью другая реализация
        redirectToPayPalLogin();
        // ...
    }
    
    @Override
    public boolean canProcess(Payment payment) {
        return payment.getType() == PaymentType.PAYPAL;
    }
}

2. JavaDoc и документирование контракта

Описание поведения через документацию:

public interface UserRepository {
    /**
     * Находит пользователя по ID.
     *
     * @param id ID пользователя (не может быть null)
     * @return User объект если найден
     * @throws IllegalArgumentException если id == null
     * @throws UserNotFoundException если пользователь не существует
     * 
     * Поведение:
     * - Ищет в БД по exact ID match
     * - Возвращает первый найденный результат
     * - Thread-safe для одновременных операций
     * - Не кэширует результаты
     */
    User findById(String id) throws UserNotFoundException;
    
    /**
     * Сохраняет или обновляет пользователя.
     *
     * @param user пользователь для сохранения (не может быть null)
     * @return сохраненный пользователь с ID
     * @throws IllegalArgumentException если user == null или невалиден
     * @throws DataAccessException если ошибка БД
     * 
     * Гарантии:
     * - Операция атомарная (all-or-nothing)
     * - Если ID существует -> UPDATE, иначе -> INSERT
     * - Все constraints проверяются перед сохранением
     * - Вернутся ID автогенерируется если не указан
     */
    User save(User user);
}

3. Поведение через типизацию и generic типы

// Типизация описывает поведение на уровне типов
public interface Container<T> {
    // Поведение ясно из типов:
    // - add() принимает T и не возвращает ничего
    // - get() возвращает T
    // - Контейнер работает с объектами типа T
    void add(T item);
    T get(int index);
    List<T> getAll();
    int size();
}

public class IntegerContainer implements Container<Integer> {
    private List<Integer> items = new ArrayList<>();
    
    @Override
    public void add(Integer item) {
        // Поведение: добавить целое число в контейнер
        if (item == null) throw new IllegalArgumentException();
        items.add(item);
    }
    
    @Override
    public Integer get(int index) {
        // Поведение: получить целое число по индексу
        return items.get(index);
    }
}

4. Builder Pattern для описания конструирования

// Builder описывает пошаговое конструирование объекта
public class HttpRequest {
    private String url;
    private String method;
    private Map<String, String> headers;
    private String body;
    private int timeout;
    
    private HttpRequest(Builder builder) {
        this.url = builder.url;
        this.method = builder.method;
        this.headers = builder.headers;
        this.body = builder.body;
        this.timeout = builder.timeout;
    }
    
    public static class Builder {
        private final String url;  // обязателен
        private String method = "GET";
        private Map<String, String> headers = new HashMap<>();
        private String body = "";
        private int timeout = 5000;
        
        public Builder(String url) {
            this.url = url;
        }
        
        public Builder method(String method) {
            this.method = method;
            return this;
        }
        
        public Builder header(String key, String value) {
            this.headers.put(key, value);
            return this;
        }
        
        public Builder body(String body) {
            this.body = body;
            return this;
        }
        
        public Builder timeout(int ms) {
            this.timeout = ms;
            return this;
        }
        
        public HttpRequest build() {
            if (method.equals("POST") && body.isEmpty()) {
                throw new IllegalStateException(
                    "POST требует body"
                );
            }
            return new HttpRequest(this);
        }
    }
}

// Использование описывает поведение
HttpRequest request = new HttpRequest.Builder("https://api.example.com/users")
    .method("POST")
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer token")
    .body("{\"name\":\"John\"}")
    .timeout(10000)
    .build();

5. Strategy Pattern для описания алгоритмов

// Стратегия = описание поведения алгоритма
public interface SortingStrategy {
    /**
     * Сортирует список элементов.
     * 
     * Поведение:
     * - Изменяет список в place (in-place)
     * - Сравнивает элементы через Comparable.compareTo()
     * - Временная сложность: O(n log n) для большинства случаев
     * - Потокобезопасность: нет (не thread-safe)
     */
    <T extends Comparable<T>> void sort(List<T> list);
}

public class QuickSortStrategy implements SortingStrategy {
    @Override
    public <T extends Comparable<T>> void sort(List<T> list) {
        if (list.size() <= 1) return;
        quickSort(list, 0, list.size() - 1);
    }
    
    private <T extends Comparable<T>> void quickSort(
        List<T> list, int low, int high) {
        if (low < high) {
            int pi = partition(list, low, high);
            quickSort(list, low, pi - 1);
            quickSort(list, pi + 1, high);
        }
    }
}

public class MergeSortStrategy implements SortingStrategy {
    @Override
    public <T extends Comparable<T>> void sort(List<T> list) {
        // Совсем другое поведение сортировки
        mergeSort(list, 0, list.size() - 1);
    }
}

6. Аннотации для описания поведения

// Аннотации описывают non-functional требования
@Deprecated(since = "2.0", forRemoval = true)
public void oldMethod() {
    // Это поведение не рекомендуется, будет удалено
}

@Override
public String toString() {
    // Это переопределение стандартного поведения Object
    return "Custom string representation";
}

@Transactional(isolation = Isolation.SERIALIZABLE)
public void criticalOperation() {
    // Поведение: выполнить в транзакции с максимальной изоляцией
}

@Async
public void asyncTask() {
    // Поведение: выполнить асинхронно в отдельном потоке
}

@Retry(maxAttempts = 3, delay = 1000)
public void unreliableOperation() {
    // Поведение: повторить до 3 раз с задержкой 1 сек
}

7. State Pattern для описания изменения поведения

// Объект меняет поведение в зависимости от состояния
public interface OrderState {
    void cancel(Order order);
    void ship(Order order);
    void deliver(Order order);
}

public class PendingOrderState implements OrderState {
    @Override
    public void cancel(Order order) {
        // Поведение в состоянии PENDING: можно отменить
        order.setState(new CancelledOrderState());
        order.refund();
    }
    
    @Override
    public void ship(Order order) {
        // Поведение: перейти к состоянию SHIPPED
        order.setState(new ShippedOrderState());
    }
    
    @Override
    public void deliver(Order order) {
        // Поведение: невозможно доставить из PENDING
        throw new IllegalStateException(
            "Нельзя доставить заказ в состоянии PENDING"
        );
    }
}

public class ShippedOrderState implements OrderState {
    @Override
    public void cancel(Order order) {
        // Поведение в состоянии SHIPPED: отмена невозможна
        throw new IllegalStateException(
            "Нельзя отменить уже доставленный заказ"
        );
    }
    
    @Override
    public void ship(Order order) {
        // Нельзя отправить дважды
        throw new IllegalStateException("Заказ уже отправлен");
    }
    
    @Override
    public void deliver(Order order) {
        // Поведение: доставить
        order.setState(new DeliveredOrderState());
        order.markAsDelivered();
    }
}

8. Контрактное программирование (Design by Contract)

public class BankAccount {
    private double balance;
    
    /**
     * Снять деньги со счета.
     *
     * PRECONDITION (перед вызовом):
     * - amount > 0
     * - balance >= amount (достаточно средств)
     *
     * POSTCONDITION (после успешного вызова):
     * - balance уменьшится на amount
     * - вернется true
     *
     * INVARIANT (всегда верно):
     * - balance >= 0 (баланс не может быть отрицательным)
     *
     * @param amount сумма для снятия
     * @return true если успешно, false если недостаточно средств
     */
    public boolean withdraw(double amount) {
        // PRECONDITION проверка
        if (amount <= 0) {
            throw new IllegalArgumentException(
                "Amount must be positive"
            );
        }
        
        if (balance < amount) {
            return false;  // Не выполнен precondition
        }
        
        // ОПЕРАЦИЯ
        balance -= amount;
        
        // POSTCONDITION проверка
        assert balance >= 0 : "Invariant violation";
        
        return true;
    }
    
    /**
     * INVARIANT: баланс никогда не может быть отрицательным.
     * Это свойство должно быть верно в любой момент.
     */
    public double getBalance() {
        assert balance >= 0 : "Balance invariant violated";
        return balance;
    }
}

Итоговый чек-лист описания поведения

1. Интерфейсы — определи контракт (какие методы, какие типы)
2. JavaDoc — объясни, что метод делает, какие исключения выбросит
3. Типизация — используй типы для самодокументирования
4. Паттерны — Builder, Strategy, State для описания сложного поведения
5. Аннотации — обозначь non-functional свойства
6. Контракт — определи preconditions, postconditions, invariants
7. Тесты — примеры поведения через unit тесты
8. Код — понятные имена и простая логика

Заключение

Описание поведения объекта — это не только код, но и:

• Контракт (интерфейсы)
• Документация (JavaDoc)
• Типизация (типы и generics)
• Проектирование (паттерны)
• Спецификация (preconditions, postconditions)

В моей практике это приводит к более предсказуемому и поддерживаемому коду.