์๋ฐ์ ์ ์ 8์ฅ: ์์ธ์ฒ๋ฆฌ
[ ์ถ์ฒ ]
์๋ฐ์ ์ ์:
https://product.kyobobook.co.kr/detail/S000001550352
์๋ฐ์ ์ ์ ์ ํ๋ธ:
https://www.youtube.com/playlist?list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp

8-1. ํ๋ก๊ทธ๋จ ์ค๋ฅ
2) ๋ฐํ์ ์๋ฌ(runtime error) : ์คํํ ๋ ๋ฐ์ํ๋ ์๋ฌ
3) ๋ ผ๋ฆฌ์ ์๋ฌ(logical error) : ์์ฑ ์๋์ ๋ค๋ฅด๊ฒ ๋์
public class ExceptionTest {
public static void main(String[] args) {
system.out.println(args[0]); // ์ปดํ์ผ ์๋ฌ
}
}
์ปดํ์ผ ์๋ฌ
์ปดํ์ผ ์๋ฌ๊ฐ ๋ฐ์ํ์ ๊ฒฝ์ฐ์ class ํ์ผ์ด ๋ง๋ค์ด์ง์ง ์์ ์คํ์ด ๋ถ๊ฐ๋ฅํ๋ค.
javac.exe : ์๋ฐ ์ปดํ์ผ๋ฌ

<์ปดํ์ผ๋ฌ์ ์ญํ >
- ๊ตฌ๋ฌธ์ฒดํฌ : ๋ฌธ๋ฒ์ ๋ง๋์ง ํ์ธ
๋ฒ์ญ
: ์๊ฐ ํต์ฌ์ด๋ค.
- ์ต์ ํ
ex)
int i = 3 + 4;
โ
int i = 7;
- ์๋ต๋ ์ฝ๋ ์ถ๊ฐ
ex)
extends Object
๋ฐํ์ ์๋ฌ
์ปดํ์ผ์ ๋์์ง๋ง ์คํ ๋์ค์ ์๋ฌ๊ฐ ๋ฐ์ํด ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋๋ค.

๋ฌธ๋ฒ์๋ ๋ง์ง๋ง JVM์ด ์ฝ๋๋ฅผ ์คํํ๋ค๋ณด๋ฉด ๋ฌธ์ ๊ฐ ์๊ธธ ์ ์๋ค.
compile-time์ ํ๋ก๊ทธ๋จ์ ๋ค ์ฒดํฌํ ์ ์๋ค. ๊ธฐ๋ณธ์ ์ธ ๊ฒ๋ง ์ฒดํฌํ๊ธฐ ๋๋ฌธ์ ์ปดํ์ผ ํ ๋ ๋ฌธ์ ๊ฐ ์์๋ค๊ณ ์คํ ์์ ๋ฌธ์ ๊ฐ ์๋ ๊ฒ์ด ์๋๋ค.
๋ ผ๋ฆฌ์ ์๋ฌ
ํ๋ก๊ทธ๋จ ์ข ๋ฃ X ๋ด๊ฐ ์ํ๋, ์๋ํ๋๋ก ๋์ํ์ง ์๋ ๊ฒ์ด๋ค.
ex) ์ฌ๊ณ ๊ด๋ฆฌ ํ๋ก๊ทธ๋จ์์ ์ฌ๊ณ ๊ฐ ์์๋ก ๋ณด์ฌ์ง
Java์ ๋ฐํ์ ์๋ฌ
์์ธ(exception) : ํ๋ก๊ทธ๋จ ์ฝ๋์ ์ํด์ ์์ต๋ ์ ์๋ ๋ค์ ๋ฏธ์ฝํ ์ค๋ฅ
์๋ฌ(error)๋ ์ด์ฉ ์ ์์ง๋ง, ์์ธ(exception)๋ ์ฒ๋ฆฌํ์.
์์ธ์ฒ๋ฆฌ(exception handling)์ ์ ์์ ๋ชฉ์
๋ชฉ์ ํ๋ก๊ทธ๋จ์ ๋น์ ์ ์ข ๋ฃ๋ฅผ ๋ง๊ณ , ์ ์์ ์ธ ์คํ์ํ๋ฅผ ์ ์งํ๋ ๊ฒ
8-2 ์์ธ ํด๋์ค์ ๊ณ์ธต ๊ตฌ์กฐ

8-3 Exception๊ณผ RuntimeException
RuntimeException๊ณผ ๊ทธ ์์๋ค : ํ๋ก๊ทธ๋๋จธ์ ์ค์๋ก ๋ฐ์ํ๋ ์์ธ

* ์ ๋ฆฌ

8-4 ์์ธ ์ฒ๋ฆฌํ๊ธฐ, try-catch๋ฌธ
์ ์ ํ๋ก๊ทธ๋จ ์คํ ์ ๋ฐ์ํ ์ ์๋ ์์ธ์ ๋ฐ์์ ๋๋นํ ์ฝ๋๋ฅผ ์์ฑํ๋ ๊ฒ
๋ชฉ์ ํ๋ก๊ทธ๋จ์ ๋น์ ์ ์ข ๋ฃ๋ฅผ ๋ง๊ณ , ์ ์์ ์ธ ์คํ์ํ๋ฅผ ์ ์งํ๋ ๊ฒ
try {
// ์์ธ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์๋ ๋ฌธ์ฅ๋ค์ ๋ฃ๋๋ค.
} catch (Exception e1) {
// Exception1์ด ๋ฐ์ํ์ ๊ฒฝ์ฐ, ์ด๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํ ๋ฌธ์ฅ์ ์ ๋๋ค.
} catch (Exception e2) {
// Exception2์ด ๋ฐ์ํ์ ๊ฒฝ์ฐ, ์ด๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํ ๋ฌธ์ฅ์ ์ ๋๋ค.
} catch (Exception eN) {
// ExceptionN์ด ๋ฐ์ํ์ ๊ฒฝ์ฐ, ์ด๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํ ๋ฌธ์ฅ์ ์ ๋๋ค.
}
๋ฐ์ํ ์ ์๋ ์์ธ๊ฐ ์ฌ๋ฌ๊ฐ์ผ ์ ์๊ธฐ ๋๋ฌธ์ catch ๋ธ๋ญ์ ์ฌ๋ฌ๊ฐ ์์ฑ์ด ๊ฐ๋ฅํ๋ค.
8-5 try-catch๋ฌธ์์์ ํ๋ฆ
- try๋ธ๋ญ ๋ด์์ ์๋ฌ๊ฐ ๋ฐ์ํ ๊ฒฝ์ฐ,
1) ๋ฐ์ํ ์์ธ์ ์ผ์นํ๋ catch ๋ธ๋ญ์ด ์๋์ง ํ์ธํ๋ค.
2) ์ผ์นํ๋ catch ๋ธ๋ญ์ ์ฐพ๊ฒ ๋๋ฉด, ๊ทธ catch ๋ธ๋ญ ๋ด์ ๋ฌธ์ฅ๋ค์ ์ํํ๊ณ ์ ์ฒด try-catch ๋ฌธ์ ๋น ์ ธ๋๊ฐ์ ๊ทธ ๋ค์ ๋ฌธ์ฅ์ ๊ณ์ํด์ ์ํํ๋ค. ๋ง์ผ ์ผ์นํ๋ catch ๋ธ๋ญ์ ์ฐพ์ง ๋ชปํ๋ฉด, ์์ธ๋ ์ฒ๋ฆฌ๋์ง ๋ชปํ๋ค.
- try๋ธ๋ญ ๋ด์์ ์์ธ๊ฐ ๋ฐ์ํ์ง ์์ ๊ฒฝ์ฐ,
1) catch ๋ธ๋ญ์ ๊ฑฐ์น์ง ์๊ณ ์ ์ฒด try-catch๋ฌธ์ ๋น ์ ธ๋๊ฐ์ ์ํ์ ๊ณ์ํ๋ค.
class Ex8_1 {
public static void main(String[] args) {
System.out.println(1);
try {
System.out.println(2);
System.out.println(3);
} catch (Exception e) {
System.out.println(4);
} // try-catch์ ๋
System.out.println(5);
}
}
// ========== ์คํ๊ฒฐ๊ณผ ============ //
1
2
3
4
class Ex8_1 {
public static void main(String[] args) {
System.out.println(1);
try {
System.out.println(0/0); // ์์ธ๋ฐ์
System.out.println(2);
} catch (ArithmeticException ae) {
System.out.println(3);
} // try-catch์ ๋
System.out.println(4);
}
}
// ========== ์คํ๊ฒฐ๊ณผ ============ //
1
3
4
8-6 ์์ธ์ ๋ฐ์๊ณผ catch๋ธ๋ญ
- ์์ธ๊ฐ ๋ฐ์ํ๋ฉด, ์ด๋ฅผ ์ฒ๋ฆฌํ catch๋ธ๋ญ์ ์ฐพ์ ๋ด๋ ค๊ฐ
- ์ผ์นํ๋ catch๋ธ๋ญ์ด ์์ผ๋ฉด, ์์ธ๋ ์ฒ๋ฆฌ ์๋จ
- Exception์ด ์ ์ธ๋ catch๋ธ๋ญ์ ๋ชจ๋ ์์ธ ์ฒ๋ฆฌ(๋ง์ง๋ง catch๋ธ๋ญ)
class Ex8_4 {
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) {
if(ae instanceof ArithmeticException)
System.out.println("true");
System.out.println("ArithmeticException");
} catch (Exception e) { // ArithmeticException์ ์ ์ธํ ๋ชจ๋ ์์ธ๊ฐ ์ฒ๋ฆฌ๋๋ค.
System.out.println("Exception");
}
System.out.println(6);
}
}
8-7 printStackTrace()์ getMessage()
์์ธ ๋ฉ์์ง๋ฅผ ํ๋ฉด์ ์ถ๋ ฅํ๋ค.
getMessage() ๋ฐ์ํ ์์ธํด๋์ค์ ์ธ์คํด์ค์ ์ ์ฅ๋ ๋ฉ์์ง๋ฅผ ์ป์ ์ ์๋ค.

์์ธ ๋ฐ์ ์ ์์ธ ๊ฐ์ฒด๊ฐ ์์ฑ๋๋ค. ์ด ๊ฐ์ฒด์๋ ๋ฐ์ํ ์์ธ์ ๋ํ ์ ๋ณด๊ฐ ๋ค์ด์๋ค. printStackTrace()๊ณผ getMessage()๊ฐ์ ๋ฉ์๋๋ค์ ํตํด ์ด ์ ๋ณด๋ค์ ๊ฐ์ ธ์ฌ ์ ์๋ค.
8-8 ๋ฉํฐ catch ๋ธ๋ญ
- ๋ด์ฉ์ด ๊ฐ์ catch ๋ธ๋ญ์ ํ๋๋ก ํฉ์น ๊ฒ(JDK 1.7๋ถํฐ)
try {
...
} catch (Exception e) {
e.printStackTrace();
} catch (ExceptionB e2) {
e.printStackTrace();
}
โ
try {
...
// ๋ด์ฉ ๋์ผ ์ค๋ณต ์ ๊ฑฐ
} catch (Exception | ExceptinoB e) {
e.printStackTrace();
}
Example case1
๋ถ๋ชจ ์์ ๊ด๊ณ์ catch ๋ธ๋ญ์ ๋ฉํฐ catch ๋ธ๋ญ ์ฌ์ฉ ๋ถ๊ฐ
try {
...
// } catch (ParentException | ChildExcpetion e) { // ์๋ฌ!
} catch (ParentException e) {
e.printStackException();
}
Example case2
ExceptionA์ ExceptionB์ ๊ณตํต๋ฉค๋ฒ๋ง ์ฌ์ฉ ๊ฐ๋ฅ
try {
} catch (Exception A | ExceptionB e) {
e.methodA(); // ์๋ฌ. ExceptionA์ ์ ์ธ๋ methodA()๋ ํธ์ถ๋ถ๊ฐ
if(e instanceof ExceptionA) {
ExceptionA e1 = (ExceptionA)e;
e1.methodA(); // OK. ExceptionA์ ์ ์ธ๋ ๋ฉ์๋ ํธ์ถ๊ฐ๋ฅ
} else { // if(e instanceof ExceptionB)
...
}
}
8-9 ์์ธ ๋ฐ์์ํค๊ธฐ
- ์ฐ์ฐ์ new๋ฅผ ์ด์ฉํด์ ๋ฐ์์ํค๋ ค๋ ์์ธ ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ๋ง๋ ๋ค์
Exception e = new Exception(โ๊ณ ์๋ก ๋ฐ์์์ผฐ์โ);
- ํค์๋ throw๋ฅผ ์ด์ฉํด์ ์์ธ๋ฅผ ๋ฐ์์ํจ๋ค.
throw e;
// ์์ 8-6
public class Ex8_6 {
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("ํ๋ก๊ทธ๋จ์ด ์ ์ ์ข
๋ฃ๋์์");
}
}
8-10 checked ์์ธ, unchecked ์์ธ
- checked ์์ธ : ์ปดํ์ผ๋ฌ๊ฐ ์์ธ ์ฒ๋ฆฌ ์ฌ๋ถ๋ฅผ ์ฒดํฌ(์์ธ ์ฒ๋ฆฌ ํ์)
- unchecked ์์ธ : ์ปดํ์ผ๋ฌ๊ฐ ์์ธ ์ฒ๋ฆฌ ์ฌ๋ถ๋ฅผ ์ฒดํฌ ์ํจ(์์ธ ์ฒ๋ฆฌ ์ ํ)

RuntimeException๊ณผ ๊ทธ ์์๋ค์ด unchecked ์์ธ์ธ ์ด์
try {
int[] arr = new int[10];
System.out.println(arr[0]);
} catch (ArrayIndexOutOfBoundsException ae) {
} catch(NullPointerException ne) {
}
๋ชจ๋ ์ฐธ์กฐ๋ณ์๋ฅผ ์ฌ์ฉํ ๋ NPE๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์๊ณ ๋ฐฐ์ด์ ๊ฒฝ์ฐ ArrayIndexOutOfBoundsException๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์กด์ฌํ๊ธฐ ๋๋ฌธ์ ์ ๋ถ try catch๋ก ๋ฌถ์ด์ค์ผ ํ๋ค.
๊ทธ๋์ RuntimeException์ด ๋ฐ์ํ ์ ์๋ ์ฝ๋๋ค์ ์์ธ์ฒ๋ฆฌ๋ฅผ ์ ํํ ์ ์๋๋ก ํ์๋ค. ์ด๊ฒ์ด ํ์๊ฐ ๋ ๊ฒฝ์ฐ ๊ฑฐ์ ๋ชจ๋ ์ฝ๋์ try catch๊ฐ ์์ด์ผ ํ๊ธฐ ๋๋ฌธ
// ์์ 8-7
try {
// Exception๊ณผ ๊ทธ ์์์ ๋ฐ๋์ ์์ธ์ฒ๋ฆฌ๋ฅผ ํด์ค์ผ ํ๋ค.(ํ์)
throw new Exception(); // Exception์ ๊ณ ์๋ก ๋ฐ์์ํจ๋ค.
} catch (Exception e) {
}
// RuntimeException๊ณผ ๊ทธ ์์์ ์์ธ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ์ง ์์๋ ์ปดํ์ผ์ด ๋๋ค.
throw new RuntimeException();
8-11 ๋ฉ์๋์ ์์ธ ์ ์ธํ๊ธฐ
- ์์ธ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ
- try-catch๋ฌธ(์ง์ ์ฒ๋ฆฌ)
- ์์ธ ์ ์ธํ๊ธฐ(๋ ๋๊ธฐ๊ธฐ, ์๋ฆฌ๊ธฐ)
- ๋ฉ์๋๊ฐ ํธ์ถ ์ ๋ฐ์๊ฐ๋ฅํ ์์ธ๋ฅผ ํธ์ถํ๋ ์ชฝ์ ์๋ฆฌ๋ ๊ฒ
throw : ์์ธ ๋ฐ์ ํค์๋
throws : ์์ธ๋ฅผ ๋ฉ์๋์ ์ ์ธ ์ ์ฐ์ด๋ ํค์๋

๋ฐ์ํ ์ ์๋ ์์ธ๋ 2๊ฐ์ง์ธ๋ฐ ์ ์์ธ ์ ์ธ์ 1๊ฐ์ง๋ง ํ์๋์ง?
๋ฉ์๋์ ์์ธ ์ ์ธ ์ checked
, unchecked
์์ธ๋ฅผ ๋ ๋ค ์ ์ด๋ ๋์ง๋ง, ์์ธ์ ์ธ์ checked
๋ง ์ ๋ ๊ฒ์ด ์ ์์ด๋ค. unchecked
๋ ์ ์ง ์์
// ์์ 8-9
class Ex8_9 {
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 Ex8_9.method2(Ex8_9.java:11)
at Ex8_9.method1(Ex8_9.java:7)
at Ex8_9.main(Ex8_9.java:3)
์๋ JVM์ ๊ธฐ๋ณธ์์ธ์ฒ๋ฆฌ๊ธฐ๊ฐ ์ถ๋ ฅํ ๋ด์ฉ์ด๋ค.(printStackTrace();
) โ ์์ธ๊ฐ ๋ฐ์ํ ๋น์์ ๋ด์ฉ์ด ๋ด๊ฒจ์๋ค.
์์ธ ์ ์ธ์ ์์ ์ ํธ์ถํ ๋ฉ์๋์๊ฒ ์์ธ๋ฅผ ๋ ๋๊ธฐ๋ ๊ฒ์ด์ง ์ฒ๋ฆฌํ๋ ๊ฒ์ด ์๋๋ค. ์์ธ๊ฐ ์ฒ๋ฆฌ๋๋ ค๋ฉด try-catch๋ฌธ์ด ์์ด์ผํ๋ค.
// ์์ 8-10
class Ex8_10 {
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ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ๋ง๋ ๋ค.
// File๊ฐ์ฒด์ createNewFile๋ฉ์๋๋ฅผ ์ด์ฉํด์ ์ค์ ํ์ผ์ ์์ฑํ๋ค.
f.createNewFile();
return f; // ์์ฑ๋ ๊ฐ์ฒด์ ์ฐธ์กฐ๋ฅผ ๋ฐํํ๋ค.
} // createFile๋ฉ์๋์ ๋
} // ํด๋์ค์ ๋
์ด ์์ธ๋ ์์ ์ ์ํจ ๋ฉ์๋๊ฐ ์ฒ๋ฆฌํ๋ ๊ฒ ๋ง๋์ง, ์์ ์ ์ํํ๋ ๋ฉ์๋๊ฐ ์ฒ๋ฆฌํ๋ ๊ฒ์ด ๋ง๋ ๊ฑด์ง์ ๋ฐ๋ผ try-catch ๋ธ๋ญ์ ์ด๋์ ๋์์ง ๊ฒฐ์ ํ๋ฉด ๋๋ค.
8-14 finally ๋ธ๋ญ
- ์์ธ ๋ฐ์์ฌ๋ถ์ ๊ด๊ณ์์ด ์ํ๋์ด์ผ ํ๋ ์ฝ๋๋ฅผ ๋ฃ๋๋ค.
try {
// ์์ธ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์๋ ๋ฌธ์ฅ๋ค์ ๋ฃ๋๋ค.
} catch (Exception e1) {
// ์์ธ์ฒ๋ฆฌ๋ฅผ ์ํ ๋ฌธ์ฅ์ ์ ๋๋ค.
} finally {
// ์์ธ์ ๋ฐ์์ฌ๋ถ์ ๊ด๊ณ์์ด ํญ์ ์ํ๋์ด์ผํ๋ ๋ฌธ์ฅ๋ค์ ๋ฃ๋๋ค.
// finally ๋ธ๋ญ์ try-catch ๋ฌธ์ ๋งจ ๋ง์ง๋ง์ ์์นํด์ผํ๋ค.
}
try {
startInstall();
copyFiles();
deleteTempFiles(); // ์ฝ๋ ์ค๋ณต
} catch (Exception e) {
e.printStackTrace();
deleteTempFiles(); // ์ฝ๋ ์ค๋ณต
} // try-catch์ ๋
์ค์น๊ฐ ์ ๋ผ๋ ์์ํ์ผ์ ์ญ์ ํด์ผ ํ๊ณ ์ค์น ์ค๊ฐ์ ์์ธ๊ฐ ๋ฐ์ํด๋ ์์ํ์ผ์ ์ญ์ ๋์ด์ผ ํ๋ค.
โ
try {
startInstall();
copyFiles();
} catch (Exception e) {
e.printStackTrace();
} finally {
deleteTempFiles(); // ์ฝ๋ ์ค๋ณต ์ ๊ฑฐ
} // try-catch์ ๋
์๋ ์์ ๋ฐํ - try-with-resources๋ฌธ
try (FileInputStream fis = new FileInputStream("score.dat");
DataInputStream dis = new DataInputStream(fis)) {
while (true) {
score = dis.readInt();
System.out.println(score);
sum += socre;
}
} catch (EOFException e) {
System.out.println("์ ์์ ์ดํฉ์ " + sum + "์
๋๋ค.");
} catch (IOException ie) {
ie.printStackTrace();
}
try-with-resources ๋ฌธ์ ๊ดํธ()์์ ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ ๋ฌธ์ฅ์ ๋ฃ์ผ๋ฉด, try ๋ธ๋ญ์ ๋ฒ์ด๋๋ ์๊ฐ ์๋์ ์ผ๋ก close()๊ฐ ํธ์ถ๋๋ค. ๊ทธ ๋ค์์ catch๋ธ๋ญ ๋๋ finally ๋ธ๋ฝ์ด ์ํ๋๋ค.
I/O ๊ด๋ จ ํด๋์ค ์ฌ์ฉ์ ์ ์ฉํจ
์๋ฐ์์ ์์ธ์ฒ๋ฆฌ๋ฅผ ํ๋ ๋ฐฉ๋ฒ์ ๋ํ ์ค๋ช ๊ณผ, ์์ธ ๋๋์ง๊ธฐ, ์ฐ๊ฒฐ๋ ์์ธ์ ๋ํ ๋ด์ฉ์ ๋ค๋ฃจ๊ณ ์๋ค. ์ฐ๊ฒฐ๋ ์์ธ๋ ์ฌ๋ฌ ์์ธ๋ฅผ ํ๋๋ก ๋ฌถ์ด์ ์ฒ๋ฆฌํ๊ฑฐ๋ checked ์์ธ๋ฅผ unchecked ์์ธ๋ก ๋ณ๊ฒฝํ ๋ ์ฌ์ฉ๋๋ค. ์ฐ์ต๋ฌธ์ ๋ ํฌํจ๋์ด ์๋ค.
์๋ฐ์์ ์์ธ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๋ํด ์ค๋ช ํ ๋ฌธ์์ ๋๋ค. ์์ธ ๋๋์ง๊ธฐ์ ์ฐ๊ฒฐ๋ ์์ธ์ ๋ํ ๋ด์ฉ๋ ํฌํจ๋์ด ์์ต๋๋ค. ์ฐ์ต๋ฌธ์ ๋ ํฌํจ๋์ด ์์ต๋๋ค.
8-15 ์ฌ์ฉ์ ์ ์ ์์ธ ๋ง๋ค๊ธฐ
- ์ฐ๋ฆฌ๊ฐ ์ง์ ์์ธ ํด๋์ค๋ฅผ ์ ์ํ ์ ์๋ค.
- ์กฐ์์
Exception
๊ณผRuntimeException
์ค์์ ์ ํ
์ ํ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅํ๋ฉด RuntimeException์ ์กฐ์์ผ๋ก ํ๋ ๊ฒ์ด ์ข๋ค.
class MyException extends Exception { // ํ์์ฒ๋ฆฌ ์์ธ
MyException(String msg) { // ๋ฌธ์๋ฅผ ๋งค๊ฐ๋ณ์๋ก ๋ฐ๋ ์์ฑ์
super(msg); // ์กฐ์์ธ Exception ํด๋์ค์ ์์ฑ์๋ฅผ ํธ์ถํ๋ค.
}
}
<๊ท์น, ํฌ์ธํธ>
Exception
๊ณผRuntimeException
์ค์์ ์กฐ์์ ์ ํํ๋ค.
String
๋งค๊ฐ๋ณ์๊ฐ ์๋ ์์ฑ์๋ฅผ ๋ง๋ ๋ค.
8-17 ์์ธ ๋๋์ง๊ธฐ(exception re-throwing)
- ์์ธ๋ฅผ ์ฒ๋ฆฌํ ํ์ ๋ค์ ์์ธ๋ฅผ ๋ฐ์์ํค๋ ๊ฒ
- ํธ์ถํ ๋ฉ์๋์ ํธ์ถ๋ ๋ฉ์๋ ์์ชฝ ๋ชจ๋์์ ์์ธ์ฒ๋ฆฌํ๋ ๊ฒ
public class Ex8_12 {
public static void main(String[] args) {
try {
method1();
} catch (Exception e) { // 4. ์์ธ ์ฒ๋ฆฌ
System.out.println("main ๋ฉ์๋์์ ์์ธ๊ฐ ์ฒ๋ฆฌ๋์์ต๋๋ค.");
}
}
static void method1() throws Exception {
try {
throw new Exception(); // 1. ์์ธ ๋ฐ์
} catch (Exception e) { // 2. ์์ธ ์ฒ๋ฆฌ
System.out.println("method1 ๋ฉ์๋์์ ์์ธ๊ฐ ์ฒ๋ฆฌ๋์์ต๋๋ค.");
throw e; // 3. ๋ค์ ์์ธ ๋ฐ์
}
}
}
<์์ธ์ฒ๋ฆฌ ๋ฐฉ๋ฒ>
- ํธ์ถ๋ ๋ฉ์๋์์ ์์ธ์ฒ๋ฆฌ
- ํธ์ถํ ๋ฉ์๋์์ ์์ธ์ฒ๋ฆฌ
- ํธ์ถํ ๋ฉ์๋์ ํธ์ถ๋ ๋ฉ์๋ ์์ชฝ์์ ๋ชจ๋ ์์ธ์ฒ๋ฆฌ
8-18 ์ฐ๊ฒฐ๋ ์์ธ(chained exception)
- ํ ์์ธ๊ฐ ๋ค๋ฅธ ์์ธ๋ฅผ ๋ฐ์์ํฌ ์ ์๋ค.
- ์์ธ A๊ฐ ์์ธ B๋ฅผ ๋ฐ์์ํค๋ฉด A๋ B์ ์์ธ ์์ธ(cause exception)
A์ B๋ฅผ ์ฐ๊ฒฐํ๋ ๊ฒ์ ์ฐ๊ฒฐ๋ ์์ธ๋ผ๊ณ ํ๋ค. ์ด ๋์ ์ฐ๊ฒฐ์ํค๋๋ฐ ์ฌ์ฉ๋๋ ๋ฉ์๋๊ฐ initCause()๋ค.
Throwable getCause() ์์ธ ์์ธ๋ฅผ ๋ฐํ
Throwable์ Exception๊ณผ Error์ ์กฐ์ ํด๋์ค
public class Throwable implements Serializable {
...
// ์์ธ ์์ธ๋ฅผ ์ ์ฅํ๊ธฐ ์ํ iv
private Throwable cause = this; // ๊ฐ์ฒด ์์ (this)์ ์์ธ ์์ธ๋ก ๋ฑ๋ก
...
public synchronized Throwable initCause(Throwable cuase) {
...
this.cuase = cause; // cause๋ฅผ ์์ธ ์์ธ๋ก ๋ฑ๋ก
return this;
}
...
}
์ฐ๊ฒฐ๋ ์์ธ : ํ๋์ ์์ธ ์์ ๋ ๋ค๋ฅธ ์์ธ๋ฅผ ํฌํจ์ํค๋ ๊ฒ
์์ธ A๊ฐ B๋ผ๋ ์์ธ๋ฅผ ๋ง๋ฆ
์์ธ ์์ธ : A
์ค์ ๋ก ๋ฐ์ํ ๊ฒ์ SpaceException์ธ๋ฐ InstallException๋ฅผ ๋ง๋ค์ด ๊ทธ ์์ ๋ฃ์ด์ค ๊ฒ ์ด๋ด ๋ ๋ ์์ธ๋ฅผ ์ฐ๊ฒฐ๋ ์์ธ๋ผ๊ณ ํ๋ค.
[์ด์ 1] ์ฌ๋ฌ ์์ธ๋ฅผ ํ๋๋ก ๋ฌถ์ด์ ๋ค๋ฃจ๊ธฐ ์ํด์
try {
install();
} catch(SpaceException e) {
e.printStackTrace();
} catch(MemoryException e) {
e.printStackTrace();
} catch(Exception e) {
e.printStackTrace();
} // catch ๋ธ๋ฝ์ด ๋๋ฌด ๋ง์์ง

โ
void install() throws InstallException {
try {
startInstall(); // SpaceException(์ ์ฅ๊ณต๊ฐ ๋ถ์กฑ) ๋ฐ์
copyFiles();
} catch (SpaceExceptioin e) { // ์์ธ A
InstallException ie = new InstallException("์ค์น์ค ์์ธ๋ฐ์"); // ์์ธ B ์์ฑ
ie.initCause(e); // InstallException์ ์์ธ ์์ธ๋ฅผ SpaceException์ผ๋ก ์ง์
throw ie; // InstallException์ ๋ฐ์์ํจ๋ค.
} catch(MemoryException me) {
InstallException ie = new InstallException("์ค์น์ค ์์ธ๋ฐ์");
ie.initCause(e);
throw ie;
}
}
์ธ๋ถ์ ์ธ ์์ธ์ฒ๋ฆฌ๋ ์์ผ๋ก ์ง์ด๋๊ณ InstallException ํ๋๋ง ๋์ง๋๋ก ์ ์ธํ ๊ฒ์ด๋ค.
์์์๋ ์์ธ์ฒ๋ฆฌ๋ฅผ ํ ๊ฒ์ด ์๋ ๋ ์์ธ๋ฅผ ์ฐ๊ฒฐํ๋ ์์ ๋ง ํ ๊ฒ์ด๋ค.
์ฒ๋ฆฌํ๋ ์ชฝ์์๋ ์ธ๋ถ์ ์ธ ์์ธ๋ฅผ ๋ฉ์๋ ์์ผ๋ก ๊ฐ์ถ ์ ์์ด ์์ธ์ฒ๋ฆฌ๊ฐ ๊ฐ๋จํด์ง๋ค.
[์ด์ 2] checked ์์ธ๋ฅผ unchecked ์์ธ๋ก ๋ณ๊ฒฝํ๋ ค ํ ๋
checked ์์ธ๋ฅผ unchecked ์์ธ๋ก ๋ฐ๊พธ๋ ์ด์ ?
โ checked ์์ธ๋ try-catch ๋ธ๋ญ์ผ๋ก ์์ธ์ฒ๋ฆฌ๋ฅผ ๋ฐ๋์ ํด์ผ ํ๋ ์ ์ฝ์ด ์๊ธฐ ๋๋ฌธ์ ์ฝ๋๊ฐ ๊ธธ์ด์ง๋ ๋ฑ ๋ถํธํ ์ ์ด ์์
static void startInstall() throws SpaceException, MemoryException {
if(!enoughSpace())
throw new SpaceException("์ค์นํ ๊ณต๊ฐ์ด ๋ถ์กฑํฉ๋๋ค.");
if(!enoughMemory())
throw new MemoryException("๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํฉ๋๋ค.");
}
class SpaceException extends Exception { // Exception == checked ์์ธ
SpaceException(String msg) {
super(msg);
}
}
SpaceException์ Exception์ ์์์ด๊ธฐ ๋๋ฌธ์ checked ์์ธ์ด๋ค. unchecked ์์ธ๋ก ๋ณ๊ฒฝํ๊ณ ์ถ์ด๋ SpaceException์ด ์ด๋ฏธ ๋ง์ด ์ฌ์ฉ๋์ด์ง๊ณ ์์ ๊ฒฝ์ฐ ์์ ๊ณ์ธต๋๋ฅผ ๋ณ๊ฒฝํ๋ ๊ฒ์ ์ฌ์ด ์์ ์ด ์๋๋ค. ์ด๋ด ๋ ์ฐ๊ฒฐ๋ ์์ธ๋ฅผ ์ด์ฉํด ๋ณ๊ฒฝํ๋ค.
โฌ๏ธ
static void startInstall() throws SpaceException {
if(!enoughSpace()) // ์ถฉ๋ถํ ์ค์น ๊ณต๊ฐ์ด ์์ผ๋ฉด...
throw new SpaceException("์ค์นํ ๊ณต๊ฐ์ด ๋ถ์กฑํฉ๋๋ค.");
if(!enoughMemory()) // ์ถฉ๋ถํ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์์ผ๋ฉด...
throw new RuntimeException(new MemoryException("๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํฉ๋๋ค.")); // ํ์ -> ์ ํ, RuntimeException์ ๋ง๋ค๊ณ ๊ทธ ์์ ์์ธ ์์ธ๋ก ๋ฑ๋ก
}
์ฐ์ต๋ฌธ์
8-1 ์์ธ์ฒ๋ฆฌ์ ์ ์์ ๋ชฉ์ ์ ๋ํด์ ์ค๋ช ํ์์ค
์โฆโฆโฆโฆโฆโฆ ์์ธ์ฒ๋ฆฌ๋
์ผ๋จ ์์ธ(Exception)๋
- Exception๊ณผ ๊ทธ ์์๋ค
- RuntimeException๊ณผ ๊ทธ ์์๋ค
์ด๋ ๊ฒ ๋ ๊ฐ์ง๋ก ์ด๋ฃจ์ด์ ธ์๋ค.
๋ชฉ์ : ํ๋ก๊ทธ๋จ์ ๋น์ ์์ ์ธ ์ข ๋ฃ๋ฅผ ๋ง๊ธฐ ์ํด์
๋ชฉ์ - ํ๋ก๊ทธ๋จ์ ๋น์ ์ ์ข ๋ฃ๋ฅผ ๋ง๊ณ , ์ ์์ ์ธ ์คํ์ํ๋ฅผ ์ ์งํ๋ ๊ฒ
8-2
๋ต : 4๋ฒ
??? 8-3
๋ต :
์ค๋ฒ๋ผ์ด๋ฉ ๊ท์น : ์กฐ์๋ณด๋ค ๋ง์ ์์ธ๋ฅผ ๊ฐ์ง ์ ์๋ค.
4) Exception์ ๋ชจ๋ ์์ธ์ ์กฐ์์ด๊ธฐ ๋๋ฌธ์ ๋ชจ๋ ์์ธ๋ฅผ ๋ฐ์ ์ ์์ด ์กฐ์๋ณด๋ค ์์ธ์ ๊ฐ์๊ฐ ๋ง์ ์๋จ
5) NumberException๊น์ง ํฌํจํด์ ์ด ์์ธ๊ฐ 3๊ฐ๋ผ ์กฐ์๋ณด๋ค ๋ง์(2๊ฐ) ์๋จ
8-4
1
3
5
1
2
5
6
8-5
3
5
8-6 ??
1
1
2
5
6
8-7
import java.util.InputMismatchException;
import java.util.Scanner;
public class Exercise8_7 {
public static void main(String[] args) {
int answer = (int) (Math.random() * 100) +1;
int input = 0;
int count = 0;
do {
count++;
System.out.println("1๊ณผ 100์ฌ์ด์ ๊ฐ์ ์
๋ ฅํ์ธ์ : ");
try {
input = new Scanner(System.in).nextInt();
} catch(InputMismatchException e) {
continue;
}
if(input < answer) {
System.out.println("๋ ํฐ ์๋ฅผ ์
๋ ฅํ์ธ์.");
}
else if(answer < input) {
System.out.println("๋ ์์ ์๋ฅผ ์
๋ ฅํ์ธ์.");
}
else {
System.out.println("๋ง์ท์ต๋๋ค.");
System.out.println("์๋ํ์๋ " + count + "๋ฒ์
๋๋ค.");
break; // do-while๋ฌธ์ ๋ฒ์ด๋๋ค.4
}
} while(true);
}
}
8-8
2
4
7
Uploaded by N2T