Можно ли не использовать Try Catch при наличии throws у вызываемого метода?

Можно ли не использовать Try Catch при наличии throws у вызываемого метода?

Краткий ответ

Да, можно не использовать try-catch если вы добавите throws в сигнатуру своего метода. Исключение будет пробросано вверх по стеку вызовов к вызывающему коду.

Два подхода обработки исключений

Подход 1: Перехвать исключение (try-catch)

public void readFile() {
    try {
        FileReader reader = new FileReader("file.txt");
        int data = reader.read();
        reader.close();
    } catch (FileNotFoundException e) {
        System.out.println("Файл не найден");
        e.printStackTrace();
    } catch (IOException e) {
        System.out.println("Ошибка чтения");
        e.printStackTrace();
    }
}

Подход 2: Пробросить исключение выше (throws)

public void readFile() throws FileNotFoundException, IOException {
    FileReader reader = new FileReader("file.txt");
    int data = reader.read();
    reader.close();
    // Исключение пробросится к вызывающему коду
}

Как это работает с throws

Стек вызовов исключения:

public class Application {
    public static void main(String[] args) throws Exception {
        // Уровень 3: просто пробрасываем дальше
        loadData();
    }
    
    private static void loadData() throws IOException {
        // Уровень 2: пробрасываем исключение от processFile
        processFile("data.txt");
    }
    
    private static void processFile(String filename) throws IOException {
        // Уровень 1: вызываем метод с throws
        FileReader reader = new FileReader(filename);
        reader.close();
        // IOException здесь пробросится выше на уровень 2
        // Затем на уровень 3, затем в main
    }
}

// Если вызвать это:
// Application.main(null)
// 
// 1. processFile() выбросит IOException
// 2. loadData() получит его и пробросит дальше
// 3. main() получит его и пробросит в JVM
// 4. JVM выведет stack trace в консоль

Практический пример

Без try-catch, с throws (метод не обрабатывает исключение):

public class FileProcessor {
    
    // Метод 1: пробрасывает исключение
    public static String readFile(String filename) throws IOException {
        FileReader reader = new FileReader(filename);
        StringBuilder content = new StringBuilder();
        int ch;
        while ((ch = reader.read()) != -1) {
            content.append((char) ch);
        }
        reader.close();
        return content.toString();
    }
    
    // Метод 2: вызывает метод 1 и тоже пробрасывает
    public static String getFileContent(String filename) throws IOException {
        return readFile(filename);  // Не ловим исключение!
    }
    
    // Метод 3: ДОЛЖЕН перехватить или пробросить
    public static void main(String[] args) {
        try {
            String content = getFileContent("data.txt");
            System.out.println(content);
        } catch (IOException e) {
            // Здесь мы перехватываем
            System.out.println("Ошибка при чтении файла: " + e.getMessage());
        }
    }
}

Обязательность try-catch

Правило: Если метод выбрасывает checked exception (наследник Exception, но не RuntimeException), то:

• Вызывающий код ДОЛЖЕН либо:
  1. Перехватить исключение (try-catch)
  2. Пробросить его дальше (throws)

// ❌ КОМПИЛИРУЕТСЯ ОШИБКА!
public void process() {
    FileReader reader = new FileReader("file.txt");  // IOException - checked exception
}
// Exception in thread "main": java.nio.file.FileNotFoundException: file.txt

// ✅ ВАРИАНТ 1: Перехватываем
public void process() {
    try {
        FileReader reader = new FileReader("file.txt");
    } catch (IOException e) {
        System.out.println("Обработано");
    }
}

// ✅ ВАРИАНТ 2: Пробрасываем
public void process() throws IOException {
    FileReader reader = new FileReader("file.txt");
}

Difference между Checked и Unchecked исключениями

Checked Exception (требует обработки):

public class CheckedExample {
    // IOException - checked exception
    public void readFile() throws IOException {
        FileReader reader = new FileReader("file.txt");
    }
    
    // Вызывающий код ДОЛЖЕН обработать
    public void caller() throws IOException {  // Пробрасываем
        readFile();
    }
}

Unchecked Exception (не требует обработки):

public class UncheckedExample {
    // RuntimeException - unchecked exception
    public void divide(int a, int b) {  // БЕЗ throws!
        int result = a / b;  // ArithmeticException - unchecked
    }
    
    // Вызывающий код НЕ обязан обрабатывать
    public void caller() {  // БЕЗ throws!
        divide(10, 0);  // Если выбросится - выбросится
    }
}

Что происходит если не обработать checked exception

# Компиляция:
javac FileProcessor.java
FileProcessor.java:5: error: unreported exception IOException; must be caught or declared to be thrown
    FileReader reader = new FileReader("file.txt");
    ^
1 error

# Вы не сможете даже откомпилировать код!

Практический пример: цепочка throws

public class Database {
    // Метод 1: выбросит исключение
    public static Connection getConnection(String url) throws SQLException {
        return DriverManager.getConnection(url);
    }
}

public class UserRepository {
    // Метод 2: вызывает getConnection и пробрасывает дальше
    public static User findById(int id) throws SQLException {
        Connection conn = Database.getConnection("jdbc:mysql://localhost/db");
        PreparedStatement stmt = conn.prepareStatement("SELECT * FROM users WHERE id = ?");
        stmt.setInt(1, id);
        return null;
    }
}

public class UserService {
    // Метод 3: вызывает findById и пробрасывает
    public static User getUser(int id) throws SQLException {
        return UserRepository.findById(id);
    }
}

public class UserController {
    // Метод 4: НАКОНЕЦ ловим исключение
    public void handleUserRequest(int id) {
        try {
            User user = UserService.getUser(id);
            System.out.println(user.getName());
        } catch (SQLException e) {
            System.out.println("Ошибка БД: " + e.getMessage());
            // Отправляем HTTP 500 пользователю
        }
    }
}

Best practices

1. Пробрасывайте только если вызывающий код может обработать

// ❌ ПЛОХО: просто пробрасываем Exception везде
public void process() throws Exception {
    // Это плохо, потому что Exception слишком общий
}

// ✅ ХОРОШО: пробрасываем конкретные исключения
public void process() throws IOException, SQLException {
    // Конкретные исключения
}

2. Документируйте throws в JavaDoc

/**
 * Читает содержимое файла
 * @param filename имя файла
 * @return содержимое файла
 * @throws IOException если файл не найден или ошибка при чтении
 * @throws NullPointerException если filename == null
 */
public String readFile(String filename) throws IOException {
    if (filename == null) {
        throw new NullPointerException("Filename не может быть null");
    }
    FileReader reader = new FileReader(filename);
    // ...
    return content;
}

3. Выбирайте между try-catch и throws

// Используйте throws если:
// - Вызывающий код может обработать исключение
// - Текущий метод не знает как обработать
public void loadConfig() throws IOException {
    // Пусть вызывающий код решает что делать
}

// Используйте try-catch если:
// - Вы знаете как обработать исключение
// - Обработка специфична для текущего метода
public void loadConfig() {
    try {
        // логика
    } catch (IOException e) {
        logger.warn("Config файл не найден, используем дефолт", e);
        loadDefaultConfig();
    }
}

Заключение

Вы можете не использовать try-catch если:

• Добавите throws в сигнатуру метода
• Переложите ответственность на вызывающий код

Вы должны использовать try-catch если:

• Вы знаете как обработать исключение
• Нужно восстановиться после ошибки
• Нужно залогировать ошибку

В конце цепочки вызовов (например, в main или в контроллере) исключение ВСЕГДА должно быть либо перехвачено (try-catch), либо пробрачено (throws) для обработки JVM.