// Антипаттерн: прямая передача 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());
    }
}