1~3. ํ๋ก๊ทธ๋จ ์ค๋ฅ
์ค๋ฅ์ ์ข
๋ฅ
- ์ปดํ์ผ ์๋ฌ : ์ปดํ์ผ ํ ๋ ๋ฐ์ํ๋ ์๋ฌ
- ๋ฐํ์ ์๋ฌ : ์คํ ํ ๋ ๋ฐ์ํ๋ ์๋ฌ
- ์๋ฌ : ํ๋ก๊ทธ๋จ ์ฝ๋์ ์ํด์ ์์ต๋ ์ ์๋ ์ฌ๊ฐํ ์ค๋ฅ
- ์์ธ : ํ๋ก๊ทธ๋จ ์ฝ๋์ ์ํด์ ์์ต๋ ์ ์๋ ๋ค์ ๋ฏธ์ฝํ ์ค๋ฅ
- Exception ํด๋์ค๋ค (์ธ์ ์์ธ)
- Runtime Exception ํด๋์ค๋ค (๋ด์ ์์ธ)
- ๋
ผ๋ฆฌ์ ์๋ฌ : ์์ฑ ์๋์ ๋ค๋ฅด๊ฒ ๋์
์ปดํ์ผ๋ฌ์ ์ญํ
- ๊ตฌ๋ฌธ ์ฒดํฌ
- ๋ฒ์ญ
- ์ต์ ํ
- ์๋ต๋ ์ฝ๋ ์ถ๊ฐ
์์ธ์ฒ๋ฆฌ์ ์ ์์ ๋ชฉ์
- ์ ์ : ํ๋ก๊ทธ๋จ ์คํ ์ ๋ฐ์ํ ์ ์๋ ์์ธ์ ๋ฐ์์ ๋๋นํ ์ฝ๋๋ฅผ ์์ฑํ๋ ๊ฒ
- ๋ชฉ์ : ํ๋ก๊ทธ๋จ์ ๋น์ ์ ์ข
๋ฃ๋ฅผ ๋ง๊ณ , ์ ์์ ์ธ ์คํ์ํ๋ฅผ ์ ์งํ๋ ๊ฒ
์์ธ ํด๋์ค์ ๊ณ์ธต ๊ตฌ์กฐ

Exception๊ณผ RuntimeException

- Exception ํด๋์ค๋ค : ์ธ์ ์ธ ์์ธ์ ์ํด ๋ฐ์ํ๋ ์์ธ (์ฌ์ฉ์์ ์ค์)
- RuntimeException ํด๋์ค๋ค : ๋ด์ ์ธ ์์ธ์ ์ํด ๋ฐ์ํ๋ ์์ธ (ํ๋ก๊ทธ๋๋จธ์ ์ค์)
4~6. ์์ธ ์ฒ๋ฆฌํ๊ธฐ
์์ธ ์ฒ๋ฆฌํ๊ธฐ. try-catch๋ฌธ
try {
// ์์ธ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์๋ ๊ตฌ๋ฌธ
} catch (Exception1 e1) {
// Exception1์ ์ฒ๋ฆฌํ ๊ตฌ๋ฌธ
} catch (Exception2 e2) {
// Exception2๋ฅผ ์ฒ๋ฆฌํ ๊ตฌ๋ฌธ
} catch (ExceptionN eN) {
// ExceptionN์ ์ฒ๋ฆฌํ ๊ตฌ๋ฌธ
}
์์ธ์ ๋ฐ์๊ณผ catch ๋ธ๋ญ
- ์์ธ๊ฐ ๋ฐ์ํ๋ฉด, ์ด๋ฅผ ์ฒ๋ฆฌํ catch ๋ธ๋ญ์ ์ฐพ์ ๋ด๋ ค๊ฐ
- ์ผ์นํ๋ catch ๋ธ๋ญ์ด ์์ผ๋ฉด, ์์ธ๋ ์ฒ๋ฆฌ ์๋จ
- Exception์ด ์ ์ธ๋ catch ๋ธ๋ญ์ ๋ชจ๋ ์์ธ ์ฒ๋ฆฌ (๋ง์ง๋ง catch ๋ธ๋ญ)
7~8. printStackTrace(), ๋ฉํฐ catch
printStackTrace()์ getMessage()
printStackTrace()
- ์์ธ๋ฐ์ ๋น์์ ํธ์ถ์คํ(Call Stack)์ ์์๋ ๋ฉ์๋์ ์ ๋ณด์ ์์ธ ๋ฉ์์ง๋ฅผ ํ๋ฉด์ ์ถ๋ ฅ
getMessage()
- ๋ฐ์ํ ์์ธํด๋์ค์ ์ธ์คํด์ค์ ์ ์ฅ๋ ๋ฉ์์ง๋ฅผ ๋ฐํ
try {
...
System.out.println(0/0); // ArithmeticException ์์ธ ๊ฐ์ฒด ์์ฑ
...
} catch (ArithmeticException ae) {
ae.printStackTrace();
System.out.println(ae.getMessage());
} catch (Exception e) {
...
}
๋ฉํฐ catch ๋ธ๋ญ
- ๋ด์ฉ์ด ๊ฐ์ catch ๋ธ๋ญ์ ํ๋๋ก ํฉ์น ๊ฒ (JDK 1.7๋ถํฐ)
try {
...
} catch (ExceptionA | ExceptionB e) {
e.printStackTrace();
e.methodA(); // ์๋ฌ. ExceptionA์ ExceptionB์ ๊ณตํต๋ฉค๋ฒ๋ง ์ฌ์ฉ ๊ฐ๋ฅ
} catch (ParentException | ChildException pe) { // ์๋ฌ. ๋ถ๋ชจ๋ง ์ฌ์ฉํด๋ ๋จ
}
9~10. ์์ธ ๋ฐ์์ํค๊ธฐ
์์ธ ๋ฐ์์ํค๊ธฐ
- ์ฐ์ฐ์ new๋ฅผ ์ด์ฉํด์ ๋ฐ์์ํค๋ ค๋ ์์ธ ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ๋ง๋ ๋ค์
- ํค์๋ throw๋ฅผ ์ด์ฉํด์ ์์ธ๋ฅผ ๋ฐ์์ํจ๋ค.
public class Ex8_6 {
public static void main(String[] args) {
try {
throw new Exception("๊ณ ์๋ก ๋ฐ์์์ผฐ์.");
} catch (Exception e) {
System.out.println("์๋ฌ ๋ฉ์์ง : " + e.getMessage());
e.printStackTrace();
}
System.out.println("์ ์ ์ข
๋ฃ");
}
}
checked ์์ธ, unchecked ์์ธ
- checked ์์ธ : ์ปดํ์ผ๋ฌ๊ฐ ์์ธ ์ฒ๋ฆฌ ์ฌ๋ถ๋ฅผ ์ฒดํฌ (์์ธ ์ฒ๋ฆฌ ํ์)
- Exception๊ณผ ์์๋ค (์ธ์ ์์ธ)
- unchecked ์์ธ : ์ปดํ์ผ๋ฌ๊ฐ ์์ธ ์ฒ๋ฆฌ ์ฌ๋ถ๋ฅผ ์ฒดํฌ ์ํจ (์์ธ ์ฒ๋ฆฌ ์ ํ)
- RuntimeException๊ณผ ์์๋ค (๋ด์ ์์ธ)
11~14. ์์ธ ์ ์ธํ๊ธฐ, finally ๋ธ๋ญ
๋ฉ์๋์ ์์ธ ์ ์ธํ๊ธฐ
- ์์ธ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ : try-catch๋ฌธ, ์์ธ ์ ์ธํ๊ธฐ
- ๋ฉ์๋๊ฐ ํธ์ถ ์ ๋ฐ์ ๊ฐ๋ฅํ ์์ธ๋ฅผ ํธ์ถํ๋ ์ชฝ์ ์๋ฆฌ๋ ๊ฒ
- checked ์์ธ (ํ์ ์ฒ๋ฆฌ ์์ธ) ๋ง throws ๋ก ์๋ฆผ
void method() throws Exception1, Exception2, ... ExceptionN {
// ๋ฉ์๋ ๋ด์ฉ
}
// method()์์ Exception๊ณผ ๊ทธ ์์ ์์ธ ๋ฐ์ ๊ฐ๋ฅ
void method() throws Exception {
// ๋ฉ์๋ ๋ด์ฉ
}
static void startInstall() throws SpaceException, MemoryException {
if (!enoughSpace()) {
throw new SpaceException("์ค์นํ ๊ณต๊ฐ ๋ถ์กฑ");
}
if (!enoughMemory()) {
throw new MemoryException("๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ");
}
}
finally ๋ธ๋ญ
- ์์ธ ๋ฐ์ ์ฌ๋ถ์ ๊ด๊ณ ์์ด ์ํ๋์ด์ผ ํ๋ ์ฝ๋
try {
// ์์ธ ๋ฐ์ ๊ฐ๋ฅ์ฑ์ด ์๋ ๊ตฌ๋ฌธ
} catch (Exception1 e1) {
// ์์ธ ์ฒ๋ฆฌ ๊ตฌ๋ฌธ
} finally {
// ์์ธ ๋ฐ์ ์ฌ๋ถ์ ๊ด๊ณ ์์ด ์ํ๋์ด์ผ ํ๋ ๊ตฌ๋ฌธ
// try ์ catch ๋ฌธ์ ๋ชจ๋ ํด๋นํ๋ ๊ตฌ๋ฌธ
}
15~17. ์ฌ์ฉ์ ์ ์ ์์ธ
์ฌ์ฉ์ ์ ์ ์์ธ ๋ง๋ค๊ธฐ
- ์ง์ ์์ธ ํด๋์ค๋ฅผ ์ ์
- ์กฐ์์ Exception๊ณผ RuntimeException ์ค์ ์ ํ
class MyException extends Exception {
MyException(String msg) {
super(msg); // ์กฐ์์ธ Exception ํด๋์ค์ ์์ฑ์ ํธ์ถ
}
}
์์ธ ๋๋์ง๊ธฐ
- ์์ธ๋ฅผ ์ฒ๋ฆฌํ ํ์ ๋ค์ ์์ธ๋ฅผ ๋ฐ์์ํค๋ ๊ฒ
- ํธ์ถํ ๋ฉ์๋์ ํธ์ถ๋ ๋ฉ์๋ ์์ชฝ ๋ชจ๋์์ ์์ธ์ฒ๋ฆฌํ๋ ๊ฒ
public class Ex8_12 {
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;
}
}
}
18. ์ฐ๊ฒฐ๋ ์์ธ
์ฐ๊ฒฐ๋ ์์ธ
- ํ ์์ธ๊ฐ ๋ค๋ฅธ ์์ธ๋ฅผ ๋ฐ์์ํฌ ์ ์์
- ์์ธA๊ฐ ์์ธB๋ฅผ ๋ฐ์์ํค๋ฉด, A๋ B์ ์์ธ ์์ธ (cause exception)
Throwable initCause(Throwable cause) ์ง์ ํ ์์ธ๋ฅผ ์์ธ ์์ธ๋ก ๋ฑ๋ก
Throwable getCause() ์์ธ ์์ธ๋ฅผ ๋ฐํ
void install() throws InstallException {
try {
startInstall(); // SpaceException ๋ฐ์
copyFiles();
} catch (SpaceException e) {
InstallException ie = new InstallException("์ค์น์ค ์์ธ ๋ฐ์"); // ์์ธ ์์ฑ
ie.initCause(e); // InstallException์ ์์ธ ์์ธ๋ฅผ SpaceException์ผ๋ก ์ง์
throw ie; // InstallException์ ๋ฐ์์ํด
} catch (MemoryException me) {
}
}
์ด์
- ์ฌ๋ฌ ์์ธ๋ฅผ ํ๋๋ก ๋ฌถ์ด์ ๋ค๋ฃจ๊ธฐ ์ํด
try {
install(); // install ๋ฉ์๋ ์์์ Space, MemoryException์ ์ฒ๋ฆฌ
} catch(InstallException e) { // InstallException์ ์์ธ ์์ธ๋ฅผ
e.printStackTrace(); // Space, MemoryException์ผ๋ก ์ง์
}
- checked ์์ธ๋ฅผ unchecked ์์ธ๋ก ๋ณ๊ฒฝํ๋ ค ํ ๋
static void startInstall() throws SpaceException {
if (!enoughSpace()) {
throw new SpaceException("๊ณต๊ฐ ๋ถ์กฑ");
}
// RuntimeException์ ์์ธ ์์ธ๋ฅผ MemoryException์ผ๋ก ์ง์
// ํ์ ์์ธ์ฒ๋ฆฌ๋ฅผ ์ ํ ์์ธ์ฒ๋ฆฌ๋ก ๋ณ๊ฒฝ
if (!enoughMemory()) {
throw new RuntimeException(new MemoryException("๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ"));
}
}