๋ชฉ์ฐจ
โ 1. Error & Exception.
โ 2. ์์ธ(Exception)
โ 3. ์์ธ์ฒ๋ฆฌ(1) try & catch
โ 4. ์์ธ์ฒ๋ฆฌ(2) try & catch
โ 5. ์์ธ ์ฒ๋ฆฌ catch๋ฌธ ์ ์ฉํ ๋ฉ์๋
โ 6. ์์ธ ์ข ๋ฅ( CheckedException & UnCheckedException )
โ 7. final๊ตฌ๋ฌธ
โ 8. throws๊ตฌ๋ฌธ
1. Error & Exception
์๋ฐ์์๋ ๋ฌธ์ ๋ฅผ ํฌ๊ฒ Error, Exception ๋ ๊ฐ์ง๋ก ๊ตฌ๋ถ์ ํ๋ค.
1. Error
๊ฐ๋ฐ์๊ฐ ์ง์ ์ฒ๋ฆฌํ ์ ์๋ ๋ฌธ์ ๋ฅผ ์๋ฏธํ๋ค. ( ๋ฉ๋ชจ๋ฆฌ, ์ด์์ฒด์ , ํ๋์จ์ด, ์ธ๋ถ์ ์ธ ์์ธ์ผ๋ก ์๊ธฐ๋ ๋ฌธ์ )
์ฆ, ์์ ์ ํ๋ ํ๊ฒฝ์ ๋ฌธ์ ๊ฐ ์๊ธด ๊ฒ์ ์๋ฏธํ๋ฉฐ ์ด๋ฌํ ๊ฒ์ ํ๋ก๊ทธ๋จ์ ํด๊ฒฐ๋ฐฉ๋ฒ์ด ์กด์ฌํ์ง ์๋๋ค.
2. Exception
๊ฐ๋ฐ์๊ฐ ์ง์ ์ฒ๋ฆฌํ ์ ์๋ ๋ฌธ์ ๋ฅผ ์๋ฏธํ๋ค.( ํ๋ก๊ทธ๋จ์ ์ฝ๋์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ ๊ฒ์ Exception(์์ธ)๋ผ๊ณ ํ๋ค. )
์ฝ๊ฒ ๋งํด ์๋ฐ๋ก ์ง์ ์ฝ๋๋ฅผ ์ง๋ค๊ฐ ์๋ํ ๊ฒ๊ณผ ๋ค๋ฅธ ์ํฉ์ ์ง๋ฉดํ์ ๋ ์๊ธฐ๋ ๋ฌธ์ ๋ฅผ ์์ธ๋ผ๊ณ ํ๋ ๊ฒ์ ๋๋ค.
์์ ) File์ ์ฝ์ด์ค๋ ์ฝ๋๋ฅผ ์งฐ๋๋ฐ ํด๋น ํ์ผ์ด ์กด์ฌํ์ง ์๋๋ค๊ฑฐ๋, ์์๋ชปํ ๊ฐ์ ์ธ๋ถ์์ ์ ๋ ฅ ๋ฐ์๋ ์๊ธฐ๋ ๋ฌธ์
์ด๋ฌํ ์์ ๋ชปํ ๋ฌธ์ ๊ฐ ํฐ์ก์ ๋ ์๋ ค์ฃผ๋ ๊ฒ์ด ์๋ฐ์์ Exception ์ ๋๋ค.
2. ์์ธ(Exception)
// ๊ฐ์ฅ ๊ฐ๋จํ๋ฉด์ ๋ํ์ ์ธ ์ฝ๋๋ก ์์๋ฅผ ๋ณด์ฌ์ฃผ๊ฒ ์ต๋๋ค.
public static void main(String[] args) {
System.out.println(2/0); // ๊ฒฐ๊ณผ : ArithmeticException( ์ซ์๊ด๋ จ ์์ธ )
// ์๋ฐ์์๋ 0์ ๋๋๊ฒ ๋๋ฉด ์์ธ๊ฐ ๋ฐ์ํ๋ค.(์ค๋ฅ)
}
// ํด๋น ์ค๋ฅ์ ๊ฒฐ๊ณผ๋ก ์๋์ ๊ฐ์ด ์ฝ์์ ์ฐํ๊ฒ ๋๋ค.
Exception in thread "main" java.lang.ArithmeticException: / by zero
at xxx.xxxx.xxxxxxxx.main(ExceptionApp.java:2)
์ฝ๋์ ์์์์ ์ฝ์์ ๊ฒฐ๊ณผ๋ฅผ ํ์ธํด๋ณด๋ฉด java.lang.ArithmeticException์ ๊ฐ์ด ํจํค์ง ๊ฒฝ๋ก์ ํด๋์ค์
๋๋ ํ ๋ฆฌ๋ฅผ ๋ช ์๋ฅผ ํด์ฃผ๊ณ ์๋ค. ์ด ์ฒ๋ผ ์ฝ์์ ์ฐํ๋ ๋ชจ๋ ์์ธ(์ค๋ฅ)์์ฒด๋ ์๋ฐ์์ ๋ง๋ค์ด์ง ํด๋์ค
์ฆ, JRE์ ํฌํจ๋ ๋ด์ฅ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ผ๊ณ ์๊ฐํ๋ฉด ๋ ๊ฒ ์ด๋ค.
์ด๋ฌํ ์์ธ ํด๋์ค๋ ๊ฐ๋ฐ์๊ฐ ํ์ฅํ์ฌ ์ฌ์ฉ์ ์ ์ ์์ธ๋ฅผ ๋ง๋ค ์๋ ์๊ฒ ๋๋ค.
3. ์์ธ ์ฒ๋ฆฌ ( 1 )
์์ธ๋ฅผ ์ฒ๋ฆฌํ๋ ์ด์ ๋ ์๋ฐ์์ ๋ง๋ค์ด์ง ์์ธ๊ฐ ๋ฐ์ํ๋ฉด ํ๋ก๊ทธ๋จ์ ์ค๋จ์ด ๋ผ๊ธฐ ๋๋ฌธ์ ์น ์ฑ์ ๊ฒฝ์ฐ ํ๋ก๊ทธ๋จ์
์ค๋จ์ผ๋ก ๋ง์ ์ฌ์ฉ์์ ํผํด๊ฐ ๊ฐ ์ ์์ผ๋ฏ๋ก ์ด๋ฌํ ์์ธ๋ฅผ ์ฒ๋ฆฌํจ์ผ๋ก ์จ ์ง์์ ์ผ๋ก ํ๋ก๊ทธ๋จ์ด ๋์ํ ์ ์๊ฒ
๋ง๋ค์ด์ฃผ๋ ๊ฒ์ด ์ด์ ๊ฐ ๋ ์ ์๋ค. ( ์๋น์ค์ ์์ ์ฑ๊ณผ ์ ๋ขฐ์ฑ์ ์ ํดํ ์ ์์ผ๋ฏ๋ก ๋ฏธ์ฐ์ ๋ฐฉ์ง๋ฅผ ํ๋ ๊ฒ )
public static void main(String[] args) {
try {
System.out.println(2/0);
} catch(ArithmeticException e) {
System.out.println("ํด๋น ์์ธ๊ฐ ๋ฐ์ํ์๋ ๋์ฒด ์ญํ ");
}
System.out.println("๋ค์ ์ฝ๋");
}
// ์ถ๋ ฅ๊ฒฐ๊ณผ
// ํด๋น ์์ธ๊ฐ ๋ฐ์ํ์๋ ๋์ฒด ์ญํ
// ๋ค์ ์ฝ๋
// ์ฆ, ์์ธ๋ฐ์์ ์ฒ๋ฆฌํจ์ผ๋ก ์จ ํ๋ก๊ทธ๋จ์ ์ค๋จ์์ด ๋ค์ ์ฝ๋๋ก ๋์ด๊ฐ ์ ์๊ฒ๋๋ค.
์์ธ ์ฒ๋ฆฌ๋ผ๋ ๊ฒ์ ๋จ์ํ๊ฒ ์์ธ๋ฅผ ์ฒ๋ฆฌํ๋ ๊ฒ์ด๋ค.
try ~ catch
์๋ฐ์์ ์ ๊ณตํ๋ try ~ catch๋ฌธ์ ํตํด ์์ธ๋ฅผ ์ฒ๋ฆฌํ ์ ์๋ค. ์์ ์ฝ๋๋ฅผ ๋ณด๋ฉด try์์ ์์ธ๊ฐ ๋ฐ์ํ
๊ตฌ๋ฌธ์ด ๋ค์ด๊ฐ ๊ฒ์ ํ์ธํ ์ ์์ ๊ฒ์ด๋ค. ์ด ์ฒ๋ผ ์์ธ๊ฐ ๋ฐ์ํ ์ ์๋
์ฝ๋๋ try์์ ๋ฃ์ด ์ฃผ๋ฉด ๋๋ค. catch๊ตฌ๋ฌธ์ ๋ณด๋ฉด catch(ArithmeticException e)์ธ ๊ฒ์ ๋ณผ ์ ์๋ค.
์์ ArithmeticException๋ ํด๋์ค ์ด๋ฆ์ด๋ฉฐ ์์ธ๊ฐ ๋ฐ์ํ ํด๋์ค์ ์ด๋ฆ์ ๋ฃ์ด์ฃผ๊ณ ๋ค์ e๋ ๋ณ์๋ช ์ด๋ค.
์ด๋ฌํ ๊ณผ์ ์ ํตํด ์์ธ๋ฅผ ์ฒ๋ฆฌํจ์ผ๋ก ์จ ๋ค์์ฝ๋์ธ System.out.println("๋ค์ ์ฝ๋"); ๊ตฌ๋ฌธ์ ์คํ์ด ๊ฐ๋ฅํ๋ค.
์ฆ, ์์ธ๋ฐ์์ ์ฒ๋ฆฌํจ์ผ๋ก ์จ ํ๋ก๊ทธ๋จ์ ์ค๋จ์์ด ๋ค์ ์ฝ๋๋ก ๋์ด๊ฐ ์ ์๊ฒ๋๋ ๊ฒ์ด๋ค.
4. ์์ธ ์ฒ๋ฆฌ ( 2 )
์์ธ๋ฅผ ํ๊ฐ๋ง ๋ณด์ฌ์ค์ ์๋ฟ์ง ์์ ์ ์์ด์ ํ๋์ ์์ธ๋ฅผ ๋ ๋ค๋ค๋ณด๋๋ก ํ๊ฒ ์ต๋๋ค.
public static void main(String[] args) {
int[] scores = {100, 200, 300};
System.out.println(scores[3]); // ๋ฐฐ์ด์ 3๋ฒ์งธ ์ธ๋ฑ์ค ์ ๊ทผ ํ ์ถ๋ ฅ
// ๋ฐฐ์ด์ ํฌ๊ธฐ๋ 3์นธ์ด ๋ง๋๋ฐ ์ธ๋ฑ์ค๋ก ๋ณด๋ฉด 0 , 1 , 2 ์ด๊ธฐ๋๋ฌธ์ 3์ ํฌ๊ธฐ์ ์นธ์ ์กด์ฌํ์ง ์๋๋ค.
}
// ์ถ๋ ฅ ๊ฒฐ๊ณผ
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
at xxxxx.xxx.ExceptionApp.main(ExceptionApp.java:3)
์ฝ๋ ์์๋ฅผ ๋ณด๋ฉด ArrayIndexOutOfBoundsException๋ผ๋ ์์ธํด๋์ค๊ฐ ํธ์ถ์ด ๋ ๊ฒ์ ์ ์ ์์ต๋๋ค.
์ด ์ฝ๋์ ๋ฌธ์ ๋ ๋ฐฐ์ด์ ํฌ๊ธฐ์ ๋ง์ง์๋ ๊ฐ์ ์ถ๋ ฅํ๋ ค๊ณ ํ๊ธฐ์ ์ค๋ฅ๊ฐ ๋ฐ์ํ ๊ฒ ์ ๋๋ค.
์ด๋ฌํ ์์ธ ๋ํ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๋์ผํฉ๋๋ค.
public static void main(String[] args) {
int[] scores = {100, 200, 300};
try {
System.out.println(scores[3]);
} catch(ArrayIndexOutOfBoundsException e) {
System.out.println("๋ฐฐ์ด์ indexํฌ๊ธฐ๋ฅผ ๋์์ต๋๋ค.");
}
System.out.println("๋ค์ ์ฝ๋");
}
// ์ถ๋ ฅ๊ฒฐ๊ณผ
// ๋ฐฐ์ด์ indexํฌ๊ธฐ๋ฅผ ๋์์ต๋๋ค.
// ๋ค์ ์ฝ๋
์ถ๋ ฅ๊ฒฐ๊ณผ๋ฅผ ์ดํด๋ณด๋ฉด ์ ๋์ค๋ ๊ฒ์ ํ์ธ ํ ์ ์๋ค.
5. ์์ธ ์ฒ๋ฆฌ catch๋ฌธ ์ ์ฉํ ๋ฉ์๋
1. e.printStackTrace() => ์์ธ๊ฐ ๋ฐ์ํ ๊ฒฝ์ฐ ์ ์ฒด์ ์ธ ์์ธ์ ๋ํ ์์ธ์ ์ธ ์ค๋ฅ ๋ฉ์์ง๋ฅผ ์๋ ค์ฃผ๋ ๋ฉ์๋์ด๋ค.
2. e.getMessage() => ์์ธ๋ฐ์์ ์ด์ ๋ฅผ ์๋ ค์ฃผ๋ ๋ฉ์๋์ด๋ค.
6. ์์ธ ์ข ๋ฅ ( CheckedException & UnCheckedException )
1. Checked Exception
์ปดํ์ผ๋ฌ๊ฐ ์ฒดํฌ๋ฅผ ํด์ฃผ๋ Exception์ด๋ค.
์ฆ, ๋ฐํ์ ์คํ์ ์ํ๋๋ผ๋ ์ฌ์ ์ ์ฝ๋์์์ ์ค๋ฅ๋ฅผ ์๋ ค์ค๋ค. ( ์์ธ์ฒ๋ฆฌํ๋ฉด ๋๋ค. )
์ปดํ์ผ ๋จ๊ณ์์ ์๋ ค์ฃผ๋ Exception์ ๋ํ์ ์ธ ์ ) IOException๊ณผ ์์๋ฐ๋ FileNotFoundException ๋ฑ๋ฑ์ด ์กด์ฌํ๋ค.
2. UnChecked Exception
์ปดํ์ผ๋ฌ๊ฐ ์ฒดํฌ๋ฅผ ์ํด์ฃผ๋ Exception์ด๋ค.
์ฆ, ๋ฐํ์ ๊ณผ์ ์์ ์ฝ๋์ ์ค๋ฅ๊ฐ ๋ฐ์ํ์ฌ ๋ํ๋๋ ์ค๋ฅ๋ก์จ ๋ํ์ ์ผ๋ก ์์์ ๋ณด์๋ArrayIndexOutOfBoundsException, ArithmeticException ๋ฑ๋ฑ์ด ์กด์ฌํ๋ค. ์ด ๋ Exception์ RuntimeException์ ๊ฐ์ฒด๋ฅผ
์์์ ๋ฐ๋ ํด๋์ค์ด๋ค. ์ฆ, RuntimeException์ ๋ฐํ์์์ ๋ํ๋๋ ์ค๋ฅ๋ผ๋ ์ ์ ์ ์ ์์ต๋๋ค.
7. final๊ตฌ๋ฌธ
์๋ฐ๋ก ํ๋ก๊ทธ๋๋ฐ์ ํ๋ค๋ณด๋ฉด ์ข ์ข ์ธ๋ถ์์ ๋ฆฌ์์ค๋ฅผ ๋ฐ์์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ๋น์ผ๋น์ ํ๋ค.
์ด๋ด๋๋ ๋ํ์ ์ผ๋ก ์๋ฐ์์ IOException ์์ธ๊ฐ ๋ฐ์ํ๊ณค ํ๋ค.
์ด๋ ๊ฒ ์ธ๋ถ์์ ๋ฆฌ์์ค๋ฅผ ๋ฐ์์ ์ฌ์ฉํ๋๋ฐ ๋ฆฌ์์ค๋ฅผ ๋ถ์ก๋ ๊ฒฝ์ฐ๊ฐ ์กด์ฌํ๋ค. ๋ํ์ ์ผ๋ก ๋ฐ์ดํฐ๋ฒ ์ด์ค์ Connection๊ณผ ๊ฐ์ DB์ ์ฐ๊ฒฐ์ ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ ๋ ๋๊น์ง ์ ์ง๋ฅผ ์ํค๊ณ ๋ ํ๋ค. ์ด๋ด๋ close๋ฉ์๋๋ฅผ ํตํด ์์ธ์ฒ๋ฆฌ ๊ตฌ๋ฌธ์์
๋์ด์ค ๋ ์ฌ์ฉํ๋ ๊ฒ์ด final๊ตฌ๋ฌธ์ด๋ค.
public static void main(String[] args) {
FileWriter f = null; // finally๊ตฌ๋ฌธ์์ ๋ฐ์ผ๋ ค๊ณ ์ธ๋ถ์ ๊ณต์ ๊ฐ ๊ฐ๋ฅํ ๋ณ์๋ฅผ ์ ์ธ ๋ฐ ์ด๊ธฐํ
// try์ ์ ์ธํ๋ฉด ์ง์ญ๋ณ์๊ฐ ๋์ด์ finally ๊ตฌ๋ฌธ ๋ด๋ถ์์ ๋ณ์๋ฅผ ๋ชป๋ฐ๋๋ค.
try {
f = new FileWriter("data.txt"); // ํ์ผ ์์ฑ ๊ตฌ๋ฌธ
f.write("Hello"); // ์ฌ๊ธฐ์ ๋ฐ๋ก catch๋ฌธ์ผ๋ก ๊ฐ๊ธฐ๋๋ฌธ์ ๋ฐ์ ๊ตฌ๋ฌธ์ ์คํ์ ์ํจ.
// f.close(); => ์ฆ, close๊ฐ ์๋๋ค.
} catch(IOException e) {
e.printStackTrace();
} finally {
if(f != null) { // f๊ฐ null์ด ์๋ ๊ฒฝ์ฐ ์ฆ, ๊ฐ์ด ์กด์ฌํ๋ ๊ฒฝ์ฐ์๋ง ์คํ์ ํด์ฃผ๊ฒ ๋ค.
try {
f.close(); // close๋ฉ์๋๋ฅผ ํตํด ํ์ผ๊ณผ์ ์ฐ๊ฒฐ์ ๋ซ์์ค๋ค.
// try์ Exception์ด ๋ฐ์ ํ๋ ์ํ๋ ๋ฌด์กฐ๊ฑด finally๊ตฌ๋ฌธ์ ์คํ์ ํ๊ฒ ๋๋ค.
} catch(IOException e) { // f.close() ๋ํ ์์ธ์ฒ๋ฆฌ๊ฐ ๋ฐ์ํ ์ ์์ผ๋ฏ๋ก ์ฒ๋ฆฌ.
e.printStackTrace();
}
}
}
}
8. throws ๊ตฌ๋ฌธ
throws ์ด๊ฒ์ ์ฌ์ฉํ๋ ์ด์ ๋ ๊ฐ๋ฐ์๊ฐ ์์ ์ด ๋ง๋ ๋ฉ์๋๊ฐ ๋ค๋ฅธ ์ฌ๋์ด ํธ์ถํ ๋ ์์ธ๊ฐ ๋ฐ์ ํ ๋ฉ์๋๋ผ๋๊ฒ ํ๋จ์ด๋๋ฉด ํด๋น ์์ธ๊ฐ์ฒด๋ฅผ "throws ์์ธํด๋์ค" ๋ฅผ ๋ฃ์ด ์๋ ค์ค ์ ์๋ค.
// Mainํด๋์ค >
public static void main(String[] args) {
Test t = new Test();
try {
t.calculate(3, 0) // => 3 / 0 => ArithmeticException ๋ฐ ์์
} catch (ArithmeticException e) {
System.out.println("0์ ๋๋๋ฉด ์๋ฉ๋๋ค!!");
}
}
// Testํด๋์ค >
public int calculate(int number1, int number2) throws ArithmeticException {
return number1 / number2;
}
// ์ด๋ฐ์์ผ๋ก ํ ๊ฐ์ฒด์ ๋ฉ์๋๋ฅผ ํธ์ถ ํ ๋ throwsํค์๋์ ๋ฐ์ํ ์์ธ (ArithmeticException)๋ฅผ
// ๋ช
์๋ฅผ ํด์ค ์ ์๋ค.
'โJava > ๐Java Programming' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ๋ณ์ ์ด๊ธฐํ์ ๋ํ ์ดํด (0) | 2024.11.05 |
---|---|
[Java] Annotation ์ด๋? ( ์ ๋ ธํ ์ด์ ) (0) | 2024.11.05 |
[Java] JVM ๋์ ์๋ฆฌ (0) | 2024.10.23 |
[Java] ํด๋์ค์ ๊ฐ์ฒด์ ์ ์ (9) | 2024.10.05 |
[Java] ์์ ( Extends ) (1) | 2024.05.01 |