// Антипаттерн: прямая передача SQLException через все слои
public User findUser(String id) throws SQLException {  // Нарушение абстракции
    return database.query("SELECT * FROM users WHERE id = ?", id);
}

// Паттерн Exception Translation: оборачивание в доменное исключение
public User findUser(String id) {
    try {
        return database.query("SELECT * FROM users WHERE id = ?", id);
    } catch (SQLException e) {
        throw new DataAccessException("Failed to load user: " + id, e);
    }
}

public void processOrder(Order order) throws OrderValidationException {
    try {
        validate(order);
    } catch (OrderValidationException e) {
        auditLog.recordValidationFailure(order.getId(), e);
        throw e;  // Тот же тип, тот же стектрейс
    }
}

public Configuration loadConfiguration() {
    try {
        return parser.parse(configFile);
    } catch (IOException e) {
        throw new ConfigurationLoadException("Cannot read config from " + configFile, e);
    }
}

// Интерфейс объявляет checked-исключение
interface DataStore {
    String read(String key) throws IOException;
}

// Реализация на основе памяти не может выбросить IOException,
// но вынуждена объявлять его или оборачивать в RuntimeException
class InMemoryStore implements DataStore {
    @Override
    public String read(String key) throws IOException {  // Нелогично
        return memoryMap.get(key);
    }
}

// Метод с checked-исключением не может быть использован как лямбда
public String fetchUrl(String url) throws IOException {
    return httpClient.get(url);
}

// Ошибка компиляции: IOException не обработано
List<String> results = urls.stream()
    .map(this::fetchUrl)  // Не компилируется
    .collect(Collectors.toList());

// Сервис не объявляет throws, использует unchecked
@Service
public class OrderService {
    public Order processOrder(OrderRequest request) {
        validate(request);  // Может выбросить ValidationException (unchecked)
        
        try {
            return orderRepository.save(request.toEntity());
        } catch (DataAccessException e) {  // Unchecked от Spring
            throw new OrderProcessingException("Failed to save order", e);
        }
    }
    
    private void validate(OrderRequest request) {
        if (request.getAmount() <= 0) {
            throw new ValidationException("Amount must be positive");
        }
    }
}

// Глобальная обработка без распространения throws через слои
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(ValidationException.class)
    public ResponseEntity<ErrorResponse> handleValidation(ValidationException e) {
        return ResponseEntity.badRequest()
            .body(new ErrorResponse(e.getMessage()));
    }
    
    @ExceptionHandler(OrderProcessingException.class)
    public ResponseEntity<ErrorResponse> handleProcessing(OrderProcessingException e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(new ErrorResponse("Order processing failed"));
    }
}

/**
 * Загружает конфигурацию приложения из файла.
 *
 * @param path путь к файлу конфигурации
 * @return загруженная конфигурация
 * @throws ConfigLoadException если файл не существует, недоступен для чтения,
 *         или содержимое не соответствует ожидаемому формату
 */
public Configuration loadConfiguration(Path path) {
    // Реализация
}

public class Task200426 {
    public static void main(String[] args) {
        try {
            method();
        } catch (Exception e) {
            System.out.println("Caught: " + e.getMessage());
        }
    }

    static void method() throws Exception {
        try {
            throw new RuntimeException("Inner");
        } catch (RuntimeException e) {
            System.out.println("Inside catch");
            throw new Exception("Outer");
        }
    }
}

public class StaticOverrideExample {
    
    static class Parent {
        public static void print() {
            System.out.println("Parent static method");
        }
        
        public void instanceMethod() {
            System.out.println("Parent instance method");
        }
    }
    
    static class Child extends Parent {
        // Это не переопределение, а сокрытие (hiding)
        public static void print() {
            System.out.println("Child static method");
        }
        
        @Override // А это корректное переопределение
        public void instanceMethod() {
            System.out.println("Child instance method");
        }
    }
    
    public static void main(String[] args) {
        Parent p = new Child();
        
        //Антипаттерн: вызов статического метода через переменную
        p.print(); // Вывод: "Parent static method" — неожиданно!
        // Компилятор смотрит на тип переменной Parent, а не на объект Child
        
        //Правильно: вызов через класс
        Parent.print();    // Parent static method
        Child.print();     // Child static method
        
        // Для сравнения: экземплярный метод ведет себя полиморфно
        p.instanceMethod(); // Вывод: "Child instance method" — ожидаемо
        
        // Демонстрация опасности
        Parent nullRef = null;
        nullRef.print(); // Работает! (тип известен на этапе компиляции)
        // nullRef.instanceMethod(); // NullPointerException
    }
}

class Parent210426 {
    static String get() { return "Parent"; }
    String nonStatic() { return "ParentNS"; }
}

class Child210426 extends Parent210426 {
    static String get() { return "Child"; }
    String nonStatic() { return "ChildNS"; }
}

public class Task210426 {
    public static void main(String[] args) {
        Parent210426 p = new Child210426();
        System.out.println(p.get());
        System.out.println(((Child210426) p).get());
        System.out.println(p.nonStatic());
    }
}

/**
 * Исключение, сигнализирующее о необходимости ручного подтверждения
 * платежа из-за превышения лимита. Вызывающий код должен инициировать
 * процедуру двухфакторной аутентификации.
 */
public class ManualApprovalRequiredException extends Exception {
    private final String transactionId;
    private final BigDecimal amount;
    private final String requiredApprovalLevel;
    
    public ManualApprovalRequiredException(String transactionId, BigDecimal amount, 
                                          String requiredApprovalLevel) {
        super(String.format("Transaction %s requires %s approval for amount %s", 
                           transactionId, requiredApprovalLevel, amount));
        this.transactionId = transactionId;
        this.amount = amount;
        this.requiredApprovalLevel = requiredApprovalLevel;
    }
    
    public String getTransactionId() { return transactionId; }
    public BigDecimal getAmount() { return amount; }
    public String getRequiredApprovalLevel() { return requiredApprovalLevel; }
}

/**
 * Исключение, сигнализирующее о нарушении бизнес-правила.
 * Восстановление невозможно без изменения входных данных.
 */
public class BusinessRuleViolationException extends RuntimeException {
    private final String ruleCode;
    private final String entityType;
    private final String entityId;
    
    public BusinessRuleViolationException(String ruleCode, String entityType, 
                                         String entityId, String message) {
        super(message);
        this.ruleCode = ruleCode;
        this.entityType = entityType;
        this.entityId = entityId;
    }
    
    public String getRuleCode() { return ruleCode; }
    public String getEntityType() { return entityType; }
    public String getEntityId() { return entityId; }
}

public class Order {
    private OrderStatus status;
    private List<OrderItem> items;
    
    public void cancel() {
        if (status == OrderStatus.SHIPPED) {
            throw new BusinessRuleViolationException(
                "ORDER_ALREADY_SHIPPED",
                "Order",
                this.id,
                "Cannot cancel order that has already been shipped"
            );
        }
        if (status == OrderStatus.CANCELLED) {
            throw new BusinessRuleViolationException(
                "ORDER_ALREADY_CANCELLED",
                "Order",
                this.id,
                "Order is already cancelled"
            );
        }
        this.status = OrderStatus.CANCELLED;
    }
}

// Антипаттерн: God Exception с enum
public class ApplicationException extends RuntimeException {
    private final ErrorCode errorCode;
    
    public ApplicationException(ErrorCode errorCode, String message) {
        super(message);
        this.errorCode = errorCode;
    }
}

// Использование
throw new ApplicationException(ErrorCode.INVALID_DATA_FORMAT, "...");
throw new ApplicationException(ErrorCode.MISSING_REQUIRED_FIELD, "...");

public abstract class PaymentException extends RuntimeException {
    protected PaymentException(String message, Throwable cause) {
        super(message, cause);
    }
}

public class InsufficientFundsException extends PaymentException {
    private final BigDecimal available;
    private final BigDecimal requested;
    
    public InsufficientFundsException(BigDecimal available, BigDecimal requested) {
        super(String.format("Insufficient funds: available %s, requested %s", 
                           available, requested), null);
        this.available = available;
        this.requested = requested;
    }
}

public class PaymentGatewayTimeoutException extends PaymentException {
    private final String gatewayId;
    private final int timeoutMillis;
    
    public PaymentGatewayTimeoutException(String gatewayId, int timeoutMillis) {
        super(String.format("Gateway %s timed out after %dms", gatewayId, timeoutMillis), null);
        this.gatewayId = gatewayId;
        this.timeoutMillis = timeoutMillis;
    }
}

try {
    paymentService.process(payment);
} catch (InsufficientFundsException e) {
    // Специфическая логика: предложить пополнение счета
    return ResponseEntity.status(402)
        .body(new PaymentErrorResponse("INSUFFICIENT_FUNDS", e.getAvailable()));
} catch (PaymentGatewayTimeoutException e) {
    // Специфическая логика: retry с другим шлюзом
    return retryWithAlternativeGateway(payment);
} catch (PaymentException e) {
    // Общая обработка для всех платежных ошибок
    return ResponseEntity.status(500)
        .body(new PaymentErrorResponse("PAYMENT_FAILED", e.getMessage()));
}