Сколько знаешь способов проверки условий?

Способы проверки условий в Java

Проверка условий — фундаментальная часть программирования. В Java есть множество способов:

1. If-Else (классический контроль потока)

public class ConditionalChecks {
    public void checkAge(int age) {
        if (age < 0) {
            System.out.println("Age cannot be negative");
        } else if (age < 18) {
            System.out.println("Minor");
        } else if (age < 65) {
            System.out.println("Adult");
        } else {
            System.out.println("Senior");
        }
    }
}

Используй когда: простая логика ветвления

2. Switch-Case (для дискретных значений)

public class SwitchExample {
    public String getDayName(int day) {
        return switch (day) {
            case 1 -> "Monday";
            case 2 -> "Tuesday";
            case 3 -> "Wednesday";
            default -> "Unknown";
        };
    }
    
    // Старый синтаксис
    public void checkRole(String role) {
        switch (role) {
            case "admin":
                System.out.println("Full access");
                break;
            case "user":
                System.out.println("Limited access");
                break;
            default:
                System.out.println("Unknown role");
        }
    }
}

Используй когда: проверяешь одну переменную против множества значений

3. Ternary оператор (условное выражение)

public class TernaryExample {
    public static void main(String[] args) {
        int age = 20;
        String status = age >= 18 ? "Adult" : "Minor";
        System.out.println(status);
        
        // Вложенный ternary (избегай!)
        String message = age < 13 ? "Child" :
                        age < 18 ? "Teen" :
                        age < 65 ? "Adult" :
                        "Senior";
    }
}

Используй когда: простая двусторонняя проверка

4. Assertions (для отладки)

public class AssertionExample {
    public void divide(double a, double b) {
        assert b != 0 : "Divisor cannot be zero";
        double result = a / b;
        
        assert result > 0 : "Result should be positive";
        System.out.println("Result: " + result);
    }
}

Запуск с ассертами:

java -ea MyApp  # -ea включает ассерты

Используй когда: отладка внутренних инвариантов

5. try-catch (исключения)

public class ExceptionChecking {
    public void parseNumber(String input) {
        try {
            int number = Integer.parseInt(input);
            System.out.println("Parsed: " + number);
        } catch (NumberFormatException e) {
            System.err.println("Invalid number format: " + e.getMessage());
        } catch (Exception e) {
            System.err.println("Unexpected error: " + e);
        }
    }
}

Используй когда: проверяешь исключительные ситуации

6. Optional (проверка null-safety)

import java.util.Optional;

public class OptionalExample {
    public void processUser(User user) {
        // Способ 1: if present
        Optional.ofNullable(user)
            .ifPresent(u -> System.out.println("User: " + u.getName()));
        
        // Способ 2: if present or else
        String name = Optional.ofNullable(user)
            .map(User::getName)
            .orElse("Unknown");
        System.out.println("Name: " + name);
        
        // Способ 3: filter
        Optional.ofNullable(user)
            .filter(u -> u.getAge() >= 18)
            .ifPresent(u -> System.out.println("Adult user"));
    }
}

Используй когда: работаешь с nullable значениями

7. Pattern Matching (Java 16+)

public class PatternMatching {
    public void checkObject(Object obj) {
        // Instanceof pattern
        if (obj instanceof String str) {
            System.out.println("String length: " + str.length());
        } else if (obj instanceof Integer num) {
            System.out.println("Number: " + num);
        }
    }
    
    // Switch with patterns (Java 17+)
    public String describe(Object obj) {
        return switch (obj) {
            case String s -> "String: " + s;
            case Integer i -> "Integer: " + i;
            case null -> "Null value";
            default -> "Unknown type";
        };
    }
}

Используй когда: работаешь с полиморфными типами

8. Guard Clauses (ранние выходы)

public class GuardClausesExample {
    public void processOrder(Order order) {
        // Вместо вложенных if
        if (order == null) {
            throw new IllegalArgumentException("Order cannot be null");
        }
        if (order.getItems().isEmpty()) {
            throw new IllegalArgumentException("Order must have items");
        }
        if (order.getTotal() <= 0) {
            throw new IllegalArgumentException("Order total must be positive");
        }
        
        // Основная логика
        saveOrder(order);
    }
}

Используй когда: нужна валидация на входе

9. Objects utility методы

import java.util.Objects;

public class ObjectsChecking {
    public void validateUser(User user) {
        // isNull / nonNull
        if (Objects.isNull(user)) {
            throw new NullPointerException("User is null");
        }
        
        // requireNonNull
        Objects.requireNonNull(user, "User must not be null");
        
        // equals с null-safety
        if (Objects.equals(user.getRole(), "admin")) {
            grantFullAccess(user);
        }
        
        // deepEquals для массивов
        if (Objects.deepEquals(user.getPermissions(), expectedPermissions)) {
            System.out.println("Permissions match");
        }
    }
}

Используй когда: нужны null-безопасные операции

10. Assertions в тестах (JUnit)

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class CalculatorTest {
    @Test
    void testAddition() {
        Calculator calc = new Calculator();
        
        // Различные assertions
        assertEquals(4, calc.add(2, 2));
        assertNotEquals(5, calc.add(2, 2));
        assertTrue(calc.add(1, 1) > 0);
        assertFalse(calc.add(-1, -1) > 0);
        assertNull(calc.divide(1, 0));
        assertNotNull(calc.add(1, 1));
        
        // Бросит исключение
        assertThrows(ArithmeticException.class, () -> calc.divide(1, 0));
        
        // Проверка коллекций
        assertIterableEquals(List.of(1, 2, 3), calc.getResults());
    }
}

Используй когда: пишешь юнит-тесты

11. Условное логирование

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ConditionalLogging {
    private static final Logger logger = LoggerFactory.getLogger(ConditionalLogging.class);
    
    public void processData(Data data) {
        if (logger.isDebugEnabled()) {
            logger.debug("Processing data: {}", data);
        }
        
        if (logger.isErrorEnabled()) {
            logger.error("Error occurred");
        }
    }
}

Используй когда: нужна условная отладка

12. Проверки через предусловия (Preconditions от Guava)

import com.google.common.base.Preconditions;

public class PreconditionsExample {
    public void setAge(int age) {
        Preconditions.checkArgument(age >= 0, "Age must be non-negative");
        Preconditions.checkArgument(age < 150, "Age seems unrealistic");
        this.age = age;
    }
    
    public void processUser(User user) {
        Preconditions.checkNotNull(user, "User cannot be null");
    }
}

Используй когда: нужна выразительная валидация параметров

Сравнение методов

┌─────────────────────┬──────────┬──────────────┬─────────────┐
│ Способ              │ Читаемо  │ Производит   │ Когда       │
├─────────────────────┼──────────┼──────────────┼─────────────┤
│ if-else             │ Да       │ Простой      │ Основное    │
│ switch              │ Да       │ Быстрый      │ Множество   │
│ ternary             │ Да       │ Компактный   │ Простое     │
│ Optional            │ Да       │ Функциональ  │ null-safety │
│ Pattern matching    │ Да       │ Современный  │ Типы        │
│ assertions          │ Да       │ Отладка      │ Тесты       │
│ try-catch           │ Да       │ Исключения   │ Ошибки      │
│ Guard clauses       │ Да       │ Ранний выход │ Валидация   │
└─────────────────────┴──────────┴──────────────┴─────────────┘

Best Practices

// ПЛОХО: глубокие вложения
if (user != null) {
    if (user.isActive()) {
        if (user.getAge() >= 18) {
            // логика
        }
    }
}

// ХОРОШО: guard clauses
if (user == null || !user.isActive() || user.getAge() < 18) {
    return;
}
// основная логика

// ПЛОХО: null checking везде
if (obj != null && obj.getValue() != null) {
    // ...
}

// ХОРОШО: Optional
Optional.ofNullable(obj)
    .map(Object::getValue)
    .ifPresent(this::process);

Ключевые выводы

• if-else — основной инструмент для простых проверок
• switch — для множества дискретных значений
• Optional — для null-safety и функциональных цепочек
• Pattern matching — современный способ работы с типами
• Guard clauses — уменьшают вложенность
• Assertions — для отладки и тестирования
• try-catch — для исключительных ситуаций
• Выбирай инструмент в зависимости от контекста — это показывает опыт