/**
 * Исключение, сигнализирующее о необходимости ручного подтверждения
 * платежа из-за превышения лимита. Вызывающий код должен инициировать
 * процедуру двухфакторной аутентификации.
 */
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()));
}

// Антипаттерн: потеря cause
try {
    processFile(file);
} catch (IOException e) {
    throw new FileProcessingException("Failed to process file");  // Cause потерян!
}
Правильный подход — всегда передавать оригинальное исключение в конструктор:
java
Copy
// Правильно: сохранение цепочки причин
try {
    processFile(file);
} catch (IOException e) {
    throw new FileProcessingException("Failed to process file: " + file.getName(), e);
}

// Базовое исключение для всего приложения
public abstract class LibraryException extends RuntimeException {
    protected LibraryException(String message, Throwable cause) {
        super(message, cause);
    }
}

// Домен: каталог книг
public abstract class CatalogException extends LibraryException {
    protected CatalogException(String message, Throwable cause) {
        super(message, cause);
    }
}

public class BookNotFoundException extends CatalogException {
    private final String isbn;
    
    public BookNotFoundException(String isbn) {
        super("Book not found: " + isbn, null);
        this.isbn = isbn;
    }
    
    public String getIsbn() { return isbn; }
}

public class DuplicateIsbnException extends CatalogException {
    private final String isbn;
    private final Long existingBookId;
    
    public DuplicateIsbnException(String isbn, Long existingBookId) {
        super(String.format("ISBN %s already exists for book %d", isbn, existingBookId), null);
        this.isbn = isbn;
        this.existingBookId = existingBookId;
    }
}

// Домен: пользователи
public abstract class UserException extends LibraryException {
    protected UserException(String message, Throwable cause) {
        super(message, cause);
    }
}

public class UserNotActiveException extends UserException {
    private final String userId;
    private final UserStatus currentStatus;
    
    public UserNotActiveException(String userId, UserStatus currentStatus) {
        super(String.format("User %s is not active, current status: %s", userId, currentStatus), null);
        this.userId = userId;
        this.currentStatus = currentStatus;
    }
}

public class LibraryProcessingException extends RuntimeException {
    private final String operation;
    private final String entityId;
    private final Instant timestamp;
    
    // Базовый конструктор
    public LibraryProcessingException(String operation, String entityId, String message) {
        this(operation, entityId, message, null);
    }
    
    // Конструктор с cause для цепочки исключений
    public LibraryProcessingException(String operation, String entityId, 
                                     String message, Throwable cause) {
        super(message, cause);
        this.operation = operation;
        this.entityId = entityId;
        this.timestamp = Instant.now();
    }
    
    // Геттеры для структурированного доступа к данным
    public String getOperation() { return operation; }
    public String getEntityId() { return entityId; }
    public Instant getTimestamp() { return timestamp; }
}

@ControllerAdvice
public class LibraryExceptionHandler {
    
    @ExceptionHandler(BookNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleBookNotFound(BookNotFoundException e) {
        return ResponseEntity.status(HttpStatus.NOT_FOUND)
            .body(new ErrorResponse(
                "BOOK_NOT_FOUND",
                e.getMessage(),
                Map.of("isbn", e.getIsbn())
            ));
    }
    
    @ExceptionHandler(DuplicateIsbnException.class)
    public ResponseEntity<ErrorResponse> handleDuplicateIsbn(DuplicateIsbnException e) {
        return ResponseEntity.status(HttpStatus.CONFLICT)
            .body(new ErrorResponse(
                "DUPLICATE_ISBN",
                e.getMessage(),
                Map.of("isbn", e.getIsbn(), "existingBookId", e.getExistingBookId())
            ));
    }
    
    @ExceptionHandler(LibraryException.class)
    public ResponseEntity<ErrorResponse> handleGenericLibrary(LibraryException e) {
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(new ErrorResponse(
                "LIBRARY_ERROR",
                "An unexpected library error occurred",
                Map.of()
            ));
    }
}

class MyCheckedException extends Exception {
    public MyCheckedException() { super(); }
}

class MyUncheckedException extends RuntimeException {
    public MyUncheckedException() { super(); }
}

public class Task220426 {
    public static void main(String[] args) {
        try {
            throw new MyUncheckedException();
        } catch (Exception e) {
            System.out.print("1");
        }

        try {
            throw new MyCheckedException();
        } catch (RuntimeException e) {
            System.out.print("2");
        } catch (Exception e) {
            System.out.print("3");
        }

        try {
            throw new MyUncheckedException();
        } finally {
            System.out.print("4");
        }
    }
}

public class ClassLoadingExample {
    
    private static final String HEAVY_CLASS = "com.example.DatabaseDriver";
    
    //Антипаттерн: Class.forName() с нежелательной инициализацией
    public static void dangerousLoad() throws ClassNotFoundException {
        // Выполнит статические блоки класса DatabaseDriver
        // Может открыть соединение, зарегистрировать драйвер и т.д.
        Class<?> clazz = Class.forName(HEAVY_CLASS);
        System.out.println("Класс загружен и инициализирован: " + clazz.getName());
    }
    
    //Решение 1: загрузка без инициализации через ClassLoader
    public static Class<?> safeLoadWithoutInit(String className) {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        try {
            // loadClass() загружает и связывает, но не инициализирует
            return classLoader.loadClass(className);
        } catch (ClassNotFoundException e) {
            System.err.println("Класс не найден: " + className);
            return null;
        }
    }
    
    //Решение 2: Class.forName() с отключенной инициализацией
    public static Class<?> safeForName(String className) throws ClassNotFoundException {
        ClassLoader loader = Thread.currentThread().getContextClassLoader();
        // initialize = false — статические блоки НЕ выполняются
        return Class.forName(className, false, loader);
    }
    
    //Демонстрация разницы
    static class DemoClass {
        static {
            System.out.println("Статический блок DemoClass выполнен!");
            // Здесь может быть тяжелая операция
        }
        
        static int value = computeValue();
        
        private static int computeValue() {
            System.out.println("Статический метод computeValue() вызван");
            return 42;
        }
    }

public class Task230426 {
    static class TestClass {
        static {
            System.out.println("Static block");
        }
    }

    public static void main(String[] args) throws Exception {
        System.out.println("Start");

        Class<?> clazz1 = Class.forName(Task230426.class.getName() + "$TestClass");
        System.out.println("After forName");

        Class<?> clazz2 = Task230426.class.getClassLoader()
                .loadClass(Task230426.class.getName() + "$TestClass");
        System.out.println("After loadClass");
    }
}

try (FileInputStream fis = new FileInputStream("source.txt");
     BufferedInputStream bis = new BufferedInputStream(fis);
     FileOutputStream fos = new FileOutputStream("dest.txt");
     BufferedOutputStream bos = new BufferedOutputStream(fos)) {
    
    byte[] buffer = new byte[8192];
    int bytesRead;
    while ((bytesRead = bis.read(buffer)) != -1) {
        bos.write(buffer, 0, bytesRead);
    }
}

// Псевдокод трансформации компилятором
{
    final Resource r1 = new Resource("r1");
    Throwable primaryExc1 = null;
    try {
        final Resource r2 = new Resource("r2");
        Throwable primaryExc2 = null;
        try {
            // Основной блок
            r1.work();
            r2.work();
        } catch (Throwable t) {
            primaryExc2 = t;
            throw t;
        } finally {
            if (r2 != null) {
                if (primaryExc2 != null) {
                    try {
                        r2.close();
                    } catch (Throwable suppressed) {
                        primaryExc2.addSuppressed(suppressed);
                    }
                } else {
                    r2.close();
                }
            }
        }
    } catch (Throwable t) {
        primaryExc1 = t;
        throw t;
    } finally {
        if (r1 != null) {
            if (primaryExc1 != null) {
                try {
                    r1.close();
                } catch (Throwable suppressed) {
                    primaryExc1.addSuppressed(suppressed);
                }
            } else {
                r1.close();
            }
        }
    }
}

try (FileReader fr = new FileReader("file.txt");
     BufferedReader br = new BufferedReader(fr)) {
    // ...
}
// Закрытие: br.close() вызывает fr.close(), затем fr.close() вызывается повторно

public List<User> findUsersByRole(String role) throws SQLException {
    String query = "SELECT id, name, email FROM users WHERE role = ?";
    
    try (Connection conn = dataSource.getConnection();
         PreparedStatement stmt = conn.prepareStatement(query);
         ResultSet rs = stmt.executeQuery()) {
        
        stmt.setString(1, role);
        List<User> users = new ArrayList<>();
        
        while (rs.next()) {
            users.add(mapRowToUser(rs));
        }
        return users;
    }
}

// Java 7/8: избыточное объявление новой переменной
BufferedReader br = new BufferedReader(new FileReader("data.txt"));
try (BufferedReader reader = br) {  // Вынуждены создать reader, хотя br уже готов
    String line = reader.readLine();
    // ...
}

// Java 9+: прямое использование существующей переменной
BufferedReader br = new BufferedReader(new FileReader("data.txt"));
try (br) {  // Нет необходимости в новой переменной
    String line = br.readLine();
    // ...
}

// Java 9+: несколько effectively final ресурсов
final Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery(query);  // effectively final

try (statement; resultSet) {
    while (resultSet.next()) {
        processRow(resultSet);
    }
}

public class ReportGenerator {
    
    public void generateMonthlyReport(Path outputPath) throws IOException {
        // Ресурс создается здесь
        BufferedWriter writer = Files.newBufferedWriter(outputPath);
        
        try {
            writeHeader(writer);
            writeBody(writer);
            writeFooter(writer);
        } finally {
            // Ручное закрытие до Java 9
            if (writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    logger.warn("Failed to close writer", e);
                }
            }
        }
    }
}

public void generateMonthlyReport(Path outputPath) throws IOException {
    BufferedWriter writer = Files.newBufferedWriter(outputPath);
    
    try (writer) {
        writeHeader(writer);
        writeBody(writer);
        writeFooter(writer);
    }
    // writer автоматически закрыт, suppressed exceptions сохранены
}

// Потенциально опасный код с effectively final
Resource r1 = new Resource("r1");
Resource r2 = new Resource("r2");  // Если здесь исключение — r1 не будет закрыт!

try (r1; r2) {
    // ...
}

Connection conn = dataSource.getConnection();
PreparedStatement stmt = conn.prepareStatement(query);
ResultSet rs = stmt.executeQuery();

try (conn; stmt; rs) {
    return extractResults(rs);
} catch (SQLException e) {
    // Выполняется после закрытия всех ресурсов
    throw new DataAccessException("Query failed: " + query, e);
} finally {
    // Выполняется после catch, все ресурсы уже закрыты
    metrics.recordQueryExecution(query, System.currentTimeMillis() - startTime);
}

import java.io.*;

public class Task240426 {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new StringReader("test"));

        try (reader) {
            System.out.print(reader.readLine());
        }

        reader.readLine();
    }
}