๐ก์ฃผ๋ง ๊ณผ์ ํผ๋๋ฐฑ
static
์ผ๋ก ์ ์ธํ๋ ๊ฒ์ด ์ข๋ค.
ex) Arrays.sort()
- ๊ทธ ์ธ์๋ static ์ฌ์ฉ์ ์ง์ํ๋ค.์์ฑ์๋ฅผ private๋ก ์ ์ธ
ํ๋ฉด ์ธ์คํด์ค ์์ฑ์ ๊ธ์งํ ์ ์๋ค.Scanner
๋ฅผ ์ธ์๋ก ๋ฐ๋ ๊ฒ์ ์ข์ง ์๋ค. (์ฌํ์ฉ์ฑ)
โ ์ค์บ๋๋ก ์ด๋ฏธ ๋ฐ์ ๊ฐ์ ๋ฐ๋ ๊ฒ์ด ์ข๋ค.
โ๋โ ํํ : me
๊ฐ ๊ณต์ฌ์ฅ๊ณผ ๊ทธ๋์ position์ position ํด๋์ค๋ก ๋ถ๋ฆฌํ๊ณ , ๊ทธ position ํด๋์ค์ x, y ์ขํ ๊ฐ์ ๊ฐ์ง๊ณ ๊ฐ ๊ณต์ฌ์ฅ๊ณผ ๊ทธ๋์ position ๊ฐ์ฒด๋ฅผ ํ๋ ์์ฑ์ผ๋ก ๊ฐ์ง๋ ์ค๊ณ๋ ์ข์ ๋ฏ ํ๋ค.package
ํด๋์ค์ ๊ฐ ๊ธฐ๋ฅ๋ณ, ๊ฐ์ฒด ๋ฑ์ผ๋ก ๋๋์ด ์ ์ฅํ๋ฉด ์ข๋ค.๐ 15์ฅ ์์ธ (Exception)
์๋ฌ์ ์ข ๋ฅ์ ๋์์ฑ
์๋ฌ ์ํฉ ๋ณ ์ฒ๋ฆฌ

์์ธ์ ์ํฉ๋ค
- ๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ
- ํ์ผ์ ์ฐพ์ ์ ์์
- null ์ธ ๋ณ์๋ฅผ ์ฐธ์กฐ ํ์. ๋ฑ
์์ธ ์ฒ๋ฆฌ ํ๋ฆ

์์ธ์ ์ข ๋ฅ

Java์์ Error์ Exception์ ๋ ๋ค ์์ธ ์ํฉ์ ๋ํ๋ด์ง๋ง, ๋ฐ์ ์ ์ฒ๋ฆฌ ๋ฐฉ์์ด ๋ค๋ฅด๋ค.
Error๋ ์์คํ ์์ค์์ ๋ฐ์ํ๋ ์ฌ๊ฐํ ์์ธ ์ํฉ์ผ๋ก, ์ ํ๋ฆฌ์ผ์ด์ ์ด๋ ์ฌ์ฉ์ ์ฝ๋์์ ์ฒ๋ฆฌํ ์ ์์ต๋๋ค. ๋ํ์ ์ผ๋ก OutOfMemoryError์ด๋ StackOverflowError ๋ฑ์ด ์์ต๋๋ค. ์ด๋ฌํ ์ค๋ฅ๋ ์ผ๋ฐ์ ์ผ๋ก ๋ณต๊ตฌํ ์ ์๊ธฐ ๋๋ฌธ์, ์์ธ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ๋ณด๋ค๋ ์์คํ ์์ฒด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๊ฒ์ด ํ์ํฉ๋๋ค.
Exception์ ๊ฐ๋ฐ์๊ฐ ์์ธกํ ์ ์๋ ์์ธ ์ํฉ์ผ๋ก, ์์ธ ์ฒ๋ฆฌ๋ฅผ ํตํด ์ ์์ ์ธ ํ๋ก๊ทธ๋จ ์คํ์ ์ ์งํ ์ ์์ต๋๋ค. Exception์ ๋ RuntimeException๊ณผ ์ผ๋ฐ์ ์ธ Exception์ผ๋ก ๋๋ฉ๋๋ค. RuntimeException์ ๊ฐ๋ฐ์์ ์๋ชป๋ ์ฝ๋๋ ๋ก์ง์ ์ํ ์์ธ์ด๋ฉฐ, ๋ฐ๋ฉด์ ์ผ๋ฐ์ ์ธ Exception์ ์ธ๋ถ ํ๊ฒฝ์ ๋ณํ์ ์ํ ์์ธ์ ๋๋ค.
Java์์๋ Exception๊ณผ RuntimeException์ ๋ชจ๋ checked exception์ด๋ผ๊ณ ๋ ๋ถ๋ฆ ๋๋ค. ์ด๋ ์์ธ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์์ผ๋ฉด ๋ฐ๋์ ์์ธ ์ฒ๋ฆฌ๋ฅผ ํด์ผ ํ๋ค๋ ์๋ฏธ์ ๋๋ค. ์ฆ, ์์ธ ์ฒ๋ฆฌ๋ฅผ ํ์ง ์์ผ๋ฉด ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค. ๊ทธ๋ ์ง๋ง RuntimeException์ unchecked exception์ด๋ผ๊ณ ๋ ๋ถ๋ฅด๋ฉฐ, ๋ช ์์ ์ผ๋ก ์์ธ ์ฒ๋ฆฌ๋ฅผ ํ์ง ์์๋ ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ฐ์ํ์ง ์์ต๋๋ค.
๋ฐ๋ผ์, ๊ฐ๋ฐ์๋ ๋ฐ์ ๊ฐ๋ฅํ ์์ธ ์ํฉ์ ๋ํด ์ ์ ํ ์์ธ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ์ ๊ตฌํํ๊ณ , ์์คํ ์์ค์์ ๋ฐ์ํ๋ Error์ ๋ํด์๋ ๋์ฒ ๋ฐฉ๋ฒ์ ๋ฏธ๋ฆฌ ์ ์ํด๋๋ ๊ฒ์ด ์ข์ต๋๋ค.
์์ธ ์ฒ๋ฆฌ ํ์ง ์๋ ๊ฒฝ์ฐ

try-catch ๋ฌธ์ผ๋ก Exception ๊ณ์ด ์์ธ์ ๋ฐ์์ ์ค๋น
import java.io.IOException;
public class Main {
public static void main(String[] args) {
try {
int[] nums = {0, 1, 2};
nums[5] = 1;
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
System.out.println("์๋ฌ ๋ฐ์");
}
}
}

์์ธ ์ฒ๋ฆฌ๋ฅผ ์์ ๋ฉ์๋์ ๋ฏธ๋ฃจ๋ ๋ฐฉ๋ฒ

import java.io.IOException;
public class Main {
// ๋ฉ์ธ ์์๋ถํฐ ํด๋น ์์ธ๋ฅผ ๋ฌด์ํ๊ฒ ๋ค๋ ๋ด์ฉ
public static void main(String[] args) throws InterruptedException {
System.out.println("์์");
Thread.sleep(1000);
System.out.println("๋");
}
}
throws
ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ํด๋น ๋ฉ์๋์์ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์๋ ์์ธ๋ฅผ ๋ช
์์ ์ผ๋ก ์ ์ธํ์ฌ ํด๋น ๋ฉ์๋๊ฐ ์์ธ๋ฅผ ์ฒ๋ฆฌํ๋๋ก ์ค์ ํ ์ ์๋ค.
์์ธ ์ธ์คํด์ค ์ด์ฉ ๋ฐฉ๋ฒ

import java.io.IOException;
public class Main {
public static void main(String[] args) {
try {
something();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void something() throws InterruptedException {
System.out.println("์์");
Thread.sleep(1000);
System.out.println("๋");
}
}
throws
์ ์์ธ ์ ๋ฐ ์ฝ๋๋ ํด๋น ๋ฉ์๋์์ ์ค์ ํ๊ณ ,
์ด๋ฅผ ์ฌ์ฉํ๋ main()์์๋ try - catch
๋ก ์์ธ ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ๋ ๊ฒ์ด ์ข๋ค.
์์ธ๋ฅผ ํ์ณ์ ์ฒ๋ฆฌ

import java.io.IOException;
public class Main {
public static void main(String[] args) {
try {
something();
FileWriter fw = new FileWriter("data.txt");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void something() throws InterruptedException {
System.out.println("์์");
Thread.sleep(1000);
System.out.println("๋");
}
}
์์ธ์ ๋คํ์ฑ์ ํ์ฉ
ํ์ฌ ์ฌ๋ฌ ๊ฐ์ ์์ธ ์ ๋ฐ์๋, ๊ฐ ์ธ๋ถ์ ์ธ Exception์ ๋ ํฐ ์์์ ๋ฒ์ฃผ์ธ Exception ์ผ๋ก ํ์ณ์ ์ฒ๋ฆฌํ ์ ์๋ค.
finally๋ก ํญ์ ํด์ผํ๋ ๊ตฌ๋ฌธ ์ฒ๋ฆฌ

finally {}
์ถ๊ฐ.
close()
์ ๋ํ try-catch ์ถ๊ฐ
ํ ๊ฒ (์ ์ฝ๋๋ ๊ฐ์ ํ ์ ์ด ์๋ค. - ์๋ ์ค๋ช
)
Java8 ์ดํ์๋ ์๋ close() ์ฒ๋ฆฌ๋๋ try-catch
Closeable
์ ๊ตฌํํ๊ณ ์๋ ๊ฐ์ฒด๋ try() ์์ ์๋์ผ๋ก close() ํด ์ค๋ค.

์๋ฌ์ ์ ๋ฌ

์์ธ ์ธ์คํด์ค๋ฅผ ์์ ์๊ฒ ๋์ง๊ธฐ


java assert
assert๋ฌธ์ ๊ฐ๋ฐ์๊ฐ ์ฝ๋๋ฅผ ์์ฑํ๋ฉด์ ์์๋๋ ์กฐ๊ฑด์ ๊ฒ์ฆํ๊ณ , ์ฝ๋์ ์ค๋ฅ๋ฅผ ๋นจ๋ฆฌ ์ฐพ์ ์ ์๋๋ก ๋์์ค๋๋ค. assert๋ฌธ์ ๊ฐ๋ฐ ๋จ๊ณ์์๋ง ์ฌ์ฉํ๊ณ , ๋ฆด๋ฆฌ์ฆ ๋จ๊ณ์์๋ ๋นํ์ฑํํด์ผ ํฉ๋๋ค.
public int divide(int a, int b) {
assert b != 0;
return a / b;
}
์ค๋ฆฌ์ง๋ ์์ธ ํด๋์ค ์ ์


15์ฅ ์ ๋ฆฌ
syntax error
, runtime error
, logic error
์ 3์ข
๋ฅ
- ์์ธ์ฒ๋ฆฌ๋ฅผ ํ ๋๋, runtime error๋ฅผ ๋์ฒํ๋ค
์์ธ์ ์ข ๋ฅ - API์๋ ์ฌ๋ฌ๊ฐ์ง ์์ธ์ ์ํฉ์ ํํํ๋ ์์ธ ํด๋์ค๊ฐ ์ค๋น๋์ด ์๋ค. - ์์ธ ํด๋์ค๋ Error ๊ณ์ด, Exeption ๊ณ์ด, RuntimeException ๊ณ์ด๋ก ํฌ๊ฒ ๋๋๋ค - ์์ธ ํด๋์ค๋ฅผ ์์ํ์ฌ ์ค๋ฆฌ์ง๋ ์์ธ ํด๋์ค๋ฅผ ์ ์ํ ์ ์๋ค.
์์ธ ์ฒ๋ฆฌ
- try-catch
๋ฌธ์ ์ฌ์ฉํ๋ฉด, try ๋ธ๋ก ๋ด์ ์์ธ๊ฐ ๋ฐ์ํ์ ๋ catch ๋ธ๋ก์์ ์ฒ๋ฆฌ๊ฐ ์ฎ๊ฒจ์ง๋ค
- finally
๋ธ๋ก์ผ๋ก ๋์ค์ ๊ผญ ํด์ผํ๋ ์ฒ๋ฆฌ๋ฅผ ํ ์ ์๋ค
- Exception ๊ณ์ด ์์ธ
๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์์ ๋์๋ try-catch
๋ฌธ์ด ํ์๋ค
- throw
์ ์ธ์ ํ๋ฉด, ์์ธ ์ฒ๋ฆฌ๋ฅผ ํธ์ถํ๋ ์ฃผ์ฒด์ ์์ํ๋ ํ ์ ์๋ค.
- throw
๋ฌธ์ ์ฌ์ฉํ๋ฉด ์์๋ก ์์ธ๋ฅผ ๋ฐ์์ํฌ ์ ์๋ค
๐์ฐ์ต ๋ฌธ์
15-1

package com.pkd.Exam;
public class Main {
public static void main(String[] args) {
String s = null;
System.out.println(s.length());
}
}

15-2

package com.pkd.Exam;
public class Main {
public static void main(String[] args) {
String s = null;
try {
System.out.println(s.length());
} catch(NullPointerException e){
System.out.println("NullPointException ์์ธ๋ฅผ catch ํ์์ต๋๋ค");
System.out.println("---- stack trace (์ฌ๊ธฐ๋ถํฐ) ----");
e.printStackTrace();
System.out.println("---- stack trace (์ฌ๊ธฐ๊น์ง) ----");
}
}
}

15-3

package com.pkd.Exam;
public class Main3 {
public static void main(String[] args) {
String s = "Tree";
try {
int i = Integer.parseInt(s);
} catch (NumberFormatException e) {
e.printStackTrace();
}
}
}

15-4

package com.pkd.Exam;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
System.out.println("ํ๋ก๊ทธ๋จ ์์");
throw new IOException();
}
}

Uploaded by N2T