// Плохо: ресурс может остаться открытым при исключении
public List<Book> importFromJsonManual(String filename) {
    FileReader reader = null;
    try {
        reader = new FileReader(filename);
        // ... парсинг ...
        return parseBooks(reader);
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        if (reader != null) {
            try {
                reader.close();  // Может бросить исключение, подавляя основное
            } catch (IOException e) {
                // игнорируем
            }
        }
    }
}

// Хорошо: автоматическое закрытие, правильная обработка исключений
public List<Book> importFromJson(String filename) {
    try (FileReader reader = new FileReader(filename);
         BufferedReader buffered = new BufferedReader(reader)) {
        
        StringBuilder json = new StringBuilder();
        String line;
        while ((line = buffered.readLine()) != null) {
            json.append(line);
        }
        return parseBooks(json.toString());
        
    } catch (IOException e) {
        throw new LibraryException("Не удалось прочитать файл: " + filename, e);
    }
}

public void exportToJson(String inputFilename, String outputFilename) {
    try (BufferedReader reader = Files.newBufferedReader(Path.of(inputFilename));
         BufferedWriter writer = Files.newBufferedWriter(Path.of(outputFilename))) {
        
        String json = reader.readLine();
        List<Book> books = parseBooks(json);
        String formatted = formatBooks(books);
        writer.write(formatted);
        
    } catch (IOException e) {
        throw new LibraryException("Ошибка при копировании данных", e);
    }
}

public class LibraryException extends RuntimeException {
    
    public LibraryException(String message) {
        super(message);
    }
    
    public LibraryException(String message, Throwable cause) {
        super(message, cause);
    }
    
    public LibraryException(String message, String bookId, Throwable cause) {
        super(message + " [книга: " + bookId + "]", cause);
    }
}

public Book findBookOrThrow(String bookId) {
    return findById(bookId)
        .orElseThrow(() -> new LibraryException("Книга не найдена", bookId, null));
}

public List<Book> loadFromMultipleSources(String jsonPath, String csvPath) {
    List<Book> result = new ArrayList<>();
    
    try {
        result.addAll(loadJson(jsonPath));
    } catch (FileNotFoundException | NoSuchFileException e) {
        // Файла нет — не критично, продолжаем с CSV
        System.err.println("JSON не найден, пробуем CSV: " + e.getMessage());
    } catch (IOException e) {
        throw new LibraryException("Ошибка чтения JSON", e);
    }
    
    try {
        result.addAll(loadCsv(csvPath));
    } catch (FileNotFoundException | NoSuchFileException e) {
        System.err.println("CSV не найден: " + e.getMessage());
    } catch (IOException e) {
        throw new LibraryException("Ошибка чтения CSV", e);
    }
    
    if (result.isEmpty()) {
        throw new LibraryException("Не удалось загрузить книги ни из одного источника");
    }
    
    return result;
}

// Не компилируется: parseDate бросает checked DateTimeParseException
public List<LocalDate> parsePublicationDates(List<String> dateStrings) {
    return dateStrings.stream()
        .map(this::parseDate)  // Ошибка: unreported exception
        .collect(Collectors.toList());
}

private LocalDate parseDate(String s) throws DateTimeParseException {
    return LocalDate.parse(s);  // checked в Java 8, но...
}

// Реальная проблема: Files.readString бросает IOException
public List<String> loadDescriptions(List<Path> paths) {
    return paths.stream()
        .map(Files::readString)  // Ошибка: IOException не обработана
        .collect(Collectors.toList());
}

public List<String> loadDescriptionsWrapped(List<Path> paths) {
    return paths.stream()
        .map(path -> {
            try {
                return Files.readString(path);
            } catch (IOException e) {
                throw new LibraryException("Не удалось прочитать: " + path, e);
            }
        })
        .collect(Collectors.toList());
}

// Утилитный метод для оборачивания checked в unchecked
@FunctionalInterface
public interface ThrowingFunction<T, R> {
    R apply(T t) throws Exception;
}

public static <T, R> Function<T, R> wrap(ThrowingFunction<T, R> throwing) {
    return t -> {
        try {
            return throwing.apply(t);
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new LibraryException("Ошибка в потоковой операции", e);
        }
    };
}

public List<String> loadDescriptionsClean(List<Path> paths) {
    return paths.stream()
        .map(wrap(Files::readString))
        .collect(Collectors.toList());
}

public Optional<Book> parseBookFromJson(String json) {
    return Optional.ofNullable(json)
        .map(wrap(this::parseBook))
        .orElseThrow(() -> new LibraryException("Пустой JSON"));
}

private Book parseBook(String json) throws JsonParseException {
    // парсинг...
}

public void addBook(Book book) {
    Objects.requireNonNull(book, "Книга не может быть null");
    Objects.requireNonNull(book.getTitle(), "Название не может быть null");
    
    if (book.getYear() < 1450 || book.getYear() > Year.now().getValue() + 1) {
        throw new IllegalArgumentException("Недопустимый год: " + book.getYear());
    }
    
    books.add(book);
}

public Book findById(String id) {
    Objects.requireNonNull(id, () -> "ID книги не может быть null, доступные: " + listIds());
    // ленивое вычисление сообщения — вызывается только при ошибке
    return internalFind(id);
}

public Book getBook(String bookId) {
    return findById(bookId)
        .orElseThrow(() -> new LibraryException("Книга не найдена", bookId, null));
}

public LocalDate getPublicationDate(String bookId) {
    return findById(bookId)
        .map(Book::getPublishedDate)
        .filter(Objects::nonNull)
        .orElseThrow(() -> new LibraryException("Дата неизвестна", bookId, null));
}

public class Library {
    private final List<Book> books = new ArrayList<>();
    
    public void addBook(Book book) {
        Objects.requireNonNull(book, "Книга не может быть null");
        Objects.requireNonNull(book.getId(), "ID книги не может быть null");
        
        if (findById(book.getId()).isPresent()) {
            throw new LibraryException("Книга с ID " + book.getId() + " уже существует");
        }
        
        books.add(book);
    }
    
    public Book getBook(String id) {
        Objects.requireNonNull(id, "ID не может быть null");
        return findById(id)
            .orElseThrow(() -> new LibraryException("Книга не найдена", id, null));
    }
    
    public List<Book> importFromJson(String filename) {
        Objects.requireNonNull(filename, "Имя файла не может быть null");
        
        try (BufferedReader reader = Files.newBufferedReader(Path.of(filename))) {
            String json = reader.lines().collect(Collectors.joining());
            return parseBooks(json);
        } catch (FileNotFoundException | NoSuchFileException e) {
            throw new LibraryException("Файл не найден: " + filename, e);
        } catch (IOException e) {
            throw new LibraryException("Ошибка чтения файла: " + filename, e);
        }
    }
    
    public List<Book> importFromMultipleSources(List<String> filenames) {
        Objects.requireNonNull(filenames, "Список файлов не может быть null");
        
        return filenames.stream()
            .filter(Objects::nonNull)
            .map(wrap(this::importFromJson))
            .flatMap(List::stream)
            .collect(Collectors.toList());
    }
    
    private Optional<Book> findById(String id) {
        return books.stream()
            .filter(b -> b.getId().equals(id))
            .findFirst();
    }
    
    private List<Book> parseBooks(String json) {
        // реализация парсинга
    }
}

public List<LocalDate> parseDatesWithFallback(List<String> inputs) {
    // Парсит даты, при ошибке возвращает LocalDate.MIN вместо исключения
    // Используйте обёртку, возвращающую Optional<LocalDate>
}

class Parent040526 {
    static void print() {
        System.out.println("Parent");
    }
}

class Child040526 extends Parent040526 {
    static void print() {
        System.out.println("Child");
    }
}

public class Task040526 {
    public static void main(String[] args) {
        Parent040526 obj1 = new Parent040526();
        Parent040526 obj2 = new Child040526();
        Child040526 obj3 = new Child040526();
        
        obj1.print();
        obj2.print();
        obj3.print();
    }
}