TIL - 2025.02.27

[Yumi-Park996]

Java에서 예외 처리는 프로그램의 안정성과 신뢰성을 높이기 위해 필수적인 요소입니다. 아래에서는 try-catch-finally 구문, finally 블록의 동작 방식에 대해 자세히 설명하겠습니다.

1. try-catch-finally 구문

try-catch-finally 구문은 예외가 발생할 수 있는 코드 블록을 정의하고, 발생한 예외를 처리하며, 예외 발생 여부와 관계없이 항상 실행되어야 하는 코드를 지정하는 구조입니다.

구문 구조:

try {
    // 예외가 발생할 수 있는 코드
} catch (ExceptionType1 e1) {
    // ExceptionType1에 대한 예외 처리
} catch (ExceptionType2 e2) {
    // ExceptionType2에 대한 예외 처리
} finally {
    // 예외 발생 여부와 상관없이 항상 실행되는 코드
}

• try 블록: 예외가 발생할 수 있는 코드를 포함합니다.
• catch 블록: try 블록에서 발생한 특정 예외를 처리합니다. 여러 개의 catch 블록을 사용하여 다양한 예외를 처리할 수 있습니다.
• finally 블록: 예외 발생 여부와 상관없이 항상 실행되는 코드를 포함합니다. 주로 리소스 해제나 정리 작업에 사용됩니다.

예제:

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
            System.out.println("결과: " + result);
        } catch (ArithmeticException e) {
            System.out.println("산술 예외 발생: " + e.getMessage());
        } finally {
            System.out.println("프로그램 종료");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

출력:

산술 예외 발생: / by zero
프로그램 종료

위 예제에서 divide 메서드는 0으로 나누기를 시도하여 ArithmeticException을 발생시킵니다.
이 예외는 catch 블록에서 처리되며, finally 블록은 예외 발생 여부와 상관없이 항상 실행되어 "프로그램 종료"를 출력합니다.

---

2. finally 블록이 return 값을 덮어쓰는 경우

finally 블록은 try 또는 catch 블록에서 return 문이 실행되더라도 반드시 실행됩니다. 만약 finally 블록 내에서 return 문을 사용하면, 이전의 return 값이나 예외를 덮어쓰게 되어 예상치 못한 동작을 초래할 수 있습니다.

예제:

public class FinallyReturnExample {
    public static void main(String[] args) {
        System.out.println("결과: " + testMethod());
    }

    public static int testMethod() {
        try {
            return 1;
        } catch (Exception e) {
            return 2;
        } finally {
            return 3;
        }
    }
}

출력:

결과: 3

위 예제에서 try 블록에서 return 1;이 실행되더라도, finally 블록의 return 3;이 최종적으로 실행되어 메서드는 3을 반환합니다.
이러한 동작은 코드의 가독성과 유지보수성을 해치므로, finally 블록 내에서 return 문을 사용하는 것은 권장되지 않습니다.

[Yumi-Park996]

관련 코드

import java.util.Random;

public class Solution01 {
    public static void main(String[] args) {
        // System.out.println(number); // 문법상 허용되지 않음 (변수가 선언되기 전에 사용 불가능)
        // Java는 변수 호이스팅(hoisting)을 지원하지 않음

        try {
            int number = 10;
            // JavaScript에서는 오류가 있어도 실행이 계속될 수 있지만, Java에서는 오류 발생 시 예외가 발생하여 프로그램이 종료됨
            // System.out.println(number / 0); // 0으로 나누는 연산 -> ArithmeticException 발생

            // throwRandom() 메서드 실행 -> 내부적으로 예외가 발생할 가능성이 있음
            System.out.println(throwRandom());

        } catch (Exception e) { // 모든 예외를 포괄적으로 처리할 수 있음
            e.printStackTrace(); // 발생한 예외의 스택 트레이스를 출력하여 디버깅할 수 있도록 함
        } finally {
            System.out.println("어쨌든 실행이 된다");
            // finally 블록은 예외 발생 여부와 관계없이 무조건 실행됨
        }

        System.out.println("도달할 수 있나?");
        // 예외가 발생하더라도 catch 블록에서 처리되었기 때문에 프로그램이 정상적으로 실행됨
    }

    static double throwRandom() { 
        // 클래스 메서드(static) -> 객체를 생성하지 않고 직접 호출 가능

        Random random = new Random();
        double result = random.nextDouble(); // 0.0 이상 1.0 미만의 난수를 생성

        try {
            if (result > 0.5) { 
                // result가 0.5보다 크면 예외를 강제로 발생시킴 (0으로 나누기)
                int error = 10 / 0;
            }
            return result; // 예외가 발생하지 않으면 result 값을 반환
        } catch (Exception e) {
            e.printStackTrace();
            result = -1; // 예외 발생 시 result 값을 -1로 설정
        } finally {
            if (result == -1) { 
                result = 9999; // 예외가 발생하면 result를 9999로 변경
            } else {
                result *= 1_000_000; // 예외가 발생하지 않으면 result를 100만 배 증가
            }
            return result; // finally 블록에서 값을 반환 -> try 또는 catch에서 설정한 return 값을 덮어씀
        }

        // return result; // 이 코드는 도달할 수 없음 (finally에서 return이 실행되므로)
    }
}

[Yumi-Park996]

1. throws

throws는 메서드가 예외를 발생시킬 가능성이 있음을 호출하는 쪽에 명확히 알리고, 예외 처리를 상위 메서드에서 하도록 위임하는 역할을 한다.

1. 예외 발생 가능성을 명시

• throws가 없으면 메서드를 호출하는 개발자는 예외 발생 가능성을 모를 수 있음
• throws를 사용하면 메서드 선언부에서 바로 예외 발생 가능성을 알 수 있음

예제 (throws 없는 경우)

public void readFile() {
    File file = new File("data.txt");
    Scanner scanner = new Scanner(file); // FileNotFoundException 발생 가능
}

• 문제점 → readFile()을 호출하는 개발자는 예외 발생 가능성을 코드 내부를 봐야 알 수 있음

```java
public void readFile() throws FileNotFoundException {
    File file = new File("data.txt");
    Scanner scanner = new Scanner(file);
}

• 해결 → throws FileNotFoundException을 보면 예외 발생 가능성을 바로 알 수 있음
• 코드 가독성 + 유지보수성 향상

---

2. 예외를 상위 메서드에서 한 번에 처리 가능

• throws 없이 try-catch를 모든 메서드에서 사용하면 불필요한 중복 발생
• throws를 사용하면 상위 메서드에서 예외를 한 번에 처리 가능

예제 (throws 없이 try-catch 중복)

public void readFile() {
    try {
        File file = new File("data.txt");
        Scanner scanner = new Scanner(file);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }
}

public void processFile() {
    readFile(); // 예외가 이미 처리됨
}

• 문제점 → readFile()에서 예외를 처리하면, processFile()에서 예외를 상세히 다룰 수 없음

예제 (throws 사용하여 상위 메서드에서 처리)

public void readFile() throws FileNotFoundException {
    File file = new File("data.txt");
    Scanner scanner = new Scanner(file);
}

public void processFile() {
    try {
        readFile(); // `readFile()`이 던진 예외를 여기서 처리
    } catch (FileNotFoundException e) {
        System.out.println("파일을 찾을 수 없습니다.");
    }
}

• 해결 → 예외를 한 곳에서만 처리하여 중복 제거 & 유지보수 편리

---

3. 체크 예외(Checked Exception)에 대한 강제 예외 처리

Java에서는 체크 예외(Checked Exception)와 언체크 예외(Unchecked Exception)가 있다.

• 체크 예외 (Checked Exception): 반드시 예외 처리를 해야 하는 예외 (IOException, SQLException, FileNotFoundException 등)
• 언체크 예외 (Unchecked Exception): 예외 처리를 강제하지 않는 예외 (NullPointerException, ArithmeticException 등)
  throws는 체크 예외를 다룰 때 필수적으로 사용됨.

체크 예외(Checked Exception) 예제

public void readFile() throws IOException {
    FileReader reader = new FileReader("data.txt"); // IOException 발생 가능
}

• IOException은 체크 예외이므로 반드시 처리해야 함.
• throws IOException을 명시하면 이 메서드를 호출하는 쪽에서 반드시 try-catch를 써야 함.

언체크 예외(Unchecked Exception) 예제

public void divide(int a, int b) {
    int result = a / b; // 0으로 나누면 ArithmeticException 발생
}

• ArithmeticException은 언체크 예외이므로 throws가 없어도 됨.
• 이런 예외는 강제적으로 예외 처리를 할 필요가 없음.

결론:

• throws는 체크 예외가 발생하는 메서드를 사용할 때 반드시 예외 처리를 하도록 강제하는 역할을 함.
• throws가 없다면 체크 예외가 있는 메서드를 사용할 때 개발자가 예외 처리를 빠뜨릴 수도 있음.

---

try-with-resources

1. try-with-resources란?
Java 7에서 도입된 기능으로, 자원을 자동으로 해제(닫아주는) 기능을 제공하는 try 문.
**자원(resource)**이란? → 파일, 네트워크 연결, 데이터베이스 연결 등 close()가 필요한 객체
(예: FileInputStream, BufferedReader, Socket 등)
try 블록이 끝날 때 close()를 자동으로 호출하기 때문에 finally에서 수동으로 close()를 호출할 필요 없음.

---

2. try-catch-finally와 try-with-resources 비교

• 기존 try-catch-finally 방식 (자원 수동 해제)

import java.io.*;

public class TryCatchFinallyExample {
    public static void main(String[] args) {
        BufferedReader br = null;
        try {
            br = new BufferedReader(new FileReader("data.txt"));
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (br != null) { // NullPointerException 방지
                    br.close(); // 반드시 닫아줘야 함
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

• try-with-resources 방식 (자원 자동 해제)

import java.io.*;

public class TryWithResourcesExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("data.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } 
        // finally 불필요! 자동으로 close()가 호출됨
    }
}

---

3. try-with-resources와 try-catch-finally의 차이점

구분	try-catch-finally	try-with-resources
자원 해제 방식	finally에서 명시적으로 close() 호출 필요	자동으로 close() 호출
예외 처리	예외 발생 시 finally 블록에서 close() 처리 필요	try 블록이 끝나면 자동으로 close() 호출
코드 길이	길고 복잡할 수 있음	간결하고 직관적
예외 발생 시 자원 해제	catch 블록에서 예외 발생하면 finally에서 close() 호출 필요	catch 블록 실행 여부와 관계없이 try 블록 종료 시 자동 close() 호출
사용 가능 자원	Closeable 또는 AutoCloseable을 구현한 객체	Closeable 또는 AutoCloseable을 구현한 객체

---

4. try-with-resources 사용 조건

• try() 안에 선언된 객체는 반드시 AutoCloseable 또는 Closeable 인터페이스를 구현해야 함.
• AutoCloseable 인터페이스를 구현하면 close() 메서드가 자동 호출됨.

class CustomResource implements AutoCloseable {
    @Override
    public void close() {
        System.out.println("CustomResource가 자동으로 닫혔습니다.");
    }
}

public class AutoCloseableExample {
    public static void main(String[] args) {
        try (CustomResource cr = new CustomResource()) {
            System.out.println("리소스를 사용 중...");
        }
    }
}

출력 결과

리소스를 사용 중...
CustomResource가 자동으로 닫혔습니다.

---

5. try-with-resources가 더 나은 이유

• 자동으로 자원 해제 → close()를 직접 호출할 필요 없음.
• 코드가 간결하고 유지보수하기 쉬움 → finally 블록 불필요.
• 예외 발생 시에도 자원이 자동 해제됨 → catch 블록이 실행되든 안 되든 close()는 실행됨.
• 여러 개의 자원을 한 번에 선언 가능 → try (A; B; C) 형식으로 여러 리소스를 선언할 수 있음.

try (
    FileInputStream fis = new FileInputStream("input.txt");
    BufferedReader br = new BufferedReader(new InputStreamReader(fis))
) {
    System.out.println(br.readLine());
} catch (IOException e) {
    e.printStackTrace();
}

FileInputStream과 BufferedReader 모두 자동으로 닫힘.

[Yumi-Park996]

관련 코드

import java.io.File; // 파일을 다루기 위한 File 클래스 임포트
import java.io.IOException; // 입출력 예외 처리를 위한 IOException 클래스 임포트
import java.util.Scanner; // 파일 내용을 읽기 위한 Scanner 클래스 임포트

public class Solution02 {
    public static void main(String[] args) throws IOException {
        // main 메서드에서 IOException을 던질 수 있도록 선언
        // (파일 입출력 작업 중 예외가 발생할 가능성이 있기 때문)

        // File 객체 생성 (파일의 경로와 이름을 지정)
        File file = new File("number.txt");

        // 파일이 존재하는지 확인하고, 존재하지 않으면 새 파일을 생성
        if (!file.exists()) {
            file.createNewFile(); // 파일 생성 중 오류가 발생하면 IOException을 던짐

        // ** 기존의 try-catch-finally 방식 (주석 처리된 부분) **
        /*
        Scanner sc = null; // Scanner 객체를 선언 (초기값은 null)
        try {
            sc = new Scanner(file); // 파일을 읽기 위한 Scanner 객체 생성
            while (sc.hasNextInt()) { // 파일에 정수 값이 있는지 확인
                int n = sc.nextInt(); // 파일에서 정수를 읽어 변수 n에 저장
                System.out.println(n); // 읽은 정수를 출력
            }
            System.out.println("끝"); // 모든 숫자를 읽고 나면 "끝"을 출력

            sc.close(); // Scanner 닫기 (예외 발생 시 이 구문이 실행되지 않을 가능성이 있음)
        } catch (Exception e) { // 예외 발생 시 처리
            e.printStackTrace(); // 예외 내용을 출력 (어떤 예외가 발생했는지 확인 가능)
        } finally { // try 블록 실행 후 반드시 실행되는 블록
            try {
                sc.close(); // Scanner를 닫음 (리소스 해제), 위에서 error로 인해 scanner가 안닫혔을 수도 있어서
            } catch (Exception e) { // Scanner가 null이면 NullPointerException 발생 가능하기 때문에 catch문 추가
                e.printStackTrace(); // 예외 내용을 출력
            }
        }
        */

        // ** Java 7 이후 try-with-resources 방식 (권장되는 방식) **
        try (Scanner sc = new Scanner(file)) {
            // try-with-resources 구문: try 블록이 끝날 때 자동으로 Scanner가 닫힘
            // (finally 블록에서 수동으로 닫을 필요 없음)

            while (sc.hasNextInt()) { // 파일에 정수 값이 있는지 확인
                int n = sc.nextInt(); // 파일에서 정수를 읽어 변수 n에 저장
                System.out.println(n); // 읽은 정수를 출력
            }
            System.out.println("끝"); // 모든 숫자를 읽고 나면 "끝"을 출력
        } catch (Exception e) { // 예외 발생 시 처리
            e.printStackTrace(); // 예외 내용을 출력 (어떤 예외가 발생했는지 확인 가능)
        }
    }
}