예외처리3
메서드에 예외 선언하기
예외를 처리하는 방법에서는 지금까지 배워 온 try-catch문을 사용하는 것 외에, 예외를 메서드에 선언하는 아법이 있다. 메서드에 예외를 선언하려면, 메서드의 선언부에 키워드 throws를 사용해서 메서드 내에서 발생할 수 있는 예외를 적어주기만 하면 된다. 그리고 예외가 여러 개일 경우에는 쉼표(,)로 구분한다.
void method() throws Exception1, Exception2, ExceptionN {
//메서드의 내용
}
만일 아래와 같이 모든 예외의 조상인 Exception 클래스를 메서드에 선언하면 이 메서드는 모든 종류의 예외가 발생할 가능성이 있다는 뜻이다.
void method() throws Exception {
//메서드의 내용
}이렇게 예외를 선언하며느 이 예외뿐만 아니라 그 자손타입의 예외까지도 발생할 수 있다는 점에 주의하자. 앞서 오버라이딩에서 살펴본 것과 같이, 오버라이딩 할 때는 단순히 선언된 예외의 개수가 아니라 상속관계까지 고려해야 한다.
메서드의 선언부에 예외를 선언함으로써 메서드를 사용하려는 사람이 메서드의 선언부를 보았을 때, 이 메서드를 사용하기 위해서는 어떠한 예외들이 처리되어져야 하는지 쉽게 알 수 있다.
자바에서는 메서드를 작성할 때 메서드 내에서 발생할 가능성이 있는 예외를 메서드의 선언부에 명시하여 이 메서드를 사용하는 쪽에서는 이에 대한 처리를 하도록 강요하기 때문에, 프로그래머 들의 짐을 덜어 주는 것은 물론이고 보다 견고한 프로그램 코드를 작성할 수 있도록 도와준다.
class ExceptionEx12 {
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끝
}
Exception in thread "main" java.lang.Exception
at ExceptionEx12.method2(ExceptionEx12.java:11)
at ExceptionEx12.method1(ExceptionEx12.java:7)
at ExceptionEx12.main(ExceptionEx12.java:3)위의 실행결과를 보면, 프로그램의 실행도중 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-cat문으로 예외처리를 해주어야한다.
class ExceptionEx13 {
public static void main(String[] args) {
method1();
}
static void method1() {
try {
throw new Exception();
} catch (Exception e) {
System.out.println("method1메서드에서 예외가 처리되었습니다.");
e.printStackTrace();
}
} // method1�� ��
}예외는 처리 되었지만, printStackTrace()를 통해 예외에 대한 정보를 화면에 출력하였다. 예외가 method1()에서 발생했으며, main메서드가 method1()을 호출했음을 알 수 있다.
class ExceptionEx14 {
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()�� ��
} // class�� ��두 예제 모두 main메서드가 method1()을 호출하며, method1()에서 예외가 발생한다. 차이점은 예외처리 방법에 있다. ex13은 method1()에서 예외처리를 했고, 예제 8-14는 method1()에서 예외를 선언하여 자신을 호출하는 메서드(main메서드)에 예외를 전달했으며, 호출한 메서드(main 메서드)에서는 try-catch문으로 예외처리를 했다.
ex13처럼 예외가 발생한 메서드(method1) 내에서 처리되어지면, 호출한 메서드 (main메서드)에서는 예외가 발생했다는 사실조차 모르게 된다 ex14처럼 예외가 발생한 메서드에서 예외를 처리하지 않고 호출한 메서드로 넘겨 주면, 호출한 메서드에서는 method1()을 호출한 라인에서 예외가 발생한 것으로 간주되어 이에 대한 처리를 하게 된다. 이처럼 예외가 발생한 메서드method1()에서 예외를 처리할 수도 있고, 예외가 발생한 메서드를 호출한 main메서드 에서 처리할 수도 있다, 또는 두 메서드가 예외처리를 분담 할 수도있다.
import java.io.*;
class ExceptionEx15 {
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) {
// fineName이 부적절한 경우, 파일 이름을 `제목없음.txt로 한다.`
fileName = "제목없음.txt";
} finally {
File f = new File(fileName); // FileŬ클래스의 객체를 만든다.
createNewFile(f); // 생성된 객체를 이용해서 파일을 생성한다.1
return f;
}
} // createFile메서드의 끝
static void createNewFile(File f) {
try {
f.createNewFile(); // 파일을 생성한다.
} catch (Exception e) {
}
} // createNewFile메서드의 긑
}
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
at ExceptionEx15.main(ExceptionEx15.java:6)이 예제는 예외가 발생한 메서드에서 직접 예외를 처리하도록 되어 있다. createFile메서드를 호출한 main메서드에서는 예외가 발생한 사실을 알지 못한다. 적절하지 못한 파일이름(fileName)이 입력되면 ,예외를 발생시키고 catch블럭에서, 파일이름을 제목없음.txt로 설정해서 파일을 생성한다. 그리고 finally블럭에서는 예외의 발생여부에 관계없이 파일을 생성하는 일을 한다.
import java.io.*;
class ExceptionEx16 {
public static void main(String[] args) {
try {
File f = createFile("반갑습니다");
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클래스의 객체를 만든다.
// File 객체의 createNewFile메서드를 이용해서 실제 파일을 생성한다.
f.createNewFile();
return f; // 생성된 객체의 참조를 반환한다.
} // createFile
} //[File]클래스의 createNewFile()은 예외가 선언된 메서드 이므로 finally블럭 내에 또 다시 try-catch문으로 처리해야하므로 좀 복잡해진다. 이해를 돕기 위해 예제의 기본 흐름을 되도록 간단히 하려고 내부적으로 예외처리를 한 createNewFile(File i)메서드를 만들어서 사용했다.
import java.io.*;
class ExceptionEx16 {
public static void main(String[] args) {
try {
File f = createFile("반갑습니다");
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클래스의 객체를 만든다.
// File 객체의 createNewFile메서드를 이용해서 실제 파일을 생성한다.
f.createNewFile();
return f; // 생성된 객체의 참조를 반환한다.
} // createFile
} //이 예제에서는 예외가 발생한 createFile메서드에서 잘못 입력된 파일이름을 임의로 처리 하지 않고, 호출한 main메서드에서 예외가 발생했음을 알려서 파일이름을 다시 입력 받도록 하였다.
EX15와 달리 createFile메서드에 예외를 선언했기 떄문에, File클래스의 createNewFile()에 대한 예외 처리를 하지 않아도 되므로 createNewFile(File f)메서드를 굳이 따로 만들지 않았다. 두 예제 모두 커맨드 라인으로 부터 파일이름을 입력 받아서 파일을 생성하는 일을 하며, 파일 이름을 잘못 입력했을 때(null 또는 빈 문자열일 때) 예외가 발생하도록 되어 있다. 차이점은 예외의 처리방법에 있다. 예제 8-15는 예외가 발생한 createFile메서드 자체 내에서 처리를 하며, 예제 8-16은 createFile메서드를 호출한 메서드(main메서드)에서 처리한다.
finally블럭
finally블럭은 예외의 발생여부에 상관없이 실행되어야할 코드를 포함시킬 목적으로 사용 된다. try-catch문의 끝에 선택적으로 덧붙여 사용할 수 있으며, try-catch-finally의 순서로 구성된다.
try{
//예외가 발생할 가능성이 있는 문장들을 넣는다.
}catch (Exception el) {
//예외 처리를 위한 문장을 적는다.
}finally {
//예외 발생여부에 관계없이 항상 수행되어야하는 문장들을 넣는다.
//finally블럭은 try-caych문의 맨 마지막에 위치해야 한다.
}예외가 발생한 경우에는 try-catch-finally의 순으로 실행되고, 예외가 발생하지 않은 경우에는 try->finally의 순으로 실행된다.
class FinallyTest {
public static void main(String args[]) {
try {
startInstall(); // 프로그램 설치에 필요한 준비를 한다.
copyFiles(); // 파일들을 복사한다.
deleteTempFiles(); // 프로그램 설치에 사용된 임시파일들을 삭제한다.
} catch (Exception e) {
e.printStackTrace();
deleteTempFiles(); // 프로그램 설치에 사용된 임시파일들을 삭제한다.
} // try-catch�� ��
} // main�� ��
static void startInstall() {
// 프로그램 설치에 필요한 준비를 하는 코드를 적는다.
}
static void copyFiles() {
/* 파일들을 복사하는 코드를 적는다. */ }
static void deleteTempFiles() {
/* 임시파일들을 삭제하는 코드를 적는다.. */ }
}이 예제가 하는 일은 프로그램설치를 위한 준비를 하고 파일들을 복사하고 설치가완료되면, 프로그램을 설치하는데 사용된 임시파일들을 삭제하는 순서로 진행된다. 프로그램의 설치과정 중에 예외가 발생하더라고, 설치에 사용된 임시파일들이 삭제되도록 catch블럭에 deleteTempFiles()메서드를 넣었다. 결국 try블럭의 문장을 수행하는 동안에(프로그램을 설치한는 과정에), 예외의 발생여부에 관계없이 deleteTempFiles()메서드는 실행되어야 하는 것이다. 이럴때 finally블럭을 사용하면 좋다.
class FinallyTest2 {
public static void main(String args[]) {
try {
startInstall(); // 프로그램에 설치된 필요한 준비를 한다.
copyFiles(); // 파일들을 복사한다.
} catch (Exception e) {
e.printStackTrace();
} finally {
deleteTempFiles(); // 프로그램 설치에 사용된 임시파일들을 삭제한다.
} // try-catch�� ��
} // main�� ��
static void startInstall() {
// 프로그램 설치에 필요한 준비를 하는 코드를 적는다.
}
static void copyFiles() {
/* 파일들을 복사하는 코드를 적는다. */ }
static void deleteTempFiles() {
/* 임시파일들을 삭제하는 코드를 적는다.. */ }
}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������ ��
}위의 결과에서 알 수 있듯이 try블럭에서 return문이 실행되는 경우에도 finally블럭의 문장들이 실행된 후에, 현재 실행 중인 메서드를 종료한다. 이와 마찬가지로 catch블럭의 문장 수행 중에 return문을 만나도 finally블럭의 문장들은 수행된다.
자동 자원 반환 -try-with-resources문
JDK1.7부터 try-with-resources문이라는 try-catch문의 변형이 새로 추가되었다. 이구문은 주로 입출력(I/O)과 관련된 클래스를 사용할 때 유용하다. 주로 입출력에 사용되는 클래스 중에서는 사용한 후에 꼭 닫아 줘야 하는 것들이 있다. 그래야 사용했던 자원(resources)이 반환되기 때문이다.
try{
fis = new FileInputStream("score.dat");
dis = new DataInputStream(fis);
} catch(IOException ie){
ie.printStackTrace();
} finally {
dis.close(); //직업 중에 예외가 발생하더라도, dis가 닫히도록 finally블럭에 넣음
}위의 코드는 DataInputStream을 사용해서 파일로부터 데이터를 읽는 도중에 예외가 발생하더라도 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();
}
}finally블럭 안에 try-catch문을 추가해서 close()에서 발생할 수 있는 예외를 처리하도록 변경했는데, 코드가 복잡해져서 별로 보기에 좋지 않다. 더 나쁜 것은 try블럭과 finally블럭에서 모두 예외가 발생하면, try블럭의 예외는 무시된다는 것이다.
이러한 점을 개선하기 위해서 try-with-resources문이 추가된 것이다. 위의 코드를 try-with-resouces문으로 바꾸면 다음 과같다.
try(FileInputStream fis = new FileInputStream("score.dat");
DataInputStream dis = new DataInputStream(fis)) {
while(true) {
score = dis.readInt();
System.out.println(score);
sum += score;
}
} catch(EOFException e) {
System.outprintln("점수의 총합은 " + sum + "입니다.");
} catch(IOException ie) {
ie.printStackTrace();
}try-with-resources문의 괄호() 안에 객체를 생성하는 문장을 넣으면, 이 객체는 따로 close()를 호출하지 않아도 try블럭을 벗어나는 순간 자동적으로 close()가 호출된다. 그다음에 catch블럭 또는 finally블럭이 수행된다.
이처럼 try-with-resources문에 의해 자동으로 객체의 close()가 호출될 수 있으려면, 클래스가 AutoCloseable이라는 인터페이스를 구현한 것이어야만 한다.
public interface AutoCloseable {
void vlose() throws Exception;
}위의 인터페이스는 각 클래스에서 적절히 자원 반환작ㅇ버을 하도록 구현되어 있다. 그런데 위의 코드를 잘 보면 close()도 Exception을 발생시킬 수 있다 .만일 자동 호출된 close()에서 예외가 발생하면 어떻게 될까? 일단 예제를 먼저 실행해보자.
class TryWithResourceEx {
public static void main(String args[]) {
try (CloseableResource cr = new CloseableResource()) {
cr.exceptionWork(false); // 예외가 발생하지 않는다.
} catch(WorkException e) {
e.printStackTrace();
} catch(CloseException e) {
e.printStackTrace();
}
System.out.println();
try (CloseableResource cr = new CloseableResource()) {
cr.exceptionWork(true); // 예외가 발생한다.
} catch(WorkException e) {
e.printStackTrace();
} catch(CloseException e) {
e.printStackTrace();
}
} // main�� ��
}
class CloseableResource implements AutoCloseable {
public void exceptionWork(boolean exception) throws WorkException {
System.out.println("exceptionWork("+exception+")");
if(exception)
throw new WorkException("WorkException발생!!!");
}
public void close() throws CloseException {
System.out.println("close()가 호출됨.");
throw new CloseException("CloseException발생!!!");
}
}
class WorkException extends Exception {
WorkException(String msg) { super(msg); }
}
class CloseException extends Exception {
CloseException(String msg) { super(msg); }
}exceptionWork(false)
close()가 호출됨.
CloseException: CloseException발생!!!
at CloseableResource.close(TryWithResourceEx.java:33)
at TryWithResourceEx.main(TryWithResourceEx.java:6)
exceptionWork(true)
close()가 호출됨.
WorkException: WorkException발생!!!
at CloseableResource.exceptionWork(TryWithResourceEx.java:28)
at TryWithResourceEx.main(TryWithResourceEx.java:14)
Suppressed: CloseException: CloseException발생!!!
at CloseableResource.close(TryWithResourceEx.java:33)
at TryWithResourceEx.main(TryWithResourceEx.java:15)main 메서드에 두 개의 try-catch문이 있는데, 첫 번째 건은 close()에서만 예외를 발생 시키고, 두 번재 것은 exceptionWork()와 close()에서 모두 예외를 발생시킨다. 첫 번째는 일반적인 예외가 발생했을 때와 같은 형태로 출력되었지만, 두 번째는 출력형태가 다르다, 먼저 exceptionWork()에서 발생한 예외에 대한 내용이 출력되고, close()에서 발생한 예외는 `억제된(suppressed)`이라는 의미의 머리말과 함께 출력되었다. 두 예외가 동시에 발생할 수는 없기 떄문에, 실제 발생하 예외를 WorkException으로 하고, CloseException은 억제된 예외로 다룬다. 억제된 예외에 대한 정보는 실제로 발생한 예외인 WorkException에 저장된다. Throwable에는 억제된 예외와 관련된 다음과 같은 메서드가 정의되어 있다.
void addSuppressed(Throwable exception) 억제된 예외를 추가
Throwable[] getSuppressed() //억제된 예외(배열)를 반환만일 기존의 try-catch문을 사용했다면, 먼저 발생한 WorkException은 무시되고, 마지막으로 발생한 CloseException에 대한 내용만 출력되었을 것이다.