프로그램이 실행 중 어떤 원인에 의해서 오작동을 하거나 비정상적으로 종료되는 경우가 있다. 이러한 결과를 초래하는 원인을 프로그램 에러 또는 오류라고 한다.
이를 발생시점에 따라 '컴파일 에러(compile-time error)'와 '런타임 에러(runtime error)'로 나눌 수 있는데, 글자 그대로 '컴파일 에러'는 컴파일 할 때 발생하는 에러이고 프로그램의 실행도중에 발생하는 에러를 '런타임 에러'라고 한다.
컴파일 할 때(compile-time)는 컴파일러가 소스코드(*.java)에 대해 오타나 잘못된 구문, 자료형 체크 등의 기본적인 검사를 수행하여 오류가 있는지를 알려 준다. 컴파일러가 알려 준 에러들을 모두 수정해서 컴파일을 성공적으로 마치고 나면, 클래스 파일(*.class)이 생성되고, 생성된 클래스 파일을 실행할 수 있게 되는 것이다.
하지만, 컴파일을 에러없이 성공적으로 마쳤다고 해서 프로그램이 실행 시에도 에러가 발생하지 않는 것은 아니다.
컴파일러가 소스코드의 기본적인 사항은 컴파일시에 모두 걸러 줄 수는 있지만, 실행도중에 발생할 수 있는 잠재적인 오류에 대해서까지 검사할 수 없기 때문에 컴파일은 잘되었어도 실행 중에 에러에 의해서 잘못된 결과를 얻거나 프로그램이 비정상적으로 종료될 수 있다.
여러분들은 이미 실행도중에 발생하는 런타임 에러를 여러 번 경험했을 것이다. 예를 들면 프로그램이 실행 중 동작을 멈춘 상태로 오랜 시간 지속되거나, 갑자기 프로그램이 실행을 멈추고 종료되는 경우 등이 이에 해당한다.
런타임 에러를 방지하기 위해서는 프로그램의 실행도중 발생할 수 있는 모든 경우의 수를 고려하여 이에 대한 대비를 하는 것이 필요하다.
자바에서는 실행 시(runtime) 발생할 수 있는 프로그램 오류를 '에러(Error)'와 '예외(Exception)', 두 가지로 구분하였다.
에러는 메모리 부족(OutOfMemoryError)이나 스택오버플로우(StackOverflowError)와 같이 일단 발생하면 복구할 수 없는 심각한 오류이고, 예외는 발생하더라도 수습될 수 있는 비교적 덜 심각한 것이다.
에러가 발생하면, 프로그램의 비정상적인 종료를 막을 길이 없지만, 예외는 발생하더라도 프로그래머가 이에 대한 적절한 코드를 미리 작성해 놓음으로써 프로그램의 비정상적인 종료를 막을 수 있다.
에러(Error) - 프로그램 코드에 의해서 수습될 수 없는 심각한 오류 예외(Exception) - 프로그램 코드에 의해서 수습될 수 있는 다소 미약한 오류 |
프로그램의 실행도중에 발생하는 에러는 어쩔 수 없지만, 예외는 프로그래머가 이에 대한 처리를 미리 해주어야 한다.
예외처리(Exception Handling)란, 프로그램 실행 시 발생할 수 있는 예기치 못한 예외의 발생에 대비한 코드를 작성하는 것이며, 예외처리의 목적은 예외의 발생으로 인한 실행 중인 프로그램의 갑작스런 비정상 종료를 막고, 정상적인 실행상태를 유지할 수 있도록 하는 것이다.
예외처리(Exception Handling)의 정의 - 프로그램 실행 시 발생할 수 있는 예외의 발생에 대비한 코드를 작성하는 것 목적 - 프로그램의 비정상 종료를 막고, 정상적인 실행상태를 유지하는 것 |
예외를 처리하기 위해서는 try-catch문을 사용하며, 그 구조는 다음과 같다.
try { // 예외가 발생할 가능성이 있는 문장들을 넣는다. } catch (Exception1 e1) { // Exception1이 발생했을 경우, Exception1을 처리하기 위한 문장을 적는다. } catch (Exception2 e2) { // Exception2가 발생했을 경우, Exception2를 처리하기 위한 문장을 적는다. ... } catch (ExceptionN eN) { // ExceptionN이 발생했을 경우, ExceptionN을 처리하기 위한 문장을 적는다. } |
하나의 try블럭 다음에는 여러 종류의 예외를 처리할 수 있도록 하나 이상의 catch블럭이 올 수 있으며, 이 중 발생한 예외의 종류와 일치하는 단 한 개의 catch블럭 만이 수행된다.
발생한 예외의 종류와 일치하는 catch블럭이 없으면, 예외는 처리되지 않는다.
| [예제8-1] ExceptionEx1.java |
class ExceptionEx1 { public static void main(String[] args) { try { try { } catch (Exception e) { } } catch (Exception e) { try { } catch (Exception e) { } // 컴파일 에러 발생 !!! } try { } catch (Exception e) { } } // main메서드의 끝 } |
위의 예제는 아무 일도 하지 않는다. 단순히 try-catch문의 사용 예를 보여 주기 위해서 작성한 코드이다. 이처럼, 하나의 메서드 내에 여러 개의 try-catch문이 사용될 수 있으며, try블럭 또는 catch블럭에 또 다른 try-catch문이 포함될 수 있다.
catch블럭의 괄호 내에 선언된 변수는 catch블럭 내에서만 유효하기 때문에, 위의 모든 catch블럭에 참조변수 'e' 하나 만을 사용해도 된다.
하지만, catch블럭 내에 또 하나의 try-catch문이 포함된 경우, 같은 이름의 참조변수를 사용해서는 안 된다. 각 catch블럭에 선언된 두 참조변수의 영역이 서로 겹치기 때문에 다른 이름을 사용해서 구별해야하기 때문이다.
따라서 위의 예제에서 catch블럭 내의 try-catch문에 선언되어 있는 참조변수이름을 'e'가 아닌 다른 것으로 바꿔야 한다.
| [예제8-2] ExceptionEx2.java |
class ExceptionEx2 { public static void main(String args[]) { int number = 100; int result = 0; for(int i=0; i < 10; i++) { result = number / (int)(Math.random() * 10); System.out.println(result); } } } |
| [실행결과] |
| 20 100 java.lang.ArithmeticException: / by zero at ExceptionEx2.main(ExceptionEx2.java:7) |
위의 예제는 변수 number에 저장되어 있는 값 100을 0~9사이의 임의의 정수로 나눈 결과를 출력하는 일을 10번 반복한다.
random메서드를 사용했기 때문에 매번 실행할 때마다 결과가 다르겠지만, 대부분의 경우 10번이 출력되기 이전에 예외가 발생하여 프로그램이 비정상적으로 종료될 것이다.
결과에 나타난 메시지를 보면 Exception의 발생원인과 위치를 알 수 있으며, 이 예제의 결과에 나타난 메세지를 분석해 보면, 0으로 나누려 했기 때문에 ArithmeticException이 발생했고, 발생위치는 ExceptionEx2클래스의 main메서드(ExceptionEx2.java의 7번째 라인)라는 것을 알 수 있다.
이제 어디서 왜 Exception이 발생하는지 알았으니, 예외처리구문을 추가 해서 실행도중 예외가 발생하더라도 프로그램이 실행 도중에 비정상적으로 종료되지 않도록 수정해 보자.
| [예제8-3] ExceptionEx3.java |
class ExceptionEx3 { public static void main(String args[]) { int number = 100; int result = 0; for(int i=0; i < 10; i++) { try { result = number / (int)(Math.random() * 10); System.out.println(result); } catch (ArithmeticException e) { // ArithmeticException이 발생하면 수행된다. System.out.println("0"); } // try-catch의 마지막 } // for의 마지막 } } |
| [실행결과] |
| 16 20 11 0 25 100 25 33 14 12 |
위의 예제는 ExceptionEx2.java에 단순히 try-catch문을 추가한 것이다. ArithmeticException이 발생했을 경우에는 0을 화면에 출력하도록 했다. 위의 결과에서 보면, 4번째에 0이 출력되었는데 그 이유는 for문의 4번째 반복에서 ArithmeticException이 발생했기 때문이다. 그래서, ArithmeticException에 해당하는 catch블럭을 찾아서 그 catch블럭 내의 문장들을 실행한 다음 try-catch문을 벗어나 for문의 다음 반복을 계속 수행하여 작업을 모두 마치고 정상적으로 종료되었다.
만일 예외처리를 하지 않았다면, 세 번째 줄까지만 출력되고 예외가 발생해서 프로그램이 비정상적으로 종료되었을 것이다.
try-catch문에서, 예외가 발생한 경우와 발생하지 않았을 때의 흐름(문장의 실행순서)가 달라지는데, 아래에는 이 두 가지 경우에 따른 문장 실행순서를 정리하였다.
곧바로 try블럭을 벗어나 제일 첫 번째 위치한 catch블럭부터 차례대로 내려오면서, 발생한 예외와 일치하는 catch블럭이 있는지 확인한다.
일치하는 catch블럭을 찾게 되면, 그 catch블럭 내의 문장들을 수행하고 전체 try-catch문을 빠져나가서 그 다음 문장을 계속해서 수행한다.
try블럭 내의 마지막 문장까지 다 수행할 때까지도 예외가 발생하지 않으면, 어떠한 catch블럭도 거치지 않고 전체 try-catch문을 빠져나가서 그 다음 문장을 계속해서 수행한다.
| [예제8-4] ExceptionEx4.java |
class ExceptionEx4 { 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); } // try-catch의 마지막 System.out.println(6); } // main메서드의 마지막 } |
| [실행결과] |
| 1 2 3 4 6 |
위의 예제에서는 예외가 발생하지 않았으므로 catch블럭의 문장이 실행되지 않았다. 아래의 예제는 위의 예제를 변경해서, try블럭에서 예외가 발생하도록 하였다.
| [예제8-5] ExceptionEx5.java |
class ExceptionEx5 { 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 (ArithmeticException ae) { System.out.println(5); } // try-catch의 마지막 System.out.println(6); } // main메서드의 마지막 } |
| [실행결과] |
| 1 2 3 5 6 |
위의 예제의 결과를 보면, 1, 2, 3을 출력한 다음 try블럭에서 예외가 발생했기 때문에 try블럭을 바로 벗어나서 System.out.println(4)은 실행되지 않는다. 그리고는 발생한 예외에 해당하는 catch블럭으로 이동하여 문장들을 수행한다. 그리고는 전체 try-catch문을 벗어나서 그 다음 문장을 실행하여 6을 화면에 출력한다.
try블럭에서 예외가 발생하면, Exception이 발생한 이후에 있는 try블럭의 문장들은 수행되지 않으므로, try블럭에 포함시킬 범위를 잘 선택해야한다.
자바에서는 실행 시 발생할 수 있는 오류(Exception과 Error)를 클래스로 정의하였다. 이미 배웠던 것과 같이 모든 클래스의 조상은 Object클래스이므로 Exception과 Error클래스 역시 Object클래스의 자손들이다.
모든 예외의 최고 조상은 Exception클래스이며, 상속계층도를 Exception클래스부터 도식화하면 다음과 같다. 
예외 클래스들은 다음과 같이 두 개의 그룹으로 나눠질 수 있다. 
- RuntimeException클래스와 그 자손클래스들(위 그림에서의 아래 부분), 그리고 - 그 외의 Exception클래스와 그 자손클래스들(윗 부분)이다. |
앞으로 RuntimeException클래스와 그 자손 클래스들을 'RuntimeException클래스들'이라 하고, RuntimeException클래스들을 제외한 나머지 클래스들을 '그 외의 Exception클래스들'이라 하겠다.
RuntimeException클래스들은 주로 프로그래머의 실수에 의해서 발생될 수 있는 예외들로서 자바의 프로그래밍 요소들과 관계가 깊다. 예를 들면, 배열의 범위를 벗어난다던가(IndexOutOfBoundsException), 값이 null인 참조변수의 멤버를 호출하려 했다던가(NullPointerException), 클래스간의 형변환을 잘못했다던가(ClassCastException), 전의 예제에서 본 것처럼 정수를 0으로 나누려 했다던가(Arithmetic- Exception)하는 경우에 발생하는 예외들이다.
위의 예제에서는 RuntimeException클래스들 중의 하나인 ArithmeticException을 try-catch문으로 처리하였지만, 사실 try-catch문을 사용하기보다는 0으로 나누지 않도록 프로그램을 변경하는 것이 바른 처리방법이다.
이처럼 RuntimeException예외들이 발생할 가능성이 있는 코드들은 try-catch문을 사용하기 보다는 프로그래머들이 보다 주의 깊게 작성하여 예외가 발생하지 않도록 해야 할 것이다.
그 외의 Exception클래스들은 주로 외부의 영향으로 발생할 수 있는 것들로서, 프로그램의 사용자들의 동작에 의해서 발생하는 경우가 많다. 예를 들면, 존재하지 않는 파일의 이름을 입력했다던가(FileNotFoundException), 실수로 클래스의 이름을 잘못 적었다던가(ClassNotFoundException), 입력한 데이터의 형식이 잘못되었다던가(DataFormatException) 하는 경우에 발생하는 예외들이다.
이런 종류의 예외들은 반드시 처리를 해주어야 한다.
RuntimeException클래스들 - 프로그래머의 실수로 발생하는 예외 그 외의 클래스들 - 사용자의 실수와 같은 외적인 요인에 의해 발생하는 예외 |
지금까지 설명한 두 가지 그룹, RuntimeException클래스들과 그 외의 Exception클래스들의 중요한 차이점은 컴파일시의 예외처리 체크여부이다.
RuntimeException클래스들 그룹에 속하는 예외가 발생할 가능성이 있는 코드에는 예외처리를 해주지 않아도 컴파일 시에 문제가 되지 않지만, 그 외의 Exception클래스들 그룹에 속하는 예외가 발생할 가능성이 있는 예외는 반드시 처리를 해주어야 하며, 그렇지 않으면 컴파일시에 에러가 발생한다.
| [예제8-6] ExceptionEx6.java |
class ExceptionEx6 { public static void main(String[] args) { throw new Exception(); // Exception을 강제로 발생시킨다. } } |
위의 예제를 작성한 후에 컴파일 하면, 아래와 같은 에러가 발생하며 컴파일이 완료되지 않을 것이다.
ExceptionEx6.java:5: unreported exception java.lang.Exception; must be caught or declared to be thrown throw new Exception(); ^ 1 error |
예외처리가 되어야 할 부분에 예외처리가 되어 있지 않다는 에러이다. 위의 결과에서 알 수 있는 것처럼, 위에서 분류한 '그 외의 Exception클래스들'이 발생할 가능성이 있는 문장들에 대해 예외처리를 해주지 않으면 컴파일 조차 되지 않는다.
따라서 위의 예제를 아래와 같이 try-catch문으로 처리해주어야 컴파일이 성공적으로 이루어질 것이다.
| [예제8-7] ExceptionEx7.java |
class ExceptionEx7 { public static void main(String[] args) { try { throw new Exception(); } catch (Exception e) { System.out.println("Exception이 발생했습니다."); } } // main메서드의 끝 } |
| [실행결과] |
| Exception이 발생했습니다. |
| [예제8-8] ExceptionEx8.java |
class ExceptionEx8 { public static void main(String[] args) { throw new RuntimeException(); // RuntimeException을 강제로 발생시킨다. } } |
위의 예제를 컴파일 하면, 예외처리를 하지 않았음에도 불구하고 이전의 예제와는 달리 성공적으로 컴파일될 것이다. 그러나 실행하면 RuntimeException이 발생하여 비정상적으로 종료될 것이다.
이 예제가 명백히 RuntimeException을 발생시키는 코드를 가지고 있고, 이에 대한 예외처리를 하지 않았음에도 불구하고 성공적으로 컴파일 되었다.
이와 같이 RuntimeExeception클래스들은 예외처리를 해주지 않아도 컴파일러가 문제삼지 않는 것을 알아야 한다.
키워드 throw를 사용해서 프로그래머가 고의로 예외를 발생시킬 수 있으며, 방법은 아래의 순서를 따르면 된다.
1. 먼저, 키워드 new를 이용해서 발생시키려는 예외 클래스의 객체를 만든 다음 Exception e = new Exception("고의로 발생시켰음"); 2. 키워드 throw를 이용해서 예외를 발생시킨다. throw e; |
| [예제8-9] ExceptionEx9.java |
class ExceptionEx9 { public static void main(String args[]) { try { Exception e = new Exception("고의로 발생시켰음."); throw e; // 예외를 발생시킴 // throw new Exception("고의로 발생시켰음."); 위의 두 줄을 한 줄로 줄여 쓸 수 있다. } catch (Exception e) { System.out.println("에러 메시지 : " + e.getMessage()); e.printStackTrace(); } System.out.println("프로그램이 정상 종료되었음."); } } |
| [실행결과] |
| 에러 메시지 : 고의로 발생시켰음. java.lang.Exception: 고의로 발생시켰음. at ExceptionEx9.main(ExceptionEx9.java:4) 프로그램이 정상 종료되었음. |
Exception인스턴스를 생성할 때, 생성자에 String을 넣어 주면, 이 String이 Exception인스턴스에 메시지로 저장된다. 이 저장된 메시지는 getMessage()를 이용해서 얻을 수 있다.
catch블럭은 괄호()와 블럭{} 두 부분으로 나눠져 있는데, 괄호()내에는 처리하고자 하는 예외와 같은 타입의 참조변수 하나를 선언해야한다.
예외가 발생하면, 발생한 예외에 해당하는 클래스의 인스턴스가 만들어 진다. 예제8-5에서는 ArithmeticException이 발생했으므로, ArithmeticException클래스의 인스턴스가 생성되었다.
예외가 발생한 문장이 try-catch문의 try블럭에 포함되어 있다면, 이 예외를 처리할 수 있는 catch블럭이 있는지를 찾게 된다.
첫 번째 catch블럭부터 차례로 내려가면서, catch블럭의 괄호()내에 선언된 참조변수의 종류와 생성된 예외클래스의 인스턴스에 instanceof연산자를 이용해서 검사하게 되는데, 검사결과가 true인 catch블럭을 만날 때까지 검사는 계속된다.
검사결과가 true인 catch블럭을 찾게 되면, 블럭에 있는 문장들을 모두 수행한 후에 try-catch문을 빠져나가고 예외는 처리되지만, 검사결과가 true인 catch블럭이 하나도 없으면 예외는 처리되지 않는다.
모든 예외 클래스들은 Exception클래스의 자손이므로, catch블럭의 괄호()에 Exception클래스 타입의 참조변수를 선언해 놓으면 어떤 종류의 예외가 발생하더라도 이 catch블럭에 의해서 처리된다.
| [예제8-10] ExceptionEx10.java |
class ExceptionEx10 { 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) { // ArithmeticException대신 Exception을 사용. System.out.println(5); } // try-catch의 마지막 System.out.println(6); } // main메서드의 마지막 } |
| [실행결과] |
| 1 2 3 5 6 |
이 예제는 예제8-5를 변경한 것인데, 결과는 같다. catch블럭의 괄호()에 ArithmeticException클래스의 참조변수 대신에 Exception클래스의 참조변수를 선언하였다.
ArithmeticException클래스는 Exception클래스의 자손클래스이므로, ArithmeticException클래스의 인스턴스와 Exception클래스와의 instanceof연산결과가 true가 되어 Exception클래스의 참조변수를 선언한 catch블럭의 문장들이 수행되고 예외는 처리되는 것이다.
| [예제8-11] ExceptionEx11.java |
class ExceptionEx11 { 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 (ArithmeticException ae) { if (ae instanceof ArithmeticException) System.out.println("true"); System.out.println("ArithmeticException"); } catch (Exception e) { System.out.println("Exception"); } // try-catch의 마지막 System.out.println(6); } // main메서드의 마지막 } |
| [실행결과] |
| 1 2 3 true ArithmeticException 6 |
위의 예제에서는 두 개의 catch블럭, ArithmeticException클래스의 참조변수를 선언한 것과 Exception클래스의 참조변수를 선언한 것을 사용하였다.
try블럭에서 ArithmeticException이 발생하였으므로, catch블럭을 하나씩 차례로 검사하게 되는데, 첫 번째 검사에서 일치하는 catch블럭을 찾았기 때문에, 두 번째 catch블럭은 검사하지 않게 된다.
만일 try블럭 내에서 ArithmeticException이 아닌 다른 종류의 예외가 발생한 경우에는 두 번째 catch블럭인 Exception클래스의 참조변수를 선언한 곳에서 처리되었을 것이다.
이처럼, try-catch문의 마지막에 Exception클래스 타입의 참조변수를 선언한 catch블럭을 사용하면, 어떤 종류의 예외가 발생하더라도 이 catch블럭에 의해 처리되도록 할 수 있다.
예외가 발생했을 때 생성되는 예외클래스의 인스턴스에는 발생한 예외에 대한 정보가 담겨져 있으며, getMessage()와 printStackTrace()를 통해서 이 정보들을 얻을 수 있다.
catch블럭의 괄호()에 선언된 참조변수를 통해 이 인스턴스에 접근할 수 있다. 이 참조변수는 선언된 catch블럭 내에서만 사용 가능하며, 주로 사용되는 메서드는 다음과 같다.
printStackTrace() - 예외 발생 당시의 호출스택(Call Stack)에 있었던 메서드의 정보와 예외 메세지를 화면에 출력한다. getMessage() - 발생한 예외클래스의 인스턴스에 저장된 예외메세지를 얻을 수 있다. |
| [예제8-12] ExceptionEx12.java |
class ExceptionEx12 { public static void main(String args[]) { System.out.println(1); System.out.println(2); try { System.out.println(3); System.out.println(0/0); // 0으로 나눠서 ArithmeticException을 발생시킨다. System.out.println(4); // 실행되지 않는다. } catch (ArithmeticException ae) { ae.printStackTrace(); // 참조변수 ae를 통해 생성된 인스턴스에 접근할 수 있다. System.out.println("예외메시지 : " + ae.getMessage()); } // try-catch의 마지막 System.out.println(6); } // main메서드의 마지막 } |
| [실행결과] |
| 1 2 3 java.lang.ArithmeticException: / by zero at ExceptionEx12.main(ExceptionEx12.java:7) 예외메시지 : / by zero 6 |
위 예제의 결과는 예외가 발생해서 비정상적으로 종료되었을 때의 결과와 비슷하지만 예외는 처리되었으며 프로그램은 정상적으로 종료되었다.
대신 ArithmeticException인스턴스의 printStackTrace()를 사용해서, 호출스택(Call Stack)에 대한 정보와 예외메시지를 출력하였다.
이처럼 try-catch문으로 예외처리를 하여 예외가 발생해도 비정상적으로 종료하지 않도록 해주는 동시에, printStackTrace() 또는 getMessage()와 같은 메서드를 통해서 예외의 발생원인을 알 수 있다.
그리고 printStackTrace(PrintStream s) 또는 printStackTrace(PrintWriter s)를 사용하면, 발생한 예외에 대한 정보를 파일에 저장할 수도 있다.
| [예제8-13] ExceptionEx13.java |
import java.io.*; class ExceptionEx13 { public static void main(String args[]) { PrintStream ps = null; FileOutputStream fos=null; try { fos = new FileOutputStream("error.log"); ps = new PrintStream(fos); System.out.println(1); System.out.println(2); System.out.println(3); System.out.println(0/0); // 0으로 나눠서 ArithmeticException을 발생시킨다. System.out.println(4); // 실행되지 않는다. } catch (Exception ae) { ae.printStackTrace(ps); ps.println("예외메시지 : " + ae.getMessage()); // 화면대신 error.log파일에 출력한다. } // try-catch의 마지막 System.out.println(6); } // main메서드의 마지막 } |
| [실행결과] |
| C:\j2sdk1.4.1\work>java ExceptionEx13 1 2 3 6 C:\j2sdk1.4.1\work>type error.log java.lang.ArithmeticException: / by zero at ExceptionEx13.main(ExceptionEx13.java:17) 예외메시지 : / by zero |
try블럭 내에 선언된 변수는, try블럭 밖에서 사용할 수 없기 때문에 변수 ps와 fos를 try블럭 외부에 선언하였다.
위의 예제는 printStackTrace() 대신 printStackTrace(PrintStream s)를 사용해서, 호출스택의 내용을 화면에 출력하는 대신 error.log 파일에 저장하는 일을 한다.
그래서 이 전 예제에서는 printStackTrace()에 의해서 화면에 출력되었던 내용이 error.log파일에 저장되었다. 파일 error.log는 생성 시에 경로없이 파일의 이름만 지정하였으므로 현재 디렉토리에 생성될 것이다. 생성된 error.log파일의 내용은 다음과 같다.
java.lang.ArithmeticException: / by zero at ExceptionEx13.main(ExceptionEx13.java:17) 예외 메시지 : / by zero |
위 예제를 잘 보면 PrintStream클래스의 참조변수인 ps가 main메서드 내에 선언되어 있기 때문에, main메서드에서만 참조변수 ps가 사용 가능하다. 즉, main메서드에서만 error.log파일에 접근할 수 있으므로, main메서드가 아닌 다른 메서드에서 발생한 예외에 대한 내용을 기록할 수 없다.
이럴 때는 System.err을 이용하면 된다. 다음은 System.err을 이용하여 위의 예제를 변경한 것이다.
| [예제8-14] ExceptionEx14.java |
import java.io.*; import java.util.*; class ExceptionEx14 { public static void main(String args[]) { PrintStream ps = null; FileOutputStream fos=null; try { fos = new FileOutputStream("error.log"); // error.log파일에 출력할 준비를 한다. ps=new PrintStream(fos); System.setErr(ps); // err의 출력을 화면이 아닌, error.log파일로 변경한다. System.out.println(1); System.out.println(2); System.out.println(3); System.out.println(0/0); // 0으로 나눠서 ArithmeticException을 발생시킨다. System.out.println(4); // 실행되지 않는다. } catch (Exception ae) { System.err.println("-----------------------------------"); System.err.println("예외발생시간 : " + new Date()); // 현재시간을 기록한다. ae.printStackTrace(System.err); System.err.println("예외메시지 : " + ae.getMessage()); System.err.println("-----------------------------------"); } // try-catch의 마지막 System.out.println(6); } // main메서드의 마지막 } |
| [실행결과] |
| c:\j2sdk1.4.1\work>java ExceptionEx14 1 2 3 6 c:\j2sdk1.4.1\work>type error.log ----------------------------------- 예외발생시간 : Thu Jan 30 12:36:44 KST 2003 java.lang.ArithmeticException: / by zero at ExceptionEx13.main(ExceptionEx14.java:17) 예외메시지 : / by zero ----------------------------------- |
System.out이나 System.err은 System클래스의 static멤버로서 프로그램의 어디에서나 사용할 수 있다. System.err은 System.out과 마찬가지로 기본적으로 출력방향이 화면으로 되어 있어서, setErr메서드를 이용해서 출력방향을 바꾸지 않는 한 err에 출력하는 내용은 모두 화면에 보여지도록 되어 있다.
위의 예제에서는 setErr메서드를 이용해서 System.err의 출력방향을 error.log라는 이름의 파일로 변경한다. 출력방향이 변경되었기 때문에, System.err의 println메서드나 print메서드를 이용해서 출력하는 내용은 error.log파일에 저장된다.
파일입출력에 관한 내용이 나와서 이번 예제가 다소 어렵게 느껴질 수도 있겠지만, 일단은 프로그램에서 발생한 예외에 대한 기록을 파일로 남기는 방법이 있다는 정도만 이해하면 된다.
finally블럭은 try-catch문과 함께, 예외의 발생여부에 상관없이 실행되어야할 코드를 포함시킬 목적으로 사용된다. try-catch문의 끝에 선택적으로 덧붙여 사용할 수 있으며, try-catch-finally의 순서로 구성된다.
try { // 예외가 발생할 가능성이 있는 문장들을 넣는다. } catch (Exception1 e1) { // 예외처리를 위한 문장을 적는다. } finally { // 예외의 발생여부에 관계없이 항상 수행되어야하는 문장들을 넣는다. // finally블럭은 try-catch문의 맨 마지막에 위치해야한다. } |
예외가 발생한 경우에는 try -> catch -> finally의 순으로 실행되고, 예외가 발생하지 않은 경우에는 try -> finally의 순으로 실행된다.
| [예제8-15] FinallyTest.java |
class FinallyTest { public static void main(String args[]) { try { startInstall(); // 프로그램 설치에 필요한 준비를 한다. copyFiles(); // 파일들을 복사한다. deleteTempFiles(); // 프로그램 설치에 사용된 임시파일들을 삭제한다. } catch (Exception e) { e.printStackTrace(); deleteTempFiles(); } // try의 끝 } // main의 끝 static void startInstall() { /* 프로그램 설치에 필요한 준비를 하는 코드를 적는다.*/ } static void copyFiles() { /* 파일들을 복사하는 코드를 적는다. */ } static void deleteTempFiles() { /* 임시파일들을 삭제하는 코드를 적는다.*/} } |
이 예제가 하는 일은 프로그램설치를 위한 준비를 하고 파일들을 복사하고 설치가 완료되면, 프로그램을 설치하는데 사용된 임시파일들을 삭제하는 순서로 진행된다.
프로그램의 설치과정 중에 예외가 발생하더라도, 설치에 사용된 임시파일들이 삭제되도록 catch블럭에 deleteTempFiles()메서드를 넣었다.
결국 try블럭의 문장을 수행하는 동안에(프로그램을 설치하는 과정에), 예외의 발생여부에 관계없이 deleteTempFiles()메서드는 실행되어야 하는 것이다.
이럴 때 finally블럭을 사용하면 좋다. 아래의 코드는 위의 예제를 finally블럭을 사용해서 변경한 것이며, 두 예제의 기능은 동일하다.
| [예제8-16] FinallyTest2.java |
class FinallyTest2 { public static void main(String args[]) { try { startInstall(); // 프로그램 설치에 필요한 준비를 한다. copyFiles(); // 파일들을 복사한다. } catch (Exception e) { e.printStackTrace(); } finally { deleteTempFiles(); // 프로그램 설치에 사용된 임시파일들을 삭제한다. } // try의 끝 } // main의 끝 static void startInstall() { /* 프로그램 설치에 필요한 준비를 하는 코드를 적는다.*/ } static void copyFiles() { /* 파일들을 복사하는 코드를 적는다. */ } static void deleteTempFiles() { /* 임시파일들을 삭제하는 코드를 적는다.*/} } |
| [예제8-17] FinallyTest3.java |
class FinallyTest3 { public static void main(String args[]) { // method1()은 static메서드이므로 아래와 같이 인스턴스 생성없이 직접 호출이 가능하다. FinallyTest3.method1(); System.out.println("method1()의 수행을 마치고 main메서드로 돌아왔습니다."); } // main메서드의 끝입니다. static void method1() { try { System.out.println("method1()이 호출되었습니다."); return ; // 현재 실행 중인 메서드를 종료한다. } catch (Exception e) { e.printStackTrace(); } finally { System.out.println("method1()의 finally블럭이 실행되었습니다."); } } // method1메서드의 끝입니다. } |
| [실행결과] |
| method1()이 호출되었습니다. method1()의 finally블럭이 실행되었습니다. method1()의 수행을 마치고 main메서드로 돌아왔습니다. |
위의 결과에서 알 수 있듯이, try블럭에서 return문이 실행되는 경우에도 finally블럭의 문장들이 먼저 실행된 후에, 현재 실행 중인 메서드를 종료한다.
이와 마찬가지로 catch블럭의 문장 수행중에 return문을 만나도 finally블럭의 문장들은 수행된다.
예외를 처리하는 방법에는 지금까지 배워 온 try-catch문을 사용하는 것 이외에, 예외를 메서드에 선언하는 방법이 있다.
메서드에 예외를 선언하려면, 메서드의 선언부에 키워드 throws를 사용해서 메서드 내에서 발생할 수 있는 예외를 적어주기만 하면 된다. 그리고, 예외가 여러 개일 경우에는 쉼표(,)로 구분한다.
void method() throws Exception1, Exception2, ... ExceptionN { // 메서드의 내용 } |
이렇게 메서드의 선언부에 예외를 선언함으로써, 메서드를 사용하려는 사람이 메서드의 선언부를 보았을 때, 이 메서드를 사용하기 위해서는 어떠한 예외들이 처리되어져야 하는지 쉽게 알 수 있다.
기존의 많은 언어들에서는 메서드에 예외선언을 하지 않기 때문에, 경험 많은 프로그래머가 아니고서는 어떤 상황에 어떤 종류의 예외가 발생할 가능성이 있는지 충분히 예측하기 힘들기 때문에 그에 대한 대비를 하는 것이 어려웠다.
그러나 자바에서는 메서드를 작성할 때 메서드 내에서 발생할 가능성이 있는 예외를 메서드의 선언부에 명시하여, 이 메서드를 사용하는 쪽에서는 이에 대한 처리를 하도록 강요하기 때문에, 프로그래머들의 짐을 덜어 주는 것은 물론이고 보다 견고한 프로그램 코드를 작성할 수 있도록 도와준다. 
위의 그림은 Java API문서에서 찾아본 java.lang.Object클래스의 wait메서드에 대한 설명이다.
메서드의 선언부에 InterruptedException이 키워드 throws와 함께 적혀 있는 것을 볼 수 있다. 이 것이 의미하는 바는 이 메서드에서는 InterruptedException이 발생할 수 있으니, 이 메서드를 호출하고자 하는 메서드에서는 InterruptedException을 처리 해주어야 한다는 것이다.
InterruptedException에 밑줄이 있는 것으로 보아 링크가 걸려 있음을 알 수 있을 것이다. 이 링크를 클릭하면, InterruptedException에 대한 설명을 볼 수 있다. 
위의 그림에서 볼 수 있는 것처럼. InterruptedException은 Exception클래스의 자손임을 알 수 있다. 따라서 InterruptedException은 반드시 처리해주어야 하는 예외임을 알 수 있다. 그래서 wait메서드의 선언부에 키워드 throws와 함께 선언되어져 있는 것이다.
Java API의 wait메서드 설명의 아래쪽에 있는 'Throws:'를 보면, wait메서드에서 발생할 수 있는 예외의 리스트와 언제 발생하는가에 대한 설명이 덧붙여져 있다.
여기에는 두 개의 예외가 적혀 있는데 메서드에 선언되어 있는 InterruptedException외에 또 하나의 예외(IllegalMonitorStateException)가 있다. IllegalMonitorStateException 역시 링크가 걸려 있으므로 클릭하면, IllegalMonitorStateException에 대한 정보를 얻을 수 있다. 
이 그림에서도 볼 수 있듯이 IllegalMonitorStateException은 RuntimeException클래스의 자손이므로 IllegalMonitorStateException은 예외처리를 해주지 않아도 된다.
그래서 wait메서드의 선언부에 IllegalMonitorStateException을 적지 않은 것이다.
지금까지 알아본 것처럼, 메서드에 예외를 선언할 때 일반적으로 RuntimeException클래스들은 적지 않는다. 이 들을 메서드 선언부의 throws에 선언한다고 해서 문제가 되지는 않지만, 보통 반드시 처리해주어야 하는 예외들만 선언한다.
이처럼 Java API문서를 통해 사용하고자 하는 메서드의 선언부와 'Throws:'를 보고, 이 메서드에서는 어떤 예외가 발생할 수 있으며 반드시 처리해주어야 하는 예외는 어떤 것들이 있는지 확인하는 것이 좋다.
사실 예외를 메서드의 throws에 명시하는 것은 예외를 처리하는 것이 아니라, 자신(예외가 발생할 가능성이 있는 메서드)을 호출한 메서드에게 예외를 전달하여 예외처리를 떠맡기는 것이다.
예외를 전달받은 메서드가 또다시 자신을 호출한 메서드에게 전달할 수 있으며, 이런 식으로 계속 호출스택에 있는 메서드들을 따라 전달되다가 제일 마지막에 있는 main메서드에서도 예외가 처리되지 않으면, main메서드 마져 종료되어 프로그램이 전체가 종료된다.
| [예제8-18] ExceptionEx18.java |
class ExceptionEx18 { public static void main(String[] args) throws Exception { method1(); // 같은 클래스내의 static멤버이므로 객체생성없이 직접 호출가능. } // main메서드의 끝 static void method1() throws Exception { method2(); } // method1의 끝 static void method2() throws Exception { throw new Exception(); } // method2의 끝 } |
| [실행결과] |
| java.lang.Exception at ExceptionEx18.method2(ExceptionEx18.java:12) at ExceptionEx18.method1(ExceptionEx18.java:8) at ExceptionEx18.main(ExceptionEx18.java:4) |
위의 실행결과를 보면, 프로그램의 실행도중 java.lang.Exception이 발생하여 비정상적으로 종료했다는 것과 예외가 발생했을 때 호출스택(Call Stack)의 내용을 알 수 있다
위의 결과로부터 다음과 같은 사실을 알 수 있다.
- 예외가 발생했을 때, 모두 3개의 메서드(main, method1, method2)가 호출스택에 있었으며, - 예외가 발생한 곳은 제일 윗 줄에 있는 method2()라는 것과 - main메서드가 method1()를, 그리고 method1()은 method2()를 호출했다는 것 |
위의 예제를 보면, method2()에서 throw new Exception();문장에 의해 예외가 강제적으로 발생했으나 try-catch문으로 예외처리를 해주지 않았으므로, method2()는 종료되면서 예외를 자신을 호출한method1()에게 넘겨준다. method1()에서도 역시 예외처리를 해주지 않았으므로 종료되면서 main메서드에게 예외를 넘겨준다.
그러나 main메서드에서 조차 예외처리를 해주지 않았으므로 main메서드가 종료되어 프로그램이 예외로 인해 비정상적으로 종료하게 되는 것이다.
이처럼 예외가 발생한 메서드에서 예외처리를 하지 않고 자신을 호출한 메서드에게 예외를 넘겨줄 수는 있지만, 이것으로 예외가 처리된 것은 아니고, 예외를 단순히 전달만 하는 것이다.
결국 어디서 든 간에 반드시 try-catch문을 사용해서 예외처리를 해주어야 한다.
| [예제8-19] ExceptionEx19.java |
class ExceptionEx19 { public static void main(String[] args) { method1(); // 같은 클래스내의 static멤버이므로 객체생성없이 직접 호출가능. } // main메서드의 끝 static void method1() { try { throw new Exception(); } catch (Exception e) { System.out.println("method1메서드에서 예외가 처리되었습니다."); e.printStackTrace(); } } // method1의 끝 } |
| [실행결과] |
| method1메서드에서 예외가 처리되었습니다. java.lang.Exception at ExceptionEx19.method1(ExceptionEx19.java:9) at ExceptionEx19.main(ExceptionEx19.java:4) |
예외는 처리되었지만, printStackTrace()를 통해 예외에 대한 정보를 화면에 출력하였다. 예외가 method1에서 발생했으며, main메서드가 method1을 호출했음을 알 수 있다.
| [예제8-20] ExceptionEx20.java |
class ExceptionEx20 { public static void main(String[] args) { try { method1(); } catch (Exception e) { System.out.println("main메서드에서 예외가 처리되었습니다."); e.printStackTrace(); } } // main메서드의 끝 static void method1() throws Exception { throw new Exception(); } // method1메서드의 끝 } |
| [실행결과] |
| main메서드에서 예외가 처리되었습니다. java.lang.Exception at ExceptionEx20.method1(ExceptionEx20.java:13) at ExceptionEx20.main(ExceptionEx20.java:5) |
두 예제 모두 main메서드가 method1()을 호출하며, method1()에서 예외가 발생한다. 차이점은 예외처리 방법에 있다.
첫 번째 예제는 method1()에서 예외처리를 했고, 두 번째 예제는 method1()에서 예외를 선언하여 자신을 호출하는 메서드(main메서드)에 예외를 전달 했으며, 호출한 메서드(main메서드)에서는 try-catch문으로 예외처리를 했다.
첫 번째 예제처럼 예외가 발생한 메서드(method1) 내에서 처리되어지면, 호출한 메서드(main)에서는 예외가 발생했다는 사실조차 모르게 된다.
두 번째 예제처럼 예외가 발생한 메서드에서 예외를 처리하지 않고 호출한 메서드로 넘겨주면, 호출한 메서드에서는 method1()을 호출한 라인에서 예외가 발생한 것으로 간주되어 이에 대한 처리를 하게 된다.
이처럼 예외가 발생한 메서드(method1())에서 예외를 처리할 수도 있고, 예외가 발생한 메서드를 호출한 메서드(main메서드)에서 처리할 수도 있다. 또는 두 메서드가 예외처리를 분담할 수도 있다.
이번엔 보다 그럴듯한 예를 들어보도록 하겠다.
| [예제8-21] ExceptionEx21.java |
import java.io.*; class ExceptionEx21 { public static void main(String[] args) { // command line에서 입력받은 값을 이름으로 갖는 파일을 생성한다. File f = createFile(args[0]); System.out.println( f.getName() + " 파일이 성공적으로 생성되었습니다."); } // main메서드의 끝 static File createFile(String fileName) { try { if (fileName==null || fileName.equals("")) throw new Exception("파일이름이 유효하지 않습니다."); } catch (Exception e) { // fileName이 부적절한경우, 파일 이름을 '제목없음.txt'로 한다. fileName = "제목없음.txt"; } finally { File f = new File(fileName); // File클래스의 객체를 만든다. createNewFile(f); // 생성된 객체를 이용해서 파일을 생성한다. return f; } } // createFile메서드의 끝 static void createNewFile(File f) { try { f.createNewFile(); // 파일을 생성한다. } catch(Exception e){ } } // createNewFile메서드의 끝 } // 클래스의 끝 |
| [실행결과] |
| C:\j2sdk1.4.1\work>java ExceptionEx21 "test.txt" test.txt 파일이 성공적으로 생성되었습니다. C:\j2sdk1.4.1\work>java ExceptionEx21 "" 제목없음.txt 파일이 성공적으로 생성되었습니다. C:\j2sdk1.4.1\work>dir *.txt 드라이브 C에 레이블이 없습니다 볼륨 일련 번호 251C-08DD 디렉터리 C:\j2sdk1.4\work 제목없음 TXT 0 03-01-24 0:47 제목없음.txt TEST TXT 0 03-01-24 0:47 test.txt 1개 파일 0 바이트 0개 디렉터리 848.14 MB 사용 가능 |
이 예제는 예외가 발생한 메서드에서 직접 예외를 처리하도록 되어 있다. createFile메서드를 호출한 main메서드에서는 예외가 발생한 사실을 알지 못한다. 적절하지 못한 파일이름(fileName)이 입력되면, 예외를 발생시키고, catch블럭에서, 파일이름을 '제목없음.txt'로 설정해서 파일을 생성한다. 그리고, finally블럭에서는 예외의 발생여부에 관계없이 파일을 생성하는 일을 한다.
| [예제8-22] ExceptionEx22.java |
import java.io.*; class ExceptionEx22 { public static void main(String[] args) { try { File f = createFile(args[0]); System.out.println( f.getName() + "파일이 성공적으로 생성되었습니다."); } catch (Exception e) { System.out.println(e.getMessage() +" 다시 입력해 주시기 바랍니다."); } } // main메서드의 끝 static File createFile(String fileName) throws Exception { if (fileName==null || fileName.equals("")) throw new Exception("파일이름이 유효하지 않습니다."); File f = new File(fileName); // File클래스의 객체를 만든다. f.createNewFile(); // File객체의 createNewFile메서드를 이용해서 실제파일을 생성한다. return f; // 생성된 객체의 참조를 반환한다. } // createFile메서드의 끝 } // 클래스의 끝 |
| [실행결과] |
| C:\j2sdk1.4.1\work>java ExceptionEx22 test2.txt test2.txt파일이 성공적으로 생성되었습니다. C:\j2sdk1.4.1\work>java ExceptionEx22 "" 파일이름이 유효하지 않습니다. 다시 입력해 주시기 바랍니다. |
이 두 번째 예제에서는 예외가 발생한 createFile메서드에서 잘못 입력된 파일이름을 임의로 처리하지 않고, 호출한 main메서드에게 예외가 발생했음을 알려서 파일이름을 다시 입력 받도록 하였다.
첫 번째 예제와는 달리 createFile메서드에 예외를 선언했기 때문에, File클래스의 createNewFile()에 대한 예외처리를 하지 않아도 되므로 createNewFile(File f)메서드를 굳이 따로 만들지 않았다.
두 예제 모두 커맨드라인으로부터 파일이름을 입력 받아서 파일을 생성하는 일을 하며. 파일 이름을 잘못 입력했을 때(null 또는 빈 문자열""일 때) 예외가 발생하도록 되어 있다.
두 예제의 차이점의 예외의 처리방법에 있다. 첫 번째 예제는 예외가 발생한 createFile메서드 자체 내에서 처리를 하며, 두 번째 예제는 createFile메서드를 호출한 메서드(main메서드)에서 처리한다.
이 처럼 예외가 발생한 메서드 내에서 자체적으로 처리해도 되는 것은 메서드 내에서 try-catch문을 사용해서 처리하고, 두 번째 예제처럼 메서드에 호출 시 넘겨받아야 할 값(fileName)을 다시 받아야 하는 경우(메서드에서 자체적으로 해결이 안 되는 경우)에는 예외를 메서드에 선언해서, 호출한 메서드에서 처리하면 된다.
한 메서드에서 발생할 수 있는 예외가 여럿인 경우, 몇 개는 try-catch문을 통해서 메서드 내에서 자체적으로 처리하고, 그 나머지는 선언부에 지정하여 호출한 메서드에서 처리하도록 함으로써, 양쪽에서 나눠서 처리되도록 할 수 있다.
그리고 심지어는 단 하나의 예외에 대해서도 예외가 발생한 메서드와 호출한 메서드, 양쪽에서 처리하도록 할 수 있다.
이 것은 예외를 처리한 후에 인위적으로 다시 발생시키는 방법을 통해서 가능한데, 이 것을 '예외 되던지기(Exception Re-throwing)이라고 한다.
먼저 예외가 발생할 가능성이 있는 메서드에서 try-catch문을 사용해서 예외를 처리해주고, catch문에서 필요한 작업을 행한 후에 throw문을 사용해서 예외를 다시 발생시킨다.
다시 발생한 예외는 이 메서드를 호출한 메서드에게 전달되고, 호출한 메서드의 try-catch문에서 예외를 또다시 처리하면 된다.
이 방법은 하나의 예외에 대해서 예외가 발생한 메서드와 이를 호출한 메서드 양쪽 모두에서 처리해줘야 할 작업이 있을 때 사용된다.
이 때 주의해야할 점은 예외가 발생할 메서드에서는 try-catch문을 사용해서 예외처리를 해줌과 동시에 메서드의 선언부에 발생할 예외를 throws에 지정해줘야 한다는 것이다.
| [예제8-23] ExceptionEx23.java |
class ExceptionEx23 { public static void main(String[] args) { try { method1(); } catch (Exception e) { System.out.println("main메서드에서 예외가 처리되었습니다."); } } // main메서드의 끝 static void method1() throws Exception { try { throw new Exception(); } catch (Exception e) { System.out.println("method1메서드에서 예외가 처리되었습니다."); throw e; // 다시 예외를 발생시킨다. } } // method1메서드의 끝 } |
| [실행결과] |
| method1메서드에서 예외가 처리되었습니다. main메서드에서 예외가 처리되었습니다. |
결과에서 알 수 있듯이 method1()와 main메서드 양쪽의 catch블럭이 모두 수행되었음을 알 수 있다. method1()의 catch블럭에서 예외를 처리하고도 throw문을 통해 다시 예외를 발생 시켰다. 그리고 이 예외를 main메서드 한번 더 처리하였다.
기존의 정의된 예외 클래스 외에 필요에 따라 프로그래머가 새로운 예외 클래스를 정의하여 사용할 수 있다. 보통 Exception클래스로부터 상속받는 클래스를 만들지만, 필요에 따라서 알맞은 예외 클래스를 선택할 수 있다.
class MyException extends Exception { MyException(String msg) { // 생성자. super(msg); // 조상클래스인 Exception클래스의 생성자를 호출한다. } } |
Exception클래스로부터 상속받아서 MyException클래스를 만들었다. 필요하다면, 멤버변수나 메서드를 추가할 수 있다. Exception클래스는 생성 시에 String값을 받아서 메시지로 저장할 수 있다. 여러분이 만든 사용자정의 예외 클래스도 메시지를 저장할 수 있으려면, 위에서 보는 것과 같이 String을 매개변수로 받는 생성자를 추가해주어야 한다.
class MyException extends Exception { private final int errorCode = 100; // 에러 코드 값을 저장하기 위한 필드를 추가 했다. MyException(String msg) { // 생성자. super(msg); } public int getCode() { // 에러 코드를 얻을수 있는 메서드도 추가했다. return errorCode; // 이 메서드는 주로 getMessage()와 함께 사용될 것이다. } } |
이전의 코드를 좀더 개선하여 메시지 뿐만 아니라 에러코드 값도 저장할 수 있도록 errorCode와 getCode()를 MyException클래스의 멤버로 추가했다.
이렇게 함으로써 MyException이 발생했을 때, catch블럭에서 getMessage메서드와 getCode메서드를 사용해서, 에러코드와 메시지를 모두 얻을 수 있을 것이다.
| [예제8-24] NewExceptionTest.java |
class NewExceptionTest { public static void main(String args[]) { try { startInstall(); // 프로그램 설치에 필요한 준비를 한다. copyFiles(); // 파일들을 복사한다. } catch (SpaceException e) { System.out.println("에러 메세지 : " + e.getMessage()); e.printStackTrace(); System.out.println("공간을 확보한 후에 다시 설치하시기 바랍니다."); } catch (MemoryException me) { System.out.println("에러 메세지 : " + me.getMessage()); me.printStackTrace(); System.gc(); // Garbage Collection을 수행하여 메모리를 늘려준다. System.out.println("다시 설치를 시도하세요."); } finally { deleteTempFiles(); // 프로그램 설치에 사용된 임시파일들을 삭제한다. } // try의 끝 } // main의 끝 static void startInstall() throws SpaceException, MemoryException { if(!enoughSpace()) // 충분한 설치 공간이 없으면... throw new SpaceException("설치할 공간이 부족합니다."); if (!enoughMemory()) // 충분한 메모리가 없으면... throw new MemoryException("메모리가 부족합니다."); } // startInstall메서드의 끝 static void copyFiles() { /* 파일들을 복사하는 코드를 적는다. */ } static void deleteTempFiles() { /* 임시파일들을 삭제하는 코드를 적는다.*/} static boolean enoughSpace() { // 설치하는데 필요한 공간이 있는지 확인하는 코드를 적는다. return false; } static boolean enoughMemory() { // 설치하는데 필요한 메모리공간이 있는지 확인하는 코드를 적는다. return true; } } // ExceptionTest클래스의 끝 class SpaceException extends Exception { SpaceException(String msg) { super(msg); } } class MemoryException extends Exception { MemoryException(String msg) { super(msg); } } |
| [실행결과] |
| 에러 메세지 : 설치할 공간이 부족합니다. SpaceException: 설치할 공간이 부족합니다. at NewExceptionTest.startInstall(NewExceptionTest.java:22) at NewExceptionTest.main(NewExceptionTest.java:4) 공간을 확보한 후에 다시 설치하시기 바랍니다. |
이 예제를 실제 설치 프로그램과 비슷하게 보이려고 하다보니 좀 복잡해 졌다. MemoryException과 SpaceException, 이 두 개의 사용자정의 예외 클래스를 새로 만들어서 사용했다. SpaceException은 프로그램을 설치하려는 곳에 충분한 공간이 없을 경우에 발생하도록 했으며, MemoryException은 설치작업을 수행하는데 메모리 충분히 확보되지 않았을 경우에 발생하도록 하였다.
이 두 개의 예외는 startInstall()메서드를 수행하는 동안에 발생할 수 있으며, enoughSpace()와 enoughMemory()의 실행결과에 따라서 발생하는 예외의 종류가 달라지도록 했다.
이번 예제에서 enoughSpace메서드와 enoughMemory메서드는 단순히 false와 true를 각각 return하도록 되어 있지만, 설치공간과 사용 가능한 메모리를 확인하는 기능을 한다고 가정하였다.
출처 : 네이버 자바의 정석 카페(예외처리)
'공부 > JAVA' 카테고리의 다른 글
| JAVA_[ Iterator & Enumerator ] (0) | 2014.08.21 |
|---|---|
| JAVA_[ Vector, ArrayList, Object[], HashMap, TreeMap 선택방법 ] (0) | 2014.08.20 |
| JAVA_[ 반올림/내림 (floor, ceil, round) ] (0) | 2014.06.19 |
| JAVA_[문자열(String) 숫자여부 체크] (0) | 2014.02.07 |
| JAVA_[ String 와 StringBuffer 성능에 대하여... ] (0) | 2014.01.22 |