java.lang.Object
    └── java.lang.Throwable (checked)
        ├── java.lang.Error (unchecked)
        │   ├── OutOfMemoryError
        │   ├── StackOverflowError
        │   ├── NoClassDefFoundError
        │   └── ...
        └── java.lang.Exception (checked)
            ├── IOException
            ├── SQLException
            └── java.lang.RuntimeException (unchecked)
                ├── NullPointerException
                ├── IllegalArgumentException
                ├── IllegalStateException
                └── ...

public class ErrorHandlingDemo {
    
    public static void main(String[] args) {
        try {
            recursiveCall(0);
        } catch (StackOverflowError e) {
            // Технически возможно, но бесполезно
            System.out.println("Stack overflow caught: " + e.getMessage());
            // Попытка продолжить работу здесь крайне опасна
            // JVM находится в нестабильном состоянии
        }
    }
    
    private static void recursiveCall(int depth) {
        // Каждый вызов добавляет фрейм в стек
        recursiveCall(depth + 1);
    }
}

// Проверяемое исключение для восстановимых бизнес-ошибок
public class PaymentProcessingException extends Exception {
    private final String transactionId;
    private final PaymentErrorCode errorCode;
    
    public PaymentProcessingException(String message, String transactionId, 
                                     PaymentErrorCode errorCode, Throwable cause) {
        super(message, cause);
        this.transactionId = transactionId;
        this.errorCode = errorCode;
    }
    
    // Геттеры для структурированной информации об ошибке
    public String getTransactionId() { return transactionId; }
    public PaymentErrorCode getErrorCode() { return errorCode; }
}

// Непроверяемое исключение для программных ошибок валидации
public class InvalidPaymentRequestException extends RuntimeException {
    private final String fieldName;
    private final Object rejectedValue;
    
    public InvalidPaymentRequestException(String fieldName, Object rejectedValue, String message) {
        super(message);
        this.fieldName = fieldName;
        this.rejectedValue = rejectedValue;
    }
}

// Антипаттерн — никогда так не делайте
public void processRequest(Request request) {
    try {
        executeBusinessLogic(request);
    } catch (Throwable t) {  // Опасно: перехватывает Error
        logger.error("Request failed", t);
        // Если это был OutOfMemoryError, приложение продолжит работу
        // с нестабильной JVM, что приведет к непредсказуемым последствиям
    }
}

public User loadUserById(String userId) throws UserRepositoryException {
    try {
        return database.executeQuery("SELECT * FROM users WHERE id = ?", userId);
    } catch (SQLException e) {
        // Сохраняем оригинальное исключение как cause
        throw new UserRepositoryException(
            "Failed to load user with ID: " + userId, 
            e  // Цепочка причин сохраняется
        );
    }
}

public class Task080426 {
    public static void main(String[] args) {
        try {
            throw new NullPointerException();
        } catch (Throwable t) {
            System.out.print("A");
            throw new RuntimeException();
        } finally {
            System.out.print("B");
        }
    }
}

public class ClassLoaderLeakExample {
    
    //Антипаттерн: статическое поле хранит класс, загруженный динамическим ClassLoader'ом
    private static Class<?> CACHED_CLASS;
    
    public static void dangerousStore(Class<?> clazz) {
        CACHED_CLASS = clazz; // Удерживает ClassLoader навсегда
    }
    
    //Антипаттерн: ThreadLocal без очистки
    private static final ThreadLocal<Object> THREAD_LOCAL = new ThreadLocal<>();
    
    public static void dangerousThreadLocal() {
        THREAD_LOCAL.set(new Object()); // Поток из пула может пережить перезагрузку
    }
    
    //Решение: очистка ThreadLocal в finally или в слушателе
    public static void safeThreadLocal() {
        try {
            THREAD_LOCAL.set(new Object());
            // работа
        } finally {
            THREAD_LOCAL.remove(); // Обязательно
        }
    }
    
    //Решение для веб-приложений: слушатель контекста
    public static class CleanupListener implements ServletContextListener {
        @Override
        public void contextDestroyed(ServletContextEvent sce) {
            // Дерегистрация JDBC-драйверов
            Enumeration<Driver> drivers = DriverManager.getDrivers();
            while (drivers.hasMoreElements()) {
                Driver driver = drivers.nextElement();
                if (driver.getClass().getClassLoader() == 
                    Thread.currentThread().getContextClassLoader()) {
                    try {
                        DriverManager.deregisterDriver(driver);
                    } catch (Exception e) { /* log */ }
                }
            }
            
            // Очистка статических кешей логирования (Log4j, Logback)
            // org.slf4j.LoggerFactory.getILoggerFactory().reset();
            
            // Остановка фоновых потоков
            // Thread.interruptAll() и т.п.
        }
    }
}

import java.lang.ref.WeakReference;

public class Task090426 {
    public static void main(String[] args) {
        Object obj = new Object();
        WeakReference<Object> ref = new WeakReference<>(obj);
        obj = null;
        System.gc();
        System.out.println(ref.get());
    }
}

// Низкоуровневый метод работы с базой данных
public User findById(String id) throws SQLException {
    Connection conn = dataSource.getConnection();
    // ... выполнение запроса
}

// Сервисный слой вынужден пробрасывать checked-исключение
public User getUser(String id) throws SQLException {
    return userRepository.findById(id);
}

// Контроллер также заражен checked-исключением
public UserDto getUserEndpoint(String id) throws SQLException {
    User user = userService.getUser(id);
    return userMapper.toDto(user);
}

// Кастомное unchecked-исключение для домена
public class UserNotFoundException extends RuntimeException {
    private final String userId;
    
    public UserNotFoundException(String userId) {
        super("User not found: " + userId);
        this.userId = userId;
    }
}

// Репозиторий скрывает детали SQL, транслирует в доменное исключение
public User findById(String id) {
    try {
        Connection conn = dataSource.getConnection();
        // ... выполнение запроса
    } catch (SQLException e) {
        throw new DataAccessException("Database error while loading user", e);
    }
}

// Сервисный слой чист, без throws
public User getUser(String id) {
    return userRepository.findById(id)
        .orElseThrow(() -> new UserNotFoundException(id));
}

// Контроллер также чист, фокусируется на HTTP-логике
public UserDto getUserEndpoint(String id) {
    User user = userService.getUser(id);
    return userMapper.toDto(user);
}

@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    // Метод объявлен без throws, но может выбросить unchecked исключения
    Optional<Order> findByOrderNumber(String orderNumber);
}

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    
    @Transactional
    public Order processOrder(String orderNumber) {
        // Никаких try-catch для checked-исключений
        Order order = orderRepository.findByOrderNumber(orderNumber)
            .orElseThrow(() -> new OrderNotFoundException(orderNumber));
        
        // При ошибке базы данных будет выброшено DataAccessException
        // Транзакция откатится автоматически
        return executeBusinessLogic(order);
    }
}

@ControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(DataAccessException.class)
    public ResponseEntity<ErrorResponse> handleDatabaseError(DataAccessException e) {
        // Логирование, метрики, уведомление
        return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE)
            .body(new ErrorResponse("Database temporarily unavailable"));
    }
    
    @ExceptionHandler(OrderNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleNotFound(OrderNotFoundException e) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
            .body(new ErrorResponse(e.getMessage()));
    }
}

fun updateOrderQuantity(orderId: OrderId, quantity: Int) {
    require(quantity > 0) { "Quantity must be positive" }
    val order = loadOrder(orderId)  // Может выбросить исключение, но не требует try-catch
    order.quantity = quantity
    storeOrder(order)  // То же самое
}

// Метод с checked-исключением
public String fetchDataFromUrl(String url) throws IOException {
    return httpClient.fetch(url);
}

// Невозможно напрямую использовать в Stream
List<String> urls = List.of("http://api1.com", "http://api2.com");
List<String> data = urls.stream()
    .map(this::fetchDataFromUrl)  // Ошибка компиляции: IOException не обработано
    .collect(Collectors.toList());

List<String> data = urls.stream()
    .map(url -> {
        try {
            return fetchDataFromUrl(url);
        } catch (IOException e) {
            throw new RuntimeException(e);  // Уничтожение семантики checked-исключения
        }
    })
    .collect(Collectors.toList());

// Checked-исключение для редкого, но критичного сценария восстановления
public class PaymentReversalRequiredException extends Exception {
    private final Payment originalPayment;
    private final String reasonCode;
    
    public PaymentReversalRequiredException(Payment payment, String reasonCode, String message) {
        super(message);
        this.originalPayment = payment;
        this.reasonCode = reasonCode;
    }
    
    // Методы доступа для логики восстановления
    public Payment getOriginalPayment() { return originalPayment; }
    public String getReasonCode() { return reasonCode; }
}

// Unchecked-исключения для всех остальных сценариев
public class PaymentProcessingException extends RuntimeException {
    private final String transactionId;
    
    public PaymentProcessingException(String transactionId, String message, Throwable cause) {
        super(message, cause);
        this.transactionId = transactionId;
    }
}

public class InvalidPaymentRequestException extends IllegalArgumentException {
    private final String fieldName;
    
    public InvalidPaymentRequestException(String fieldName, Object value) {
        super(String.format("Invalid value for field %s: %s", fieldName, value));
        this.fieldName = fieldName;
    }
}

import io.vavr.control.Either;
import io.vavr.control.Try;

public Either<PaymentError, PaymentReceipt> processPayment(PaymentRequest request) {
    return validateRequest(request)
        .flatMap(this::authorizePayment)
        .flatMap(this::executeTransfer)
        .map(this::generateReceipt);
}

private Either<PaymentError, ValidatedRequest> validateRequest(PaymentRequest request) {
    if (request.getAmount() <= 0) {
        return Either.left(new PaymentError("INVALID_AMOUNT", "Amount must be positive"));
    }
    if (request.getCurrency() == null) {
        return Either.left(new PaymentError("MISSING_CURRENCY", "Currency is required"));
    }
    return Either.right(new ValidatedRequest(request));
}