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

Да, можно. Логика гарантированного выполнения реализуется без явного выброса исключений

Гарантированное выполнение означает, что код точно выполнится, независимо от результата других операций. В Java существует несколько механизмов для этого, и исключения не обязательны.

1. Блок finally — основной инструмент

Блок finally выполняется всегда, даже если произойдёт исключение или return:

public class GuaranteedExecution {
    public static void example1() {
        try {
            System.out.println("1. Начало try");
            int result = 10 / 2;  // Нормальная операция
            System.out.println("2. Результат: " + result);
            return;  // Выход из метода
        } finally {
            // ✅ Это ГАРАНТИРОВАННО выполнится
            System.out.println("3. Finally выполнился, несмотря на return");
        }
    }
    
    public static void main(String[] args) {
        example1();
    }
}

// Вывод:
// 1. Начало try
// 2. Результат: 5
// 3. Finally выполнился, несмотря на return

2. Случаи, когда finally ВСЕГДА выполняется

public class FinallyGuarantees {
    
    // Случай 1: Нормальное завершение
    public static void case1() {
        try {
            System.out.println("Нормальное выполнение");
        } finally {
            System.out.println("Finally выполнится");  // ✅ Выполнится
        }
    }
    
    // Случай 2: Исключение в try
    public static void case2() {
        try {
            throw new RuntimeException("Ошибка!");
        } catch (RuntimeException e) {
            System.out.println("Поймано исключение");
        } finally {
            System.out.println("Finally выполнится");  // ✅ Выполнится
        }
    }
    
    // Случай 3: return в try
    public static String case3() {
        try {
            return "Значение из try";
        } finally {
            System.out.println("Finally выполнится");  // ✅ Выполнится
        }
    }
    
    // Случай 4: return в catch
    public static String case4() {
        try {
            throw new RuntimeException();
        } catch (RuntimeException e) {
            return "Значение из catch";
        } finally {
            System.out.println("Finally выполнится");  // ✅ Выполнится
        }
    }
    
    // Случай 5: System.exit() — ИСКЛЮЧЕНИЕ!
    public static void case5() {
        try {
            System.out.println("До System.exit");
            System.exit(0);  // Завершает JVM
        } finally {
            System.out.println("Finally НЕ выполнится");  // ❌ Не выполнится
        }
    }
    
    // Случай 6: Бесконечный цикл
    public static void case6() {
        try {
            while (true) {  // Бесконечный цикл
                // Ничего не делаем
            }
        } finally {
            System.out.println("Finally НЕ выполнится");  // ❌ Не выполнится
        }
    }
}

3. Try-with-resources (Java 7+) — автоматическое закрытие

Блок try-with-resources гарантирует закрытие ресурса:

import java.io.*;

public class ResourceManagement {
    
    // Плохо: может протечь ресурс при исключении
    public static void readFileBad() throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("file.txt"));
        String line = reader.readLine();
        System.out.println(line);
        reader.close();  // Может не выполниться при исключении
    }
    
    // ✅ Хорошо: try-with-resources закроет ресурс ГАРАНТИРОВАННО
    public static void readFileGood() throws IOException {
        try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
            String line = reader.readLine();
            System.out.println(line);
        }  // reader.close() вызовется ВСЕГДА
    }
    
    // Множественные ресурсы
    public static void copyFile(String source, String dest) throws IOException {
        try (
            BufferedReader reader = new BufferedReader(new FileReader(source));
            BufferedWriter writer = new BufferedWriter(new FileWriter(dest))
        ) {
            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }
        }  // Оба ресурса закроются в порядке LIFO (последний-первый)
    }
}

4. Реализация собственного Autocloseable

public class ResourceExample implements AutoCloseable {
    
    public ResourceExample() {
        System.out.println("Ресурс создан");
    }
    
    public void use() {
        System.out.println("Ресурс используется");
    }
    
    @Override
    public void close() {
        System.out.println("Ресурс закрыт ГАРАНТИРОВАННО");
    }
}

public class Test {
    public static void main(String[] args) {
        // Ресурс закроется в любом случае
        try (ResourceExample resource = new ResourceExample()) {
            resource.use();
            // Даже если здесь исключение
            throw new RuntimeException("Ошибка!");
        } catch (Exception e) {
            System.out.println("Поймано: " + e.getMessage());
        }
    }
}

// Вывод:
// Ресурс создан
// Ресурс используется
// Ресурс закрыт ГАРАНТИРОВАННО
// Поймано: Ошибка!

5. Сравнение: Исключение vs Finally

public class ExceptionVsFinally {
    
    // С исключением (throws)
    public static void methodWithException() throws IOException {
        // Метод "объявляет" о возможной ошибке
        // Но это не гарантирует выполнение кода!
    }
    
    // С finally (гарантирует выполнение)
    public static void methodWithFinally() {
        try {
            // код
        } finally {
            // ✅ Это ВСЕГДА выполнится
            System.out.println("Cleanup код");
        }
    }
}

// Разница:
// - throws: информирует об ошибке (обработка на уровне выше)
// - finally: гарантирует выполнение кода (cleanup, ресурсы)

6. Практический пример: Логирование гарантированного выполнения

public class LoggingExample {
    
    public static String processData(String input) {
        long startTime = System.currentTimeMillis();
        
        try {
            // Основная логика
            if (input == null || input.isEmpty()) {
                throw new IllegalArgumentException("Пустой input");
            }
            
            return "Обработано: " + input.toUpperCase();
            
        } catch (IllegalArgumentException e) {
            System.err.println("Ошибка валидации: " + e.getMessage());
            return "Ошибка";  // return тоже в finally
            
        } finally {
            // ✅ Логирование выполнится ВСЕГДА
            long duration = System.currentTimeMillis() - startTime;
            System.out.println("Обработка заняла: " + duration + " мс");
        }
    }
    
    public static void main(String[] args) {
        System.out.println(processData("hello"));
        System.out.println(processData(""));
    }
}

// Вывод:
// Обработано: HELLO
// Обработка заняла: 1 мс
// Ошибка валидации: Пустой input
// Ошибка
// Обработка заняла: 0 мс

7. Когда finally НЕ выполнится

⚠️ Редкие случаи:

// 1. System.exit()
System.exit(0);

// 2. Завершение JVM (OutOfMemoryError, StackOverflowError)
while (true) {
    int[] arr = new int[Integer.MAX_VALUE];
}

// 3. Убийство потока (Thread.stop() — deprecated)
thread.stop();

// 4. Бесконечный цикл
while (true) { }

// 5. Блокировка на I/O
readBlocking();  // Если поток зависает

Вывод

Да, логика 100% выполнения строки возможна БЕЗ исключений:

1. Блок finally — выполнится в 99.9% случаев
2. Try-with-resources — закроет ресурсы гарантированно
3. AutoCloseable — кастомные ресурсы с гарантией
4. Исключения (throws) — лишь информируют об ошибке, не гарантируют выполнение

Best Practice: Используй finally и try-with-resources для cleanup кода (логирование, закрытие ресурсов, откат транзакций).