chapter14. 예외

네, 그 표현은 맞습니다. 체크 예외와 런타임 예외의 본질적인 차이를 잘 설명하고 있습니다. 이를 좀 더 구체적이고 명확하게 다듬어서 작성해보겠습니다.

💻 예외

프로그램을 개발하다 보면 다양한 오류 상황을 마주치게 된다. 
이는 논리적인 문제일 수도 있고, 배열의 인덱스를 잘못 참조하는 문제일 수도 있다.

기존에는 이러한 문제를 if와 else 문을 통해 처리했다. 
하지만 이러한 방식의 단점은 프로그래머가 정확한 문제를 인지하고 일일이 해결해야 한다는 점이다.

이러한 단점을 보완하기 위해 등장한 것이 바로 예외 처리다.

💻 예외 처리

예외 처리는 앞서 배운 추상화의 일종으로 볼 수 있다. 
프로그래머가 모든 오류 상황을 세세히 알 필요 없이, 
특정 명령어와 클래스를 통해 예외 상황을 전반적으로 관리하고 처리할 수 있게 한다.

이를 통해 코드의 가독성과 유지보수성이 향상되며, 
프로그램이 예상치 못한 오류로 인해 비정상적으로 종료되는 것을 방지할 수 있다.

자바에서 예외 처리는 try, catch, finally 블록과 throw, throws 키워드를 사용하여 구현한다. 
try 블록에는 예외가 발생할 수 있는 코드를 작성하고, catch 블록에서는 해당 예외를 처리한다. 
finally 블록은 예외 발생 여부와 관계없이 항상 실행되는 코드를 포함한다. 
throw 키워드는 명시적으로 예외를 발생시키는 데 사용되고, 
throws 키워드는 메서드가 특정 예외를 던질 수 있음을 선언한다.

📖 try-catch

예외 처리를 위해 try-catch 문을 사용한다.

try 블록에서는 예외가 발생할 만한 구간을 감싸고,
catch 블록에서는 예외가 발생하면 실행할 문장을 넣는다.

배열의 범위를 잘못 사용할 때를 예로 들어보자:

public class ExceptionPrac {
    public static void main(String[] args) {
        int[] arr = new int[5];

        try {
            System.out.println(arr[5]);
        } catch (Exception e) {
            System.out.println("배열의 범위를 벗어났습니다.");
        }
    }
}

다음과 같이 배열의 범위를 벗어나게 사용하면:

사진과 같은 결과가 나오게 된다.

보다시피, try 블록에서 예외가 발생하여 catch 블록 내부의 문장이 실행되었다.

📖 finally

finally는 무슨 일이 있어도 실행되는 블록이다.

try-catch에서 어떤 것이 실행되든 
finally는 무조건 실행된다.

public class ExceptionPrac {
    public static void main(String[] args) {
        int[] arr = new int[5];

        try {
            System.out.println(arr[5]);
        } catch (Exception e) {
            System.out.println("배열의 범위를 벗어났습니다.");
        } finally {
            System.out.println("얘는 무조건 실행해야해");
        }
    }
}

📖 catch 중첩

catch 블록에 Exception e라고 적힌 것을 볼 수 있다.

중괄호 내부에는 예외의 종류를 쓰며, Exception은 예외의 종류를 나타내는 "클래스"이다.

Exception 클래스의 계층도는 다음과 같다:

Throwable 객체가 에러와 예외 처리를 다루는 최상위 클래스이며,
Exception은 처리 가능한 예외를,
Error는 프로그램에서 복구할 수 없는 상황을 다룬다.

Exception 클래스의 자식 클래스들은 다양한 상황에 대응된다.

catch로 다시 넘어와서 try는 한번만 사용해야 하지만 catch는 여러 번 사용할 수 있다.
이것은 다양한 예외 클래스가 존재하기 때문이다.

public class ExceptionPrac {
    public static void main(String[] args) {
        int[] arr = new int[5];

        try {
            System.out.println(arr[5]);
        } catch (Exception e) {
            System.out.println("배열의 범위를 벗어났습니다.");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("ArrayIndexOutOfBoundsException");
        } finally {
            System.out.println("얘는 무조건 실행해야해");
        }
    }
}

위 코드에서는 catch 블록을 중첩해서 사용할 수 있을 것 같지만 오류가 발생한다.

이는 클래스의 계층도와 관련이 있다.

Exception 클래스는 모든 예외의 최상위 계층이다.
따라서 Exception은 예외에 대한 모든 상황을 다룬다.
그러므로 Exception으로 이미 해결 가능한데 뒤에 다른 예외를 덧붙일 필요가 없다.

public class ExceptionPrac {
    public static void main(String[] args) {
        int[] arr = new int[5];

        try {
            System.out.println(arr[5]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("ArrayIndexOutOfBoundsException");
        } catch (Exception e) {
            System.out.println("배열의 범위를 벗어났습니다.");
        } finally {
            System.out.println("얘는 무조건 실행해야해");
        }
    }
}

순서를 바꿔 쓰면 문제 없이 실행되며,

첫 번째 catch가 실행된다.

📖 예외의 종류

예외의 종류는 총 3가지이다.

1. Error
2. Checked Exception
3. Runtime Exception (Unchecked Exception 이라고도 함)

<Error>
자바 프로그램 밖에서 발생한 문제로, 시스템 레벨에서 발생하는 심각한 문제를 의미한다.
예를 들어, 디스크 고장, 메모리 부족 등의 하드웨어나 시스템 오류가 있다.
프로그램에서 이러한 오류를 예측하거나 복구하기 어렵다.

<Checked Exception>
컴파일 시점에서 예외 처리 여부를 검사하는 예외로, 반드시 예외 처리를 해야 한다.
파일 입출력이나 네트워크 연결 시 발생할 수 있는 예외가 이에 해당한다.
예를 들어, `IOException`, `SQLException` 등이 있다.

<Runtime Exception (Unchecked Exception)>
실행 시점에서 발생하는 예외로, 프로그램의 논리적 오류나 잘못된 입력으로 인해 발생한다.
예를 들어, 잘못된 값을 입력하거나, 배열의 인덱스를 벗어나는 경우가 이에 해당한다.
예를 들어, `NullPointerException`, `ArrayIndexOutOfBoundsException` 등이 있다.

*** 배열은 왜?
배열에 대한 예외는 반복문과 변수를 통한 인덱스 접근이 사용 중에 결정되기 때문에 컴파일 시점에 예측하기 어렵다.
따라서 배열 인덱스를 초과하는 접근은 런타임에 검출된다.

또한, 크기가 고정된 배열에 대해 명확히 알 수 있는 인덱스 초과 예외
(예: 5칸 짜리 배열에 arr[6]으로 접근)는 컴파일러가 감지할 수 있지만,
자바는 일관성을 유지하기 위해 모든 배열 인덱스 초과 예외를 런타임 예외로 처리한다.

💻 Throwable 클래스

The Throwable class is the superclass of all errors and exceptions in the Java language.

📖 기능

<생성자>

- Throwable()
- Throwable(String message) : 예외에 대한 구체적인 상황을 설명
- Throwable(Throwable cause) : 예외에 원인을 넘겨줌
- Throwable(String message, Throwable cause)

<매소드>
가장 많이 사용되는 3가지만 알아보자

1. getMessange()
- 예외 메시지를 제공받는다. 예외 출력 시 어떤 예외가 발생했는지 확인하기 유용하다.
- 생성자 호출 시 넘겨준 message를 반환한다.

2. toString()
- getMessage처럼 예외 메시지를 돌려받지만 추가적으로 예외 클래스 이름도 제공한다.

3. printStackTrace()
- 가장 첫 줄에 예외 메시지 출력 후 두 번째부터 예외가 발생하게 된 메서드들의 호출 관계를 출력해준다.

📄 예시

package chapter14;

public class ThrowablePrac {
    public static void

 main(String[] args) {
        try {
            methodThatThrowsException();
        } catch (Exception e) {
            System.out.println("Exception caught(use getMessage): " + e.getMessage());
            System.out.println("Exception caught(use toString): " + e.toString());
            e.printStackTrace();
        }
    }

    public static void methodThatThrowsException() throws Exception {
        throw new Exception("Custom error message");
    }
}

이런 코드가 있다고 해보자.

실행 시 이런 문장이 출력되며

e.printStackTrace에서는 문제가 발생한 메서드와 호출된 구간이 나온다.

📖 throw와 throws

throw는 예외를 발생시킨다.
throw new 예외상황 으로 쓰며
원하는 조건을 특정한 예외로 포함(던진다)시킨다.

public class throwAndThrows {
    public static void main(String[] args) {
        throwAndThrows sample = new throwAndThrows();

        sample.throwException(7);
        sample.throwException(13);
    }

    public void throwException(int number) {
        try {
            if (number > 12) {
                throw new Exception("Number is over than 12!");
            } // 이제 숫자가 12보다 큰 것은 Exception에 포함된다.

            System.out.println("Number is " + number);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

위 코드에서처럼 사용하며 12가 넘어갈 때는 Exception으로 처리된다.
그렇기에 catch로 바로 넘어가 오류 구문을 출력한다.

이처럼 원하는 상황을 "예외"로 만들어 처리가 가능하다.

"예외"로 만든 상황을 처리할 때는
1. 내가 직접 처리한다.
2. 나를 호출한 상위 메서드에 넘겨준다.

이 두 가지로 다룬다.
내가 직접 해결할 때는 try-catch를 통해 해당 메서드 내에서 해결한다.

하지만 만약 상위 메서드에서 처리를 하게 한다면 throws를 통해 넘겨줘야 한다.

throws는 메서드 이름 옆에 붙으며 이 메서드는 예외를 발생시키니 잘 처리해서 쓰세요라는 뜻을 가지고 있다.

예를 들어보자

public class throwAndThrows {
    public static void main(String[] args) {
        throwAndThrows sample = new throwAndThrows();

        try {
            sample.test2();
        } catch (Exception e) {
            System.out.println("test1에서 발생한 예외가 test2를 거쳐 처리됩니다.");
        }
    }

    public void test1() throws Exception {
        throw new Exception("예외를 발생시켜 상위 메서드로 넘깁니다.");
    }

    public void test2() throws Exception {
        test1(); // test1을 호출하지만 직접 해결할 능력이 없어 더 상위로 넘겨줍니다.
    }
}

아래와 같이 사용하는데 원하는 상황을 예외로 만들었지만
내가 처리하지 못할 때 throws를 통해 상위 메서드로 넘겨준 후 상위 메서드에서 try-catch로 처리한다.

📖 내가 만드는 예외

throw와 throws는 이미 존재하는 예외에 내가 원하는 조건을 추가하는 것이다.
하지만 이것 말고도 내가 원하는 예외 상황을 만들 수도 있다.
즉, 새로운 예외 class를 만들 수 있다.

앞서 Throwable 클래스에는 Exception과 Error라는 자식 클래스가 존재한다고 했다.

이중 Error 클래스는 사용자가 손을 대면 안 된다.
Error가 아닌 Exception 클래스는 개발자가 임의로 추가할 수 있다.

public class MyException extends Exception {
    public MyException() {
        super();
    }

    public MyException(String message) {
        super(message);
    }
}

public class CustomExceptionPrac {
    public static void main(String[] args) {
        CustomExceptionPrac sample = new CustomExceptionPrac();

        try {
            sample.throwMyException();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void throwMyException() throws MyException {
        throw new MyException("Custom exception message");
    }
}

위처럼 예외를 상속받은 클래스를 호출하여 사용 가능하다.

장점으로는
1. 좀 더 명확하게 의사 전달이 가능하다.
2. 구체적인 예외 처리가 가능하다.

등이 있다.

💻 Runtime vs Checked

자바에서는 예외를 두 가지 주요 범주로 나눈다: 
Checked Exception(체크 예외)와 Runtime Exception(런타임 예외). 
이 두 가지 예외는 처리 방식과 사용 목적이 다르다.

📖 체크 예외 (Checked Exception)

체크 예외는 컴파일 시점에서 예외 처리 여부를 검사하는 예외다. 
이러한 예외는 반드시 예외 처리를 해야 한다. 파일 입출력이나 네트워크 연결 시 발생할 수 있는 예외가 이에 해당한다. 
`IOException`, `SQLException` 등이 있다.

체크 예외는 메서드 선언부에 `throws` 키워드를 사용하여 선언해야 한다. 
이는 메서드를 호출하는 쪽에서 해당 예외를 반드시 처리해야 한다는 것을 의미한다. 
이러한 예외는 주로 외부 자원과의 상호작용에서 발생할 수 있는 오류를 처리하는 데 사용된다.

📖 런타임 예외 (Runtime Exception)

런타임 예외는 실행 시점에서 발생하는 예외로, 프로그램의 논리적 오류나 잘못된 입력으로 인해 발생한다. 
예를 들어, 잘못된 값을 입력하거나, 배열의 인덱스를 벗어나는 경우가 이에 해당한다. 
`NullPointerException`, `ArrayIndexOutOfBoundsException` 등이 있다.

런타임 예외는 메서드 선언부에 `throws` 키워드를 사용하여 선언하지 않아도 된다. 
예외 처리를 강제하지 않으므로, 필요한 경우에만 `try-catch` 블록을 사용하여 처리한다. 
이는 주로 프로그래밍 오류나 논리적 오류를 처리하는 데 사용된다.

📖 체크 예외와 런타임 예외의 비교

체크 예외는 외부 자원과의 상호작용에서 발생할 수 있는 오류를 처리하기 위해 사용되며, 
반드시 예외 처리를 해야 한다. 
반면, 런타임 예외는 프로그램의 논리적 오류를 처리하기 위해 사용되며, 예외 처리를 강제하지 않는다.

체크 예외는 예외 발생 가능성이 높은 외부 자원 접근 코드에서 사용하고,
런타임 예외는 논리적 오류를 처리하기 위해 사용한다. 
이를 통해 코드의 가독성과 유지보수성을 향상시키고, 예외 상황을 보다 효과적으로 처리할 수 있다.

요약

체크 예외와 런타임 예외는 각각의 사용 목적과 처리 방식이 다르다. 
체크 예외는 컴파일 시점에서 예외 처리 여부를 검사하며, 반드시 예외 처리를 해야 한다. 
런타임 예외는 실행 시점에서 발생하며, 예외 처리를 강제하지 않는다.