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()));
}

// Антипаттерн: потеря 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;
        }
    }