해당 글을 백기선 님의 자바 스터디 9주차 과제를 공부하고 공유하기 위해서 작성되었습니다.

목표

자바의 예외 처리에 대해 학습한다.

학습할 것

자바에서 예외 처리 방법
자바가 제공하는 예외 계층 구조
Exception과 Error의 차이는?
RuntimeException과 RE가 아닌 것의 차이는?
커스텀한 예외 만드는 방법

자바에서 예외 처리 방법

프로그램이 실행 중 어떤 원인에 의해서 오작동을 하거나 비정상적으로 종료되는 경우가 있다. 이러한 결과를 초래하는 원인을 프로그램 에러 또는 오류라고 한다.

이를 발생시점에 따라 컴파일 에러(compile-time error)와 런타임 에러(runtime error)로 나눌 수 있다.
컴파일 에러는 컴파일 할 때 발생하는 에러를 말하고 런타임 에러는 프로그램의 실행도중에 발생하는 에러를 말한다. 이 외에 논리적 에러(logical error)가 있는데, 컴파일도 잘되고 실행도 잘되지만 의도한 것과 다르게 동작하는 것을 말한다.

컴파일 에러 컴파일 시에 발생하는 에러
런타임 에러 실행 시에 발생하는 에러
논리적 에러 실행은 되지만, 의도와 다르게 동작하는 것

기본적으로 소스코드를 컴파일 하면 컴파일러가 소스코드(*.java)에 대해 오타나 잘못된 구문, 자료형 체크등의 기본적인 검사를 수행하여 오류가 있는지 알려준다. 컴파일러가 알려준 에러들을 모두 수정해서 컴파일을 성공적으로 마치고 나면, 클래스 파일(*.class)이 생성되고, 생성된 클래스 파일을 실행할 수 있게 되는 것이다.

하지만 컴파일이 에러없이 성공적으로 마쳤다고 해서 실행 시 에러가 발생하지 않는다는 보장은 없다. 컴파일러가 소스코드의 기본적인 사항은 컴파일 시에 모두 걸러 줄 수 있지만, 실행 중에 발생할 수 있는 잠재적인 오류까지 검사할 수 없기 때문이다.

예외 처리(exception handling)

예외 처리(exception handling)란, 프로그램 실행 시 발생할 수 있는 예기치 못한 예외의 발생에 대비한 코드를 작성하는 것이다. 예외처리의 목적은 예외의 발생으로 인한 실행 중인 프로그램의 비정상 종료를 막고, 정상적인 실행상태를 유지할 수 있도록 하는 것이다.

예외처리(exception handling)의
- 정의 - 프로그램 실행 시 발생할 수 있는 예외에 대비한 코드를 작성하는 것
- 목적 - 프로그램의 비정상 종료를 막고, 정상적인 실행상태를 유지하는 것

발생한 예외를 처리하지 못하면, 프로그램은 비정상적으로 종료되며, 처리되지 못한 예외(uncaught exception)는 JVM의 예외처리기(UncaughtExceptionHandler)가 받아서 예외의 원인을 출력한다.

try-catch문

예외를 처리하기 위해서는 try-catch문을 사용하며, 구조는 다음과 같다.

    try {
        // 예외가 발생할 가능성이 있는 문장들
    } catch (Exception1 e1) {
        // Exception1이 발생햇을 경우, 이를 처리하는 문장
    } catch (Exception2 e2) {
        // Exception2가 발생햇을 경우, 이를 처리하는 문장
    } catch (Exception3 e3) {
        // Exception3이 발생했을 경우, 이를 처리하는 문장
    }

하나의 try블럭 다음에는 여러 종류의 예외를 처리할 수 있도록 하나 이상의 catch블럭이 올 수 있으며, 이 중 발생한 예외의 종류와 일치하는 단 한 개의 catch블럭만 수행된다.

    class App {
        public static void main(String[] args) {
            try {
                try { } catch (Exception e) { }
            } catch (Exception e) {
                try { } catch (Exception e) { } // 에러. 변수 e가 중복.
            } // try-catch 끝

            try {

            } catch (Exception e) {

            } // try-catch 끝
        }
    }

이 예제는 아무 일도 발생하지 않는다. 예제에서 알 수 있듯이 하나의 메서드 내에 여러 개의 try-catch문이 사용될 수 있으며, try블럭 또는 catch블럭에 또 다른 try-catch문이 포함될 수 있다.
catch블럭의 괄호 내에 선언된 변수는 catch블럭 내에서만 유효하기 때문에 위의 모든 catch블럭에 참조변수 e 하나 만을 사용해도 된다.

그러나 catch블럭 내에 또 하나의 try-catch문이 포함된 경우, 같은 이름의 참조변수를 사용해서는 안 된다. 각 catch블럭에 선언된 두 참조변수의 영역이 서로 겹치므로 다른 이름을 사용해야만 서로 구별되기 때문이다.

try-catch문에서의 흐름

try-catch문에서, 예외가 발생한 경우와 발생하지 않았을 때의 흐름이 달라진다.

▶try블럭 내에서 예외가 발생하지 않은 경우,

catch블럭을 거치지 않고 전체 try-catch문을 빠져나가서 수행을 계속한다.

class App {
    public static void main(String[] args) {
        System.out.println(1);
        System.out.println(2);
        try {
            System.out.println(3);
            System.out.println(4);
        } catch (Exception e) {
            System.out.println(5);
        }
        System.out.println(6);
    }
}

▶try블럭 내에서 예외가 발생한 경우,

발생한 예외와 일치하는 catch블럭이 있는지 확인한다.
일치하는 catch블럭을 찾게 되면, 그 catch블럭 내의 문장들을 수행하고 전체 try-catch문을 빠져나가서 그 다음 문장을 계속해서 수행한다. 만일 일치하는 catch블럭을 찾지 못하면, 예외는 처리되지 못한다.

class App {
    public static void main(String[] args) {
        System.out.println(1);
        System.out.println(2);
        try {
            System.out.println(3);
            System.out.println(0/0); // 고의로 ArithmeticException을 발생
            System.out.println(4);
        } catch (Exception e) {
            System.out.println(5);
        }
        System.out.println(6);
    }
}

이처럼 try블럭에서 예외가 발생하면, 예외가 발생한 위치 이후에 있는 try블럭의 문장들은 수행되지 않으므로, try블럭에 포함시킬 코드의 범위를 잘 선택해야한다.

catch블럭

catch블럭은 괄호( )와 블럭{ } 두 부분으로 나눠져 있는데, 괄호 내에는 처리하고자 하는 예외와 같은 타입의 참조변수 하나를 선언해야한다.

예외가 발생하면, 발생한 예외에 해당하는 클래스의 인스턴스가 만들어진다. 예를 들어 ArithmeticException이 발생했다면 ArithmeticException인스턴스가 생성된다. 예외가 발생한 문장이 try블럭에 포함되어 있다면, 이 예외를 처리할 수 있는 catch블럭이 있는지 찾게된다.

첫 번째 catch블럭부터 차례로 내려가면서 catch블럭의 괄호 내에 선언된 참조변수의 종류와 생성된 예외클래스의 인스턴스에 instanceof연산자를 이용해서 검사하게 되는데, 검사결과가 true인 catch블럭을 만날 때까지 검사는 계속된다.
검사결과가 true인 catch블럭을 찾게 되면 블럭에 있는 문장들을 모두 수행한 후에 try-catch문을 빠져나가고 예외는 처리되지만, 검사결과가 true인 catch블럭이 하나도 없으면 예외는 처리되지 않는다.

모든 예외 클래스는 Exception클래스의 자손이므로, catch블럭의 괄호에 Exception클래스 타입의 참조변수를 선언해 놓으면 어떤 종류의 예외가 발생하더라도 이 catch블럭에 의해서 처리된다.

class App {
    public static void main(String[] args) {
        System.out.println(1);
        System.out.println(2);
        try {
            System.out.println(3);
            System.out.println(0/0);
            System.out.println(4);
        } catch (ArithmeticException ae) {
            if(ae instanceof ArithmeticException)
              System.out.println("true");
            System.out.println("ArithmeticException");
        } catch (Exception e) {
            System.out.println("Exception");
        }
        System.out.println(6);
    }
}

try블럭에서 ArithmeticException이 발생하였으므로 catch블럭을 하나씩 차례로 검사하게 되는데, 첫 번째 검사에서 일치하는 catch블럭을 찾았기 때문에 두 번째 catch블럭은 검사하지 않았다. 만일 ArithmeticException이 아닌 다른 종류의 에러가 발생한 경우에는 두 번째 catch블럭인 Exception클래스 타입의 참조변수를 선언한 곳에서 처리되었을 것이다.

printStackTrace()와 getMessage()

예외가 발생했을 때 생성되는 예외 클래스의 인스턴스에는 발생한 예외에 대한 정보가 담겨져 있으며, getMessage()와 printStackTrace()를 통해서 이 정보들을 얻을 수 있다.

catch블럭의 괄호에 선언된 참조변수를 통해 이 인스턴스에 접근할 수 있으며, 이 참조변수는 선언된 catch블럭 내에서만 사용 가능하다.

printStackTrace()
- 예외 발생 당시의 호출스택(Call Stack)에 있었던 메서드의 정보와 예외 메시지를 화면에 출력한다.
getMessage()
- 발생한 예외클래스의 인스턴스에 저장된 메시지를 얻을 수 있다.

멀티 catch블럭

JDK 1.7부터 여러 catch블럭을 |기호를 이용해서, 하나의 catch블럭으로 합칠 수 있게 되었다. 이러한 형태를 ‘멀티 catch블럭’이라 한다. 이 때 사용되는 |기호는 논리 연산자가 아니라 기호이며, 연결할 수 있는 예외 클래스의 개수에는 제한이 없다.

    try {
        ...
    } catch (ExceptionA e) {
        e.printStackTrace();
    } catch (ExceptionB e2) {
        e2.printStackTrace();
    }

    try {
        ...
    } catch (ExceptionA | ExceptionB e) {
        e.printStackTrace();
    }

만일 멀티 catch 블럭의 기호로 연결된 예외 클래스가 조상과 자손의 관계에 있다면 컴파일 에러가 발생한다.

    try {
        ...
    } catch (ParentException | ChildException e) { // 에러!
        e.printStackTrace();
    }

두 예외 클래스가 조상과 자손의 관계라면, 조상클래스만 써주는 것과 똑같기 때문에 불필요한 코드를 제거하라는 의미에서 에러가 발생한다.

    try {
        ...
    } catch (ParentException e) {
        e.printStackTrace();
    }

예외 발생시키기

키워드 throw를 사용해서 예외를 고의로 발생시킬 수 있다.

연산자 new를 이용해 발생시키려는 예외 클래스의 객체를 만든다.
Exception e = new Exception(“예외 발생”);
키워드 throw를 이용해서 예외를 발생시킨다.
throw e;

class App {
    public static void main(String[] args) {
        try {
            Exception e = new Exception("예외 발생");
            throw e;
        } catch (Exception e) {
            System.out.println("에러 메시지 : " + e.getMessage());
            e.printStackTrace();
        }
        System.out.println("프로그램 정상 종료");
    }
}

Exception인스턴스를 생성할 때, 생성자에 String을 넣어주면 메시지로 저장된다. 이 메시지는 getMessage()를 이용해서 얻을 수 있다.

메서드에 예외 선언하기

예외를 처리하는 방법 중에는 예외를 메서드에 선언하는 방법이 있다.

메서드에 예외를 선언하려면 메서드 선언부에 키워드 throws를 사용해서 메서드 내에서 발생할 수 있는 예외를 적어주기만 하면 된다. 그리고 여러 개일 경우에는 쉼표로 구분한다.

    void method() throws Exception1, Exception2, ... , ExceptionN {
        // 메서드의 내용
    }

메서드의 선언부에 예외를 선언함으로써 메서드를 사용하려는 사람이 메서드의 선언부를 보았을 때, 이 메서드를 사용하기 위해서는 어떠한 예외들이 처리되어야 하는지 쉽게 알 수 있다.

메서드에 예외를 선언할 때 일반적으로 RuntimeException클래스들은 적지 않는다. throws에 선언한다고 해서 문제가 되지는 않지만, 보통 반드시 처리되어야 하는 예외들만 선언한다.

예외를 메서드의 throws에 명시하는 것은 예외를 처리하는 것이 아니라, 자신을 호출한 메서드에게 예외를 전달하여 예외처리를 떠맡기는 것이다.
예외를 전달받은 메서드는 자신을 호출하는 또다른 메서드에게 전달할 수 있으며, 이런 식으로 계속 호출스택에 있는 메서드들을 따라 전달되다가 마지막에 main메서드에서도 예외가 처리되지 않으면, main메서드가 종료되면서 프로그램 전체가 종료된다.

결국 예외는 처리되는 것이 아닌 단순히 전달만 되는 것이므로 결국 어느 한 곳에서는 try-catch문으로 처리를 해주어야 한다.

class App {
    public static void main(String[] args) {
        try {
            method1();
        } catch (Exception e) {
            System.out.println("main메서드에서 예외가 처리되었습니다.");
            e.printStackTrace();
        }
    }

    static void method1() throws Exception {
        throw new Exception();
    }
}

위 예제에서는 method1에서 발생한 예외를 main메서드에서 처리해주었다.

예외 처리는 예외가 발생한 메서드에서 예외를 처리할 수도 있고, 예외가 발생한 메서드를 호출한 메서드에서 처리할 수도 있다. 또는 두 메서드가 예외처리를 분담할 수도 있다.

finally블럭

finally블럭은 try-catch문과 함께 예외 발생여부에 상관없이 실행되어야할 코드를 포함시킬 목적으로 사용된다. try-catch문의 끝에 선택적으로 덧붙여 사용할 수 있으며, try-catch-finally의 순서로 구성된다.

    try {
        // 예외가 발생할 가능성이 있는 문장
    } catch (Exception e) {
        // 예외처리를 위한 문장
    } finally {
        // 예외 발생 여부에 관계없이 항상 실행되어야 할 문장
        // try-catch문의 마지막에 위치해야 한다.
    }

예외가 발생하면 ‘try → catch → finally’순으로 실행되고, 예외가 발생하지 않은 경우에는 ‘try → finally’순으로 실행된다.

자동 자원 반환 - try-with-resources문

JDK1.7부터 try-catch-resources문이라는 try-catch문의 변형이 새롭게 추가되었다.

주로 입출력에 사용되는 클래스 중에서는 사용한 후에 꼭 닫아 줘야 하는 것들이 있다. 닫아야만 사용했던 자원(resources)이 반환되기 때문이다.

    try {
        fis = new FileInputStream("score.dat");
        dis = new DataInputStream(fis);
          ...
    } catch (IOException ie) {
        ie.printStackTrace();
    } finally {
        dis.close();
    }

위 예제는 파일로부터 데이터를 읽는 코드인데, 데이터를 읽는 도중에 예외가 발생하더라도 DataInputStream이 닫히도록 finally블럭 안에 close()를 넣었다. 문제는 close()가 예외를 발생시킬 수 있기 때문에 아래와 같이 해야 올바른 코드이다.

    try {
        fis = new FileInputStream("score.dat");
        dis = new DataInputStream(fis);
          ...
    } catch (IOException ie) {
        ie.printStackTrace();
    } finally {
        try {
            if(dis != null)
              dis.close();
        } catch (IOException ie) {
            ie.printStackTrace();
        }
    }

이렇게 작성하게되면 코드가 복잡해지고 try블럭과 finally블럭 모두 예외가 발생해버리면 try 블럭의 예외가 무시된다.

이러한 점을 개선하기 위해 추가된 것이 try-with-resources문이다.

    try (FileInputStream fis = new FileInputStream("score.dat");
         DataInputStream dis = new DataInputStream(fis)) {
        while(true) {
            score = dis.readInt();
              ...
        }   
    } catch (EOFException e) {
        System.out.println(" ... ");
    } catch (IOException ie) {
        ie.printStackTrace();
    }

try-with-resources문의 괄호 안에 객체를 생성하는 문장을 넣으면, 이 객체는 따로 close()를 호출하지 않아도 try블럭을 벗어나는 순간 자동적으로 close()가 호출된다. 이 후 catch블럭 또는 finally블럭이 수행된다.

자바가 제공하는 예외 계층 구조

자바에서는 실행 시 발생할 수 있는 오류(Exception과 Error)를 클래스로 정의하였다. Exception과 Error 또한 클래스이므로 Object 클래스의 자손이다.

모든 예외의 최고 조상은 Exception클래스이며, 상속계층도를 Exception클래스부터 도식화하면 다음과 같다.

Exception과 Error의 차이는?

자바에서는 실행 시(runtime) 발생할 수 있는 프로그램 오류를 에러(Error)와 예외(Exception), 두 가지로 구분한다.

에러 Error

에러는 메모리 부족(OutOfMemoryError)이나 스택오버플로우(StackOverflowError)와 같은 발생하게 되면 복구할 수 없는 심각한 수준의 오류를 뜻한다. 시스템에 비정상적인 상황이 생겼을 때 발생하므로 System level의 문제이다.

예외 Exception

예외는 개발자가 작성한 로직 내에서 발생한 오류를 뜻한다. 따라서 발생하더라도 개발자가 이에 대한 적절한 코드를 미리 작성해 놓음으로써 프로그램의 비정상적인 종료와 같은 오류를 방지할 수 있다.

에러(error) 프로그램 코드에 의해서 수습될 수 없는 심각한 오류
예외(exception) 프로그램 코드에 의해서 수습될 수 있는 상대적으로 미약한 오류

Exception과 Error는 System Level의 문제와 Application Level의 문제의 차이이다.

RuntimeException과 RE가 아닌 것의 차이는?

상속계층도에서 볼 수 있듯이 예외 클래스는 두 그룹으로 나눌 수 있다.

Exception클래스와 그 자손들
RuntimeException클래스와 그 자손들

Unchecked Exception

Unchecked Exception(RuntimeException클래스와 그 자손들)은 주로 프로그래머의 실수에 의해서 발생될 수 있는 예외들로 자바의 프로그래밍 요소들과 관계가 깊다.

예를 들어

배열의 범위를 벗어난다던가(ArrayIndexOutOfBoundsException)
값이 null인 참조변수의 멤버를 호출하려 했다던가(NullPointerException)
클래스 간의 형변환을 잘못했다던가(ClassCastException)
정수를 0으로 나누려고(ArithmeticException)

하는 경우에 발생한다.

명시적인 처리를 강제하지 않고, 실행되는 시점(Runtime)에 확인한다.

Checked Exception

Checked Exception(RE클래스들을 제외한 나머지 클래스들)은 주로 외부의 영향으로 발생하는 것들로, 프로그램 사용자들의 동작에 의해서 발생하는 경우가 많다.

예를 들어

존재하지 않는 파일의 이름을 입력했다던가(FileNotFoundException)
실수로 클래스의 이름을 잘못 적었다던가(ClassNotFoundException)
입력한 데이터 형식이 잘못된(DataFormatException)

경우에 발생한다.

이름에서 알 수 있듯이 반드시 예외를 처리해야하고, 컴파일되는 시점에 확인한다.

어떻게 구분 할 수 있을까?

두 가지의 가장 명확한 구분 기준은 꼭 처리를 해야 하는냐이다. Checked Exception이 발생할 가능성이 있는 메소드라면 반드시 try ~ catch로 감싸거나 throw로 던져서 처리해야 한다.

반면에 Unchecked Exception은 명시적인 예외처리를 하지 않아도 된다. 대부분의 예외가 부주의로 발생하고, 예측하지 못했던 상황의 예외가 아니기 때문에 굳이 로직으로 처리 할 필요가 없도록 만들어져 있다.

예외를 확인할 수 있는 시점으로도 구분할 수 있다. 일반적으로 컴파일 단계에서 명확하게 Exception 체크가 가능한 것을 Checked Exception이라 하며, 실행과정 중 어떠한 특정 논리에 의해 발견되는 Exception을 Unchecked Exception이라 한다.

커스텀한 예외 만드는 방법

기존의 정의된 예외 클래스 외에 필요에 따라 프로그래머가 새로운 예외 클래스를 정의하여 사용할 수 있다. 보통 Exception클래스로부터 상속받는 클래스를 만들지만, 필요에 따라서 알맞은 예외 클래스를 선택할 수 있다.

class MyException extends Exception {
    MyException(String msg) {
        super(msg);
    }
}

Exception클래스로부터 상속받아서 만들어진 MyException클래스에 필요에 따라 멤버변수나 메서드를 추가할 수도 있다.
Exception클래스는 생성 시에 String값을 받아서 메시지로 저장할 수 있는데, 이처럼 String을 매개변수로 받는 생성자를 추가하여 메시지를 저장할 수 있도록 만들었다.

class MyException extends Exception {
    private final int ERR_CODE;

    MyException(String msg, int errCode) {    // 생성자
        super(msg);
        ERR_CODE = errCode;
    }

    MyException(String msg) {   // 생성자
        this(msg, 100);         // ERR_CODE를 100(기본값)으로 초기화
    }

    public int getErrCode() {   // 에러 코드를 얻을 수 있는 메서드
        return ERR_CODE;        // getMessage()와 함께 사용될 것
    }
}

에러코드 값을 저장할 수 있도록 ERR_CODE와 getErrCode()를 멤버로 추가했다. 이렇게 함으로써 MyException이 발생했을 때, catch블럭에서 getMessage()와 getErrCode()를 사용해서 에러코드와 메시지를 모두 얻을 수 있다.

기존의 예외 클래스는 주로 Exception을 상속받아서 Checked Exception으로 작성하는 경우가 많았다고 한다. 요즘은 예외처리를 선택적으로 할 수 있도록 RuntimeException을 상속받아서 작성하는 쪽으로 바뀌어가고 있다고 한다. Checked Exception은 반드시 예외처리를 해주어야 하기 때문에 불필요한 경우에도 try-catch문을 넣어 코드가 복잡해지기 떄문이다.

예외 되던지기(exception re-throwing)

한 메서드에서 발생할 수 있는 예외가 여럿인 경우, 몇 개는 try-catch문을 통해서 메서드 내에서 자체적으로 처리하고, 나머지는 선언부에 지정하여 호출한 메서드에서 처리하도록 함으로써, 양쪽에서 나눠서 처리되도록 할 수 있다.

심지어 하나의 예외를 양 쪽에서 처리하도록 할 수 있다. 예외를 처리한 후에 인위적으로 다시 발생시키는 방법을 통해서 가능한데, 이것을 예외 되던지기(exception re-throwing)라고 한다.

이 방법은 하나의 예외에 대해서 예외가 발생한 메서드와 이를 호출한 메서드 양쪽 모두에서 처리해줘야 할 작업이 있을 때 사용된다. 이 때 주의할 점은 예외가 발생한 메서드에서는 try-catch문을 사용해서 예외처리를 해줌과 동시에 메서드의 선언부에 발생할 예외를 throws에 지정해줘야 한다는 것이다.

class App {
    public static void main(String[] args) {
        try {
            method1();
        } catch (Exception e) {
            System.out.println("main메서드에서 예외처리");
        }
    }

    static void method1() throws Exception {
        try {
            throw new Exception();
        } catch (Exception e) {
            System.out.println("method1에서 예외처리");
            throw e;
        }
    }
}

반환값이 있는 return문의 경우, catch블럭에도 return문이 있어야 한다. 혹은 catch블럭에서 예외 되던지기를 해서 호출한 메서드로 예외를 전달하면, return문이 없어도 된다.

연결된 예외(chained exception)

한 예외가 다른 예외를 발생시킬 수도 있다. 예를 들어 예외 A가 예외 B를 발생시켰다면, A는 B의 원인 예외(cause exception)라고 한다.

아래 코드는 프로그램을 설치하는 코드에서 SpaceException을 원인 예외로 하는 InstallException을 발생시키는 방법이다.

    try {
        startInstall();     //SpaceException 발생
        copyFiles();
    } catch (SpaceException e) {
        InstallException ie = new InstallException("설치 중 예외발생"); // 예외 생성
        ie.initCause(e);  // InstallException의 원인 예외를 SpaceException으로 지정
        throw ie; // InstallException을 발생시킴
    } catch (MemoryException me) {
        ...
    }

initCause()는 Exception클래스의 조상인 Throwable클래스에 정의되어 있기 때문에 모든 예외에서 사용가능하다.

Throwable initCause(Throwable cause) 지정한 예외를 원인 예외로 등록
Throwable getCause() 원인 예외를 반환

발생한 예외를 그냥 처리하면 될 텐데, 원인 예외로 등록해서 다시 예외를 발생시키는 이유는 뭘까? 그 이유는 여러가지 예외를 하나의 큰 분류의 예외로 묶어서 다루기 위해서이다.
그렇다고 아래와 같이 InstallException을 SpaceException과 MemoryException의 조상으로 해서 catch블럭을 작성하면, 발생한 예외가 어떤 것인지 알 수 없다는 문제와 상속관계를 변경해야한다는 문제가 생긴다.

    try {
        startInstall();
        copyFiles();
    } catch (InstallException e) {
        e.printStackTrace();
    }

그래서 생각한 것이 예외가 원인 예외를 포함시킬 수 있게 한 것이다. 이렇게 하면, 두 예외는 상속관계가 아니어도 상관없다.

또 다른 이유는 Checked Exception을 Unchecked Exception으로 바꿀 수 있도록 하기 위해서이다. Checked Exception이 발생해도 예외를 처리할 수 없는 상황이 나타나면서 이를 해결하기 위해 의미없는 try-catch문을 추가하는 것 뿐이였다. 이럴 때 Checked Exception을 Unchecked Exception으로 바꾸면 예외처리가 선택적이 되므로 억지로 예외처리를 하지 않아도 된다.

예를 들어 MemoryException은 Exception의 자손이므로 반드시 예외를 처리해야하는데, 이 예외를 RuntimeException으로 감싸서 Unchecked Exception으로 만들 수 있다. 이러면 더 이상 선언부에 MemoryException을 선언하지 않아도 된다.

    static void startInstall() throws SpaceException, MemoryException {
        if(!enoughSpace())
          throw new SpaceException("설치 공간이 부족합니다.");

        if(!enoughMemory())
          throw new MemoryException("메모리가 부족합니다.");
    }

    static void startInstall() throws SpaceException {
        if(!enoughSpace())
          throw new SpaceException("설치 공간이 부족합니다.");

        if(!enoughMemory())
          throw new RuntimeException(new MemoryException("메모리가 부족합니다."));
    }

Reference

9주차 과제: 예외 처리.

목표

학습할 것

자바에서 예외 처리 방법

예외 처리(exception handling)

try-catch문

try-catch문에서의 흐름

catch블럭

printStackTrace()와 getMessage()

멀티 catch블럭

예외 발생시키기

메서드에 예외 선언하기

finally블럭

자동 자원 반환 - try-with-resources문

자바가 제공하는 예외 계층 구조

Exception과 Error의 차이는?

에러 Error

예외 Exception

Exception과 Error는 System Level의 문제와 Application Level의 문제의 차이이다.

RuntimeException과 RE가 아닌 것의 차이는?

Unchecked Exception

Checked Exception

어떻게 구분 할 수 있을까?

커스텀한 예외 만드는 방법

예외 되던지기(exception re-throwing)

연결된 예외(chained exception)

GitHub File

Category

Tags

Comments

JAVA STUDY HALLE 의 다른 글

15주차 피드백 06 Mar 2021

15주차 과제: 람다식. 28 Feb 2021

14주차 피드백 27 Feb 2021

14주차 과제: 제네릭. 22 Feb 2021

13주차 피드백 20 Feb 2021

13주차 과제: I/O. 08 Feb 2021

12주차 피드백 06 Feb 2021

12주차 과제: 애노테이션. 01 Feb 2021

11주차 피드백 30 Jan 2021

11주차 과제: Enum. 24 Jan 2021

10주차 피드백 23 Jan 2021

10주차 과제: 멀티쓰레드 프로그래밍. 18 Jan 2021

9주차 피드백 16 Jan 2021

9주차 과제: 예외 처리. 10 Jan 2021

8주차 피드백 09 Jan 2021

8주차 과제: 인터페이스. 03 Jan 2021

7주차 피드백 02 Jan 2021

7주차 과제: 패키지. 28 Dec 2020

6주차 피드백 27 Dec 2020

6주차 과제: 상속. 21 Dec 2020

5주차 피드백 20 Dec 2020

5주차 과제: 클래스. 14 Dec 2020

4주차 피드백 13 Dec 2020

4주차 과제: 제어문. 30 Nov 2020

3주차 피드백 29 Nov 2020

3주차 과제: 연산자. 22 Nov 2020

2주차 피드백 21 Nov 2020

2주차 과제: 자바 데이터 타입, 변수 그리고 배열. 15 Nov 2020

1주차 피드백 15 Nov 2020

1주차 과제: JVM은 무엇이며 자바 코드는 어떻게 실행하는 것인가. 08 Nov 2020