Что такое AssertionsЧто такое Assertions?

Assertions в Java: назначение и практическое применение

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

Основной синтаксис

В Java assertions включаются с помощью ключевого слова assert:

// Простая форма
assert condition;  // если condition == false, выбрасывает AssertionError

// С сообщением об ошибке
assert condition : "Описание ошибки";

// Примеры
assert age >= 0 : "Возраст не может быть отрицательным";
assert list != null : "Список не должен быть null";
assert balance > 0 : "Баланс должен быть положительным";

Как включить Assertions

По умолчанию assertions отключены в Java. Их нужно явно включить при запуске:

# Включить для всего приложения
java -ea MyApplication

# Или с полным флагом
java -enableassertions MyApplication

# Включить только для конкретного пакета
java -ea:com.myapp... MyApplication

# Отключить для конкретного пакета
java -ea -da:com.thirdparty... MyApplication

# В IDE (например, IntelliJ IDEA)
# Run -> Edit Configurations -> VM options: -ea

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

1. Проверка инвариантов класса

public class BankAccount {
    private double balance;
    
    public void withdraw(double amount) {
        double newBalance = balance - amount;
        
        // Инвариант: баланс никогда не должен быть отрицательным
        assert newBalance >= 0 : "Баланс не может быть отрицательным";
        
        balance = newBalance;
    }
    
    public double getBalance() {
        // Все данные должны быть непротиворечивы
        assert balance >= 0 : "Внутренняя ошибка: баланс отрицательный";
        return balance;
    }
}

2. Проверка предусловий (Preconditions)

public class Calculator {
    public double divide(double a, double b) {
        // Предусловие: делитель не должен быть нулём
        assert b != 0 : "Делитель не может быть нулём";
        
        return a / b;
    }
    
    public void setAge(int age) {
        // Предусловие: возраст должен быть в разумном диапазоне
        assert age >= 0 && age <= 150 : 
            "Возраст должен быть между 0 и 150";
        
        this.age = age;
    }
}

3. Проверка постусловий (Postconditions)

public class UserService {
    public User findUserById(String id) {
        User user = userRepository.findById(id);
        
        // Постусловие: результат всегда должен быть непустым для существующего ID
        assert user != null : "User с ID " + id + " должен существовать";
        assert !user.getName().isEmpty() : "Имя пользователя не может быть пустым";
        
        return user;
    }
}

4. Проверка инвариантов цикла

public class ArrayProcessor {
    public void processArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            // Инвариант цикла: i всегда находится в допустимом диапазоне
            assert i >= 0 && i < array.length : 
                "Индекс вышел за границы массива";
            
            // Обработка элемента
            array[i] = array[i] * 2;
            
            // Постусловие цикла
            assert array[i] % 2 == 0 : 
                "После умножения на 2, число должно быть чётным";
        }
    }
}

Практический пример: валидация данных

public class Order {
    private String id;
    private List<Item> items;
    private OrderStatus status;
    private double totalPrice;
    
    public Order(String id, List<Item> items) {
        // Предусловия
        assert id != null && !id.isEmpty() : "ID заказа не может быть пустым";
        assert items != null && !items.isEmpty() : "Заказ должен содержать хотя бы один товар";
        
        this.id = id;
        this.items = new ArrayList<>(items);
        this.status = OrderStatus.CREATED;
        this.totalPrice = calculateTotal();
        
        // Постусловие
        assert totalPrice > 0 : "Общая стоимость должна быть положительной";
    }
    
    public void applyDiscount(double discountPercent) {
        assert discountPercent >= 0 && discountPercent <= 100 : 
            "Скидка должна быть между 0 и 100 процентами";
        
        double oldPrice = totalPrice;
        totalPrice *= (1 - discountPercent / 100);
        
        // Постусловие: цена не должна увеличиться
        assert totalPrice <= oldPrice : 
            "Скидка не должна увеличивать цену";
    }
    
    private double calculateTotal() {
        return items.stream()
            .mapToDouble(Item::getPrice)
            .sum();
    }
    
    public void completeOrder() {
        // Инвариант: можно завершить только новый заказ
        assert status == OrderStatus.CREATED : 
            "Можно завершить только заказ со статусом CREATED";
        
        status = OrderStatus.COMPLETED;
        
        // Постусловие
        assert status == OrderStatus.COMPLETED : 
            "Статус должен быть COMPLETED";
    }
}

Assertions vs Исключения

Это ОЧЕНЬ важное различие:

// НЕПРАВИЛЬНО: использовать assertions для валидации входных данных
public void processUserInput(String input) {
    assert input != null : "Ввод не должен быть null";  // ошибка!
    // Почему? Assertions отключены в продакшене!
    // Пользователь отправит null, и программа упадёт с NPE
}

// ПРАВИЛЬНО: использовать исключения для пользовательских ошибок
public void processUserInput(String input) {
    if (input == null) {
        throw new IllegalArgumentException("Ввод не должен быть null");
    }
    // Это работает везде, даже без -ea флага
}

// ПРАВИЛЬНО: использовать assertions для внутренних проверок
private void internalProcessing(String processedInput) {
    // На этом этапе мы уже знаем, что input валиден,
    // поэтому используем assertion для проверки логики
    assert processedInput != null : "После валидации input должен быть не-null";
}

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

1. Не используйте Assertions для публичного API

// ПЛОХО
public void setName(String name) {
    assert name != null;  // а если -ea отключены?
    this.name = name;
}

// ХОРОШО
public void setName(String name) {
    if (name == null) {
        throw new IllegalArgumentException("Имя не может быть null");
    }
    this.name = name;
}

2. Не используйте side effects в assertions

// ПЛОХО: побочный эффект
assert list.remove(item) : "Элемент должен быть в списке";  // опасно!

// ХОРОШО: отделяем проверку от действия
boolean wasRemoved = list.remove(item);
assert wasRemoved : "Элемент должен быть в списке";

3. Используйте для сложной логики

// ХОРОШО: проверяем сложный инвариант
private void validateTreeStructure() {
    // После каждой операции проверяем инвариант
    assert isValidBST() : "Дерево нарушило свойство BST";
    assert hasNoDuplicates() : "Дерево содержит дубликаты";
    assert isBalanced() : "Дерево разбалансировано";
}

Заключение

Assertions — это дешёвый и эффективный способ поймать логические ошибки во время разработки. Они помогают:

• Документировать предположения о коде
• Выявить проблемы на ранних этапах
• Упростить отладку
• Улучшить качество кода

Но помните: никогда не полагайтесь на assertions для критичной валидации данных — используйте исключения для того, что может произойти в продакшене.