Можно ли реализовать логику 100% выполнения строки с добавлением исключения и без него?

Ответ

Гарантированное выполнение кода: try-finally и другие механизмы

Да, в Java есть несколько способов гарантировать, что определённый код выполнится всегда, независимо от того, произойдёт ли исключение или нет. Это критически важно для освобождения ресурсов и финализации операций.

Способ 1: try-finally (классический подход)

public class TryFinallyExample {
    
    public void processFile(String filename) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(filename);
            byte[] data = new byte[1024];
            fis.read(data);  // Может выбросить IOException
            System.out.println("File read successfully");
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
            // Может выбросить исключение
            throw new RuntimeException(e);
        } finally {
            // ГАРАНТИРОВАННОЕ ВЫПОЛНЕНИЕ
            // Выполнится ВСЕГДА: нормальный поток, исключение или даже return
            if (fis != null) {
                try {
                    fis.close();  // Освобождаем ресурс 100% времени
                } catch (IOException e) {
                    System.err.println("Error closing file: " + e);
                }
            }
        }
    }
}

// Важно: finally выполнится даже при:
// 1. Нормальном завершении
// 2. Исключении в try
// 3. Исключении в catch
// 4. return в try или catch
// 5. System.exit() НЕ выполнит finally (исключение!)

Способ 2: try-with-resources (Java 7+, рекомендуется)

Это более чистый и безопасный способ:

public class TryWithResourcesExample {
    
    public void processFile(String filename) throws IOException {
        // try-with-resources АВТОМАТИЧЕСКИ закроет ресурсы
        try (FileInputStream fis = new FileInputStream(filename);
             BufferedInputStream bis = new BufferedInputStream(fis)) {
            
            byte[] data = new byte[1024];
            bis.read(data);
            System.out.println("File read successfully");
            
        } catch (IOException e) {
            System.err.println("Error: " + e.getMessage());
            throw e;  // Переброс исключения
        }
        // close() вызывается АВТОМАТИЧЕСКИ для всех ресурсов
        // Даже если произойдёт исключение!
    }
    
    // Несколько ресурсов
    public void multipleResources() throws Exception {
        try (Connection conn = DriverManager.getConnection("jdbc:...");
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery("SELECT * FROM users")) {
            
            while (rs.next()) {
                System.out.println(rs.getString("name"));
            }
        } catch (SQLException e) {
            System.err.println("Database error: " + e);
        }
        // close() вызовется для rs, затем stmt, затем conn
    }
}

Способ 3: Пользовательский управляемый ресурс

Вы можете создать свой класс, который реализует AutoCloseable:

// Пользовательский ресурс
public class DatabaseConnection implements AutoCloseable {
    private String connectionString;
    private boolean isConnected = false;
    
    public DatabaseConnection(String connectionString) {
        this.connectionString = connectionString;
        connect();
    }
    
    private void connect() {
        System.out.println("Подключение к " + connectionString);
        isConnected = true;
    }
    
    public void executeQuery(String sql) throws SQLException {
        if (!isConnected) {
            throw new SQLException("Connection closed");
        }
        System.out.println("Выполняю: " + sql);
    }
    
    @Override
    public void close() throws Exception {
        // ГАРАНТИРОВАННОЕ ВЫПОЛНЕНИЕ при выходе из try-with-resources
        if (isConnected) {
            System.out.println("Закрываю соединение с " + connectionString);
            isConnected = false;
        }
    }
}

// Использование
public class Main {
    public static void main(String[] args) {
        try (DatabaseConnection db = new DatabaseConnection("localhost:5432/mydb")) {
            db.executeQuery("SELECT * FROM users");
            // Может быть исключение
            throw new RuntimeException("Что-то пошло не так!");
        } catch (Exception e) {
            System.err.println("Ошибка: " + e);
        }
        // close() вызовется ГАРАНТИРОВАННО даже с исключением
    }
}

Вывод:
Подключение к localhost:5432/mydb
Выполняю: SELECT * FROM users
Закрываю соединение с localhost:5432/mydb
Ошибка: java.lang.RuntimeException: Что-то пошло не так!

Способ 4: try-catch-finally вместе

public class ComprehensiveExample {
    
    public void processWithAllPhases() {
        try {
            // Фаза 1: Основная логика
            System.out.println("1. Выполняю основную операцию");
            // Может выбросить исключение
            int result = 10 / 2;  // OK
            System.out.println("Результат: " + result);
            
        } catch (ArithmeticException e) {
            // Фаза 2: Обработка исключения
            System.err.println("2. Ошибка: " + e.getMessage());
            
        } finally {
            // Фаза 3: ГАРАНТИРОВАННОЕ ВЫПОЛНЕНИЕ
            System.out.println("3. Очищаю ресурсы (выполняется ВСЕГДА)");
        }
        
        System.out.println("4. Продолжаю работу после блока");
    }
}

Вывод:
1. Выполняю основную операцию
Результат: 5
3. Очищаю ресурсы (выполняется ВСЕГДА)
4. Продолжаю работу после блока

Способ 5: finally при return

public class FinallyWithReturn {
    
    public String processWithReturn(boolean success) {
        try {
            if (success) {
                System.out.println("Успешное выполнение");
                return "Success";  // Хочет выйти отсюда
            } else {
                throw new IllegalArgumentException("Failed");
            }
        } catch (IllegalArgumentException e) {
            System.out.println("Поймано исключение");
            return "Error";  // Хочет выйти отсюда
        } finally {
            // ВЫПОЛНИТСЯ ВСЕ РАВНО, даже при return!
            System.out.println("Finally блок при return");
        }
    }
    
    public static void main(String[] args) {
        System.out.println(new FinallyWithReturn().processWithReturn(true));
    }
}

Вывод:
Успешное выполнение
Finally блок при return
Success

Исключения: когда finally НЕ выполнится

public class FinallyExceptions {
    
    public void systemExit() {
        try {
            System.out.println("Начало try");
            System.exit(0);  // Завершает всю JVM!
        } finally {
            // НЕ ВЫПОЛНИТСЯ!
            System.out.println("Finally не выполнится");
        }
    }
    
    public void infiniteLoop() {
        try {
            System.out.println("Начало try");
            while (true) {  // Бесконечный цикл
                Thread.sleep(1000);
            }
        } finally {
            // НЕ ВЫПОЛНИТСЯ (пока не прервать поток)
            System.out.println("Finally не выполнится");
        }
    }
    
    public void threadTerminated() {
        try {
            System.out.println("Начало try");
            // Основной поток прерывается извне
        } finally {
            // НЕ ВЫПОЛНИТСЯ если JVM завершена
            System.out.println("Finally");
        }
    }
}

Способ 6: Guardrails и Callback'и

public class CallbackPattern {
    
    @FunctionalInterface
    public interface Operation {
        void execute() throws Exception;
    }
    
    // Функция гарантирует выполнение cleanup кода
    public static void executeWithGuarantee(
            Operation operation,
            Runnable cleanup) {
        try {
            operation.execute();
        } catch (Exception e) {
            System.err.println("Ошибка: " + e);
        } finally {
            // ГАРАНТИРОВАННОЕ ВЫПОЛНЕНИЕ cleanup
            cleanup.run();
        }
    }
    
    public static void main(String[] args) {
        executeWithGuarantee(
            () -> {
                System.out.println("Выполняю операцию");
                throw new RuntimeException("Ошибка!");
            },
            () -> System.out.println("Очищаю ресурсы (гарантированно)")
        );
    }
}

Вывод:
Выполняю операцию
Ошибка: java.lang.RuntimeException: Ошибка!
Очищаю ресурсы (гарантированно)

Способ 7: Stream API с peek() и finally

public class StreamExample {
    
    public void streamProcessing() {
        try {
            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
            numbers.stream()
                .peek(n -> System.out.println("Обработка: " + n))
                .filter(n -> n % 2 == 0)
                .peek(n -> System.out.println("Фильтровал: " + n))
                .forEach(n -> System.out.println("Результат: " + n));
                
            // Может быть исключение
        } finally {
            System.out.println("Очищаю ресурсы");
        }
    }
}

Сравнение подходов

┌──────────────────────┬──────────────┬────────────────┬─────────────────┐
│ Подход               │ Автоматизм   │ Безопасность   │ Рекомендация    │
├──────────────────────┼──────────────┼────────────────┼─────────────────┤
│ try-finally          │ Ручной       │ Средняя        │ Наследство      │
│ try-with-resources   │ АВТОМАТИЧЕ   │ ВЫСОКАЯ        │ ★ ЛУЧШИЙ        │
│ AutoCloseable        │ АВТОМАТИЧЕ   │ ВЫСОКАЯ        │ ★ ЛУЧШИЙ        │
│ finally + return     │ Ручной       │ Средняя        │ Осторожно        │
│ Callback'и           │ Явный        │ Средняя        │ Функцион стиль   │
└──────────────────────┴──────────────┴────────────────┴─────────────────┘

Вывод

Да, можно реализовать 100% выполнение кода:

1. try-finally — классический способ, но требует ручного управления ресурсами
2. try-with-resources — рекомендуемый способ (Java 7+), автоматически закрывает ресурсы
3. AutoCloseable — для пользовательских ресурсов
4. finally ВСЕГДА выполняется, кроме System.exit() и завершения JVM

Для современного Java кода используйте try-with-resources — это безопаснее, чище и меньше кода.