
< 1. ๋ณ์์ ์ด๊ธฐํ >
๋ณ์์ ์ข ๋ฅ
- ๋ฉค๋ฒ ๋ณ์(ํ๋): ํด๋์ค์ ์ ์ธ
- ์ง์ญ ๋ณ์: ๋ฉ์๋์ ์ ์ธ, ๋งค๊ฐ๋ณ์๋ ์ง์ญ ๋ณ์์ ํ ์ข ๋ฅ์ด๋ค.
๋ฉค๋ฒ ๋ณ์, ํ๋ ์์
public class Student {
String name;
int age;
int grade; }
์ง์ญ ๋ณ์ ์์
public class ClassStart3 {
public static void main(String[] args) {
Student student1;
student1 = new Student();
Student student2 = new Student();
} }
`student1` , `student2` ๋ ์ง์ญ ๋ณ์์ด๋ค.
1.1 ๋ฉ์๋ ํธ์ถ ์ ํ์ ๋ณ์ ์ํ
public class MethodChange1 {
public static void main(String[] args) {
int a = 10;
System.out.println("๋ฉ์๋ ํธ์ถ ์ : a = " + a); changePrimitive(a); System.out.println("๋ฉ์๋ ํธ์ถ ํ: a = " + a);
}
public static void changePrimitive(int x) {
x = 20;
} }
1.1.1 ์ง์ญ ๋ณ์ (Local Variable)
์ง์ญ ๋ณ์๋ ํน์ ๋ฉ์๋๋ ๋ธ๋ก ์์์๋ง ์ ์ธ๋๊ณ ์ฌ์ฉ๋๋ ๋ณ์์ด๋ค.
๋ฉ๋ชจ๋ฆฌ ๊ด์ ์์ ๋ณด๋ฉด, ์ง์ญ ๋ณ์๋ ๋ฉ์๋๊ฐ ํธ์ถ๋ ๋ ์คํ ๋ฉ๋ชจ๋ฆฌ์ ์์ฑ๋๋ฉฐ, ๋ฉ์๋๊ฐ ์ข ๋ฃ๋๋ฉด ์คํ์์ ์ ๊ฑฐ๋์ด ์ฌ๋ผ์ง๋ค.
์ฝ๋์์์ ์ง์ญ ๋ณ์:
public static void main(String[] args) {
int a = 10; // 'a'๋ main() ๋ฉ์๋์ ์ง์ญ ๋ณ์์ด๋ค.
}
public static void changePrimitive(int x) {
x = 20; // 'x'๋ changePrimitive() ๋ฉ์๋์ ์ง์ญ ๋ณ์์ด๋ค.
}
• a๋ main() ๋ฉ์๋ ์์์๋ง ์ฌ์ฉ๋๋ค. main() ๋ฉ์๋๊ฐ ๋๋๋ฉด a๋ ๋ฉ๋ชจ๋ฆฌ์์ ์ ๊ฑฐ๋๋ค.
• x๋ changePrimitive() ๋ฉ์๋ ์์์๋ง ์ฌ์ฉ๋๋ค. ์ด ๋ฉ์๋๊ฐ ๋๋๋ฉด x ์ญ์ ๋ฉ๋ชจ๋ฆฌ์์ ์ ๊ฑฐ๋๋ค.
• ์ด ๋ ๋ณ์๋ ๊ฐ๊ธฐ ๋ค๋ฅธ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ฌ์ฉํ๋ฉฐ ์๋ก ์ํฅ์ ์ฃผ์ง ์๋๋ค.
1.1.2. ๊ฐ์ ์ํ ํธ์ถ (Call by Value)
- ์๋ฐ๋ ๋ชจ๋ ๋ณ์ ์ ๋ฌ์ด ๊ฐ์ ์ํ ํธ์ถ์ด์ง๋ง, ๊ธฐ๋ณธํ ๋ณ์๋ ๊ฐ ์์ฒด๊ฐ ๋ณต์ฌ๋๊ณ , ์ฐธ์กฐํ ๋ณ์๋ ์ฃผ์๊ฐ์ด ๋ณต์ฌ๋๋ค๋ ์ฐจ์ด๊ฐ ์๋ค.
์๋ฐ๋ ๋ฉ์๋ ํธ์ถ ์ ๊ฐ์ ์ํ ํธ์ถ ๋ฐฉ์์ ์ฌ์ฉํ๋ค.
์ด๋ ๋ฉ์๋๊ฐ ํธ์ถ๋ ๋, ๋ณ์์ ์ค์ ๊ฐ์ด ๋ณต์ฌ๋์ด ๋ฉ์๋์ ์ ๋ฌ๋๋ค๋ ์๋ฏธ์ด๋ค.
๋ฐ๋ผ์ ๋ฉ์๋์์ ์๋ณธ ๋ณ์์ ๊ฐ์ ๋ณ๊ฒฝ๋์ง ์๋๋ค.
• ์ฝ๋ ๋์:
int a = 10;
changePrimitive(a);
System.out.println(a); // ์ฌ์ ํ a๋ 10์ด๋ค.
• changePrimitive(a)๋ฅผ ํธ์ถํ๋ฉด, a์ ๊ฐ 10์ด x์ ๋ณต์ฌ๋๋ค.
• ๋ฉ์๋ ์์์ x = 20;์ ์คํํด๋, ์ด๋ x์๋ง ์ํฅ์ ๋ฏธ์น๋ฉฐ, a์๋ ์๋ฌด๋ฐ ์ํฅ์ ์ฃผ์ง ์๋๋ค.
์ด๋ x๊ฐ a์ ๋ณต์ฌ๋ณธ์ผ ๋ฟ์ด๊ธฐ ๋๋ฌธ์ด๋ค.
1.1.3. ๋ฉ์๋ ํธ์ถ ์ ํ์ ๋ณ์ ์ํ
์ด ์ฝ๋์ ์คํ ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ๋ค:
๋ฉ์๋ ํธ์ถ ์ : a = 10 ๋ฉ์๋ ํธ์ถ ํ: a = 10
• ๋ฉ์๋ ํธ์ถ ์ :
main() ๋ฉ์๋ ์์์ a๊ฐ ์ ์ธ๋๊ณ ์ด๊ธฐํ๋๋ค. ์ด ์์ ์์ a์ ๊ฐ์ 10์ด๋ค.
• ๋ฉ์๋ ํธ์ถ ์ค
changePrimitive(a)๋ฅผ ํธ์ถํ๋ฉด, a์ ๊ฐ 10์ด x๋ก ๋ณต์ฌ๋๋ค.
x๋ changePrimitive() ๋ฉ์๋์ ์ง์ญ ๋ณ์๋ก, x = 20;์ด ์คํ๋๋๋ผ๋ ์ด๋ x์๋ง ์ํฅ์ ์ค๋ค. ๋ฐ๋ผ์ a์ ๊ฐ์ ๋ณํ์ง ์๋๋ค.
• ๋ฉ์๋ ํธ์ถ ํ:
main() ๋ฉ์๋๋ก ๋์์ค๋ฉด, a์ ๊ฐ์ ์ฌ์ ํ 10์ด๋ค.
x๋ ๋ฉ์๋๊ฐ ์ข ๋ฃ๋๋ฉด์ ์คํ ๋ฉ๋ชจ๋ฆฌ์์ ์ ๊ฑฐ๋์ด ๋ ์ด์ ์กด์ฌํ์ง ์๋๋ค.
1.1.4. ์ง์ญ ๋ณ์์ ์คํ ๋ฉ๋ชจ๋ฆฌ
์๋ฐ์์ ์ง์ญ ๋ณ์๋ ์คํ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ๋๋ค.
์ค์ํ ์ ์ ๋ฉ์๋๊ฐ ์ข ๋ฃ๋๋ฉด ํด๋น ๋ฉ์๋์ ์คํ ํ๋ ์์ด ์ ๊ฑฐ๋๊ณ , ์ง์ญ ๋ณ์๋ ํจ๊ป ์ฌ๋ผ์ง๋ค๋ ๊ฒ์ด๋ค.
• ์คํ ๋ฉ๋ชจ๋ฆฌ์ ํ๋ฆ:
1. main() ๋ฉ์๋ ํธ์ถ → ์คํ์ a(10) ์์ฑ
2. changePrimitive(a) ๋ฉ์๋ ํธ์ถ → ์คํ์ x(10 ๋ณต์ฌ๋ณธ) ์์ฑ
3. x ๊ฐ ๋ณ๊ฒฝ (20) → ์๋ณธ a๋ ๋ณ๊ฒฝ๋์ง ์์
4. changePrimitive() ๋ฉ์๋ ์ข ๋ฃ → ์คํ์์ x ์ ๊ฑฐ
5. main() ๋ฉ์๋ ์ข ๋ฃ → ์คํ์์ a ์ ๊ฑฐ
1.1.5. ์ฐธ์กฐํ ๋ณ์์์ ๋น๊ต
๋ง์ฝ ์ด ์ฝ๋๊ฐ ์ฐธ์กฐํ ๋ณ์(์: ๋ฐฐ์ด์ด๋ ๊ฐ์ฒด)๋ฅผ ์ฌ์ฉํ๋ค๋ฉด, ๊ฐ์ด ์๋ ์ฐธ์กฐ(์ฃผ์)๊ฐ ๋ณต์ฌ๋๋ฏ๋ก,
๋ฉ์๋ ๋ด๋ถ์์์ ๋ณ๊ฒฝ์ด ์๋ณธ์๋ ์ํฅ์ ๋ฏธ์ณค์ ๊ฒ์ด๋ค.
์ด๋ฅผ ํตํด ๊ฐ ํ์ ๊ณผ ์ฐธ์กฐ ํ์ ์ ์ฐจ์ด๋ฅผ ์ ์ ์๋ค.
public class ReferenceExample {
public static void main(String[] args) {
int[] arr = {10}; // ์ฐธ์กฐํ ๋ณ์
changeReference(arr);
System.out.println("๋ฉ์๋ ํธ์ถ ํ: arr[0] = " + arr[0]); // ์ถ๋ ฅ: 20
}
public static void changeReference(int[] array) {
array[0] = 20; // ์๋ณธ ๋ฐฐ์ด์ ๊ฐ์ ๋ณ๊ฒฝ
}
}
์ด ๊ฒฝ์ฐ, ๋ฐฐ์ด arr์ ์ฐธ์กฐ๊ฐ ์ ๋ฌ๋๊ธฐ ๋๋ฌธ์ array[0] = 20;์ ์๋ณธ ๋ฐฐ์ด arr์ ์ํฅ์ ์ค๋ค.
1. ๊ธฐ๋ณธ ์๋ฃํ(primitive type)์ ๊ฐ์ด ๋ณต์ฌ๋์ด ์ ๋ฌ๋๊ธฐ ๋๋ฌธ์ ์๋ณธ ๋ณ์์ ๊ฐ์ด ๋ณํ์ง ์๋๋ค.
2. ์ฐธ์กฐ ์๋ฃํ(reference type)์ ์ฃผ์๊ฐ ๋ณต์ฌ๋์ด ์ ๋ฌ๋๊ธฐ ๋๋ฌธ์ ์๋ณธ ๊ฐ์ฒด์ ์ํฅ์ ์ค ์ ์๋ค.
3. ์ง์ญ ๋ณ์๋ ํน์ ๋ฉ์๋๋ ๋ธ๋ก ์์์๋ง ์ ํจํ๋ฉฐ, ๋ฉ์๋๊ฐ ์ข ๋ฃ๋๋ฉด ์คํ ๋ฉ๋ชจ๋ฆฌ์์ ์ ๊ฑฐ๋๋ค.
< 2. ๋ณ์์ ๊ฐ ์ด๊ธฐํ >
< InitData >
package ref;
public class InitData {
int value1; //์ด๊ธฐํ ํ์ง ์์
int value2 = 10; //10์ผ๋ก ์ด๊ธฐํ
}
value1์ ์ด๊ธฐ๊ฐ์ ์ง์ ํ์ง ์์๊ณ , value2 ๋ ์ด๊ธฐ๊ฐ์ 10์ผ๋ก ์ง์ ํ๋ค.
**InitMain**
package ref;
public class InitMain {
public static void main(String[] args) {
InitData data = new InitData();
System.out.println("value1 = " + data.value1);
System.out.println("value2 = " + data.value2);
} }
**์คํ ๊ฒฐ๊ณผ**
value1 = 0
value2 = 10
`value1` ์ ์ด๊ธฐ๊ฐ์ ์ง์ ํ์ง ์์์ง๋ง ๋ฉค๋ฒ ๋ณ์๋ ์๋์ผ๋ก ์ด๊ธฐํ ๋๋ค.
์ซ์๋ `์ผ๋ก ์ด๊ธฐํ๋๋ค. value2 ๋ 10
์ผ๋ก ์ด๊ธฐ๊ฐ์ ์ง์ ํด๋์๊ธฐ ๋๋ฌธ์ ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋10์ผ๋ก ์ด๊ธฐํ๋๋ค.
2.1. ๋ฉค๋ฒ ๋ณ์์ ์ด๊ธฐํ
๋ฉค๋ฒ ๋ณ์๋ ํด๋์ค์ ํ๋๋ก, ์ธ์คํด์ค๊ฐ ์์ฑ๋ ๋ ์๋์ผ๋ก ์ด๊ธฐํ๋๋ค.
๊ฐ๋ฐ์๊ฐ ๋ช ์์ ์ผ๋ก ์ด๊ธฐ๊ฐ์ ์ง์ ํ์ง ์์๋ ๊ธฐ๋ณธ๊ฐ์ผ๋ก ์ด๊ธฐํ๋๋ค.
• ์ด๊ธฐํ ๊ท์น:
• ์ซ์ํ(int, float ๋ฑ): 0 ๋๋ 0.0์ผ๋ก ์ด๊ธฐํ๋จ.
• boolean: false๋ก ์ด๊ธฐํ๋จ.
• ์ฐธ์กฐํ(String, ๋ฐฐ์ด ๋ฑ): null๋ก ์ด๊ธฐํ๋จ.
2.2. ์ง์ญ ๋ณ์์ ์ด๊ธฐํ
์ง์ญ ๋ณ์๋ ๋ฉ์๋๋ ๋ธ๋ก ์์์ ์ ์ธ๋ ๋ณ์๋ก, ์๋ ์ด๊ธฐํ๋์ง ์๋๋ค. ๊ฐ๋ฐ์๊ฐ ๋ช ์์ ์ผ๋ก ๊ฐ์ ์ด๊ธฐํํด์ผ ํ๋ค.
• ์ด๊ธฐํ ๊ท์น:
์ง์ญ ๋ณ์๋ ์ด๊ธฐ๊ฐ์ ์ค์ ํ์ง ์๊ณ ์ฌ์ฉํ๋ ค๊ณ ํ๋ฉด ์ปดํ์ผ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
๋ฐ๋์ ๊ฐ์ ๋ช ์์ ์ผ๋ก ํ ๋นํ ํ์ ์ฌ์ฉํด์ผ ํ๋ค.
• ์ฝ๋์์์ ์์:
public class InitMain {
public static void main(String[] args) {
int localVar; // ์ด๊ธฐํํ์ง ์์
// System.out.println(localVar); // ์ปดํ์ผ ์๋ฌ ๋ฐ์
localVar = 5; // ์ด๊ธฐํ
System.out.println(localVar); // ์ ์ ์ถ๋ ฅ: 5
}
}
• localVar๋ ์ง์ญ ๋ณ์๋ก, ์ด๊ธฐ๊ฐ์ด ์ค์ ๋์ง ์์ ์ํ์์ ์ฌ์ฉํ๋ ค ํ๋ฉด ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
• ๋ช ์์ ์ผ๋ก 5๋ก ์ด๊ธฐํํ ํ์๋ ์ ์์ ์ผ๋ก ์ฌ์ฉํ ์ ์๋ค.
2.3. ๋ฉค๋ฒ ๋ณ์์ ์ง์ญ ๋ณ์์ ์ด๊ธฐํ ๋น๊ต

2.4. ์ค์ํ ๋น์ ๋ก ์ดํดํ๊ธฐ
• ๋ฉค๋ฒ ๋ณ์๋ ํด๋์ค ์ธ์คํด์ค๊ฐ ์์ฑ๋ ๋ ์๋ฐ๊ฐ “์๋์ผ๋ก ์ ๋ฆฌ์ ๋”์ ํด์ฃผ์ด, ๊ฐ์ด ์๋๋ผ๋ ๊ธฐ๋ณธ๊ฐ์ผ๋ก ์ ๋ฆฌ๋ ์ํ์์ ์์ํ๋ค.
• ์ง์ญ ๋ณ์๋ ๊ฐ๋ฐ์๊ฐ ์ง์ ์ ๋ฆฌ์ ๋์ ํด์ผ ํ๋ค. ๊ฐ์ ๋ฃ์ง ์๊ณ ์ฌ์ฉํ๋ ค๊ณ ํ๋ฉด “์ ๋ฆฌ๊ฐ ์ ๋์ต๋๋ค!“๋ผ๊ณ ์ปดํ์ผ๋ฌ๊ฐ ์๋ฌ๋ฅผ ๋ฐ์์ํจ๋ค.
• ๋ฉค๋ฒ ๋ณ์๋ ์๋ ์ด๊ธฐํ๋๋ฉฐ ๊ธฐ๋ณธ๊ฐ์ ๊ฐ์ง์ง๋ง, ์ง์ญ ๋ณ์๋ ์ด๊ธฐํ๋์ง ์์ผ๋ฏ๋ก ๊ฐ๋ฐ์๊ฐ ๋ช ์์ ์ผ๋ก ์ด๊ธฐํํด์ผ ํ๋ค.
• ์ด ์ฐจ์ด๋ ํ๋ก๊ทธ๋จ์์ ๋ณ์ ์ฌ์ฉ ์ ์์ ์ฑ์ ๋ณด์ฅํ๋ฉด์, ์ง์ญ ๋ณ์์ ๋ถํ์ํ ์ด๊ธฐํ๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํ ์๋ฐ์ ์ค๊ณ ์ฒ ํ์์ ๋น๋กฏ๋์๋ค.
< 3.Null >
3.1. null์ ์๋ฏธ
null์ ์ฐธ์กฐํ ๋ณ์์์ “์์ง ์ด๋ค ๊ฐ์ฒด๋ ๊ฐ๋ฆฌํค์ง ์๋๋ค”๋ ๊ฒ์ ์๋ฏธํ๋ค.
์ด๋ ๊ฐ์ด ์๋ ์ํ๊ฐ ์๋๋ผ, ์ฐธ์กฐํ ๋์์ด ์๋ค๋ ํน๋ณํ ์ํ๋ฅผ ๋ํ๋ธ๋ค.
Data data = null; // data๋ ์์ง ์ด๋ค ๊ฐ์ฒด๋ ์ฐธ์กฐํ์ง ์์
3.2. ์ฝ๋ ์คํ ํ๋ฆ
์ฝ๋์์ null๊ณผ ๊ฐ์ฒด ์ฐธ์กฐ์ ๋ณํ๋ฅผ ๋จ๊ณ์ ์ผ๋ก ์ดํด๋ณด์.
Data data = null;
System.out.println("1. data = " + data); // null ์ถ๋ ฅ
data = new Data();
System.out.println("2. data = " + data); // ๊ฐ์ฒด์ ์ฐธ์กฐ ์ ๋ณด ์ถ๋ ฅ
data = null;
System.out.println("3. data = " + data); // ๋ค์ null ์ถ๋ ฅ
์คํ ๊ฒฐ๊ณผ:
1. 1๋จ๊ณ: data๊ฐ null
• Data data = null;์ ์ฐธ์กฐํ ๋ณ์ data๊ฐ ์ด๋ค ๊ฐ์ฒด๋ ๊ฐ๋ฆฌํค์ง ์๋ ์ํ๋ฅผ ์๋ฏธํ๋ค.
• ์ถ๋ ฅ๊ฐ: null
2. 2๋จ๊ณ: data๊ฐ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐ
• data = new Data();๋ ์๋ก์ด Data ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ณ , ๊ทธ ์ฐธ์กฐ๋ฅผ data์ ํ ๋นํ๋ค.
• ์ถ๋ ฅ๊ฐ: ๊ฐ์ฒด์ ์ฐธ์กฐ ์ ๋ณด(์: ref.Data@x001).
3. 3๋จ๊ณ: ๋ค์ null
• data = null;์ data๊ฐ ๋ ์ด์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ์ง ์๊ฒ ๋ง๋ ๋ค.
• ์ถ๋ ฅ๊ฐ: null
3.3. Garbage Collection (GC, ๊ฐ๋น์ง ์ปฌ๋ ์ )
null๋ก ์ฐธ์กฐ๊ฐ ๋๊ธด ๊ฐ์ฒด๋ ๋ ์ด์ ์ ๊ทผํ ์ ์๊ธฐ ๋๋ฌธ์, ์๋ฐ์ ๊ฐ๋น์ง ์ปฌ๋ ํฐ(GC)๊ฐ ํด๋น ๊ฐ์ฒด๋ฅผ ๋ฉ๋ชจ๋ฆฌ์์ ์๋์ผ๋ก ์ ๊ฑฐํ๋ค.
๋์ ์๋ฆฌ:
1. ๊ฐ์ฒด๊ฐ ์์ฑ๋ ๋, ๋ฉ๋ชจ๋ฆฌ์ ํ ์์ญ์ ์ ์ฅ๋๊ณ , ์ฐธ์กฐ๋ฅผ ํตํด ์ ๊ทผ ๊ฐ๋ฅํ๋ค.
2. ์ฐธ์กฐ๋ฅผ ์๊ฑฐ๋ null๋ก ์ค์ ๋๋ฉด ๋ ์ด์ ํด๋น ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ ์ ์๊ฒ ๋๋ค.
3. JVM์ GC๋ ์ด๋ฌํ “๊ณ ์ ๊ฐ์ฒด”(Unreachable Object)๋ฅผ ํ์งํ์ฌ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ํ๋ค.
• ์: data = null; ์ดํ, ์ด์ ์ ์ฐธ์กฐํ๋ Data ๊ฐ์ฒด๋ GC์ ๋์์ด ๋๋ค.
3.4. GC์ ์ด์
• ์๋ฐ๋ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ง์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ด๋ฆฌํ์ง ์์๋ ๋๋ค.
• ๋ฉ๋ชจ๋ฆฌ ๋์๋ฅผ ์ค์ด๊ณ , ํ์ํ์ง ์์ ๊ฐ์ฒด๋ฅผ ์๋์ผ๋ก ์ ๋ฆฌํ๋ค.
• ํ์ง๋ง GC๋ ์ฆ๊ฐ ์คํ๋์ง ์๊ณ , JVM์ด ํ์ํ๋ค๊ณ ํ๋จํ ๋ ์คํ๋๋ค.
3.5. ์ฃผ์ํ ์
• null๋ก ์ฐธ์กฐ๋ฅผ ํด์ ํ๋ค๊ณ ํด์ GC๊ฐ ์ฆ์ ์๋ํ๋ ๊ฒ์ ์๋๋ค. GC๋ JVM์ด ๋ฉ๋ชจ๋ฆฌ ์ํฉ์ ๋ฐ๋ผ ํ์ํ ๋ ๋์ํ๋ค.
• ๊ฐ์ฒด๊ฐ null์ด๋๋ผ๋, ํ๋ก๊ทธ๋จ์์ ๊ทธ ๊ฐ์ฒด์ ์ฌ์ฉ ์ฌ๋ถ๋ฅผ ์ ์ ํ ํ๋จํ์ง ๋ชปํ๋ฉด NullPointerException์ด ๋ฐ์ํ ์ ์๋ค.
• null์ ๊ฐ์ฒด ์ฐธ์กฐ๊ฐ ์์์ ๋ํ๋ด๋ ํน๋ณํ ๊ฐ์ด๋ค.
• ์ฐธ์กฐ๊ฐ ์๋ ๊ฐ์ฒด๋ GC์ ์ํด ๋ฉ๋ชจ๋ฆฌ์์ ์ ๊ฑฐ๋๋ค.
• ์๋ฐ์ ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ ์ฝ๋์ ์์ ์ฑ๊ณผ ํจ์จ์ฑ์ ๋์ด๋ ๋ฐ ๊ธฐ์ฌํ๋ค.
ํ์ง๋ง, null์ ์๋ชป ๋ค๋ฃจ๋ฉด ์์ธ๊ฐ ๋ฐ์ํ ์ ์์ผ๋ฏ๋ก ์ฃผ์ํด์ผ ํ๋ค.
< 4.NullPointerException์ด ๋ฐ์ํ๋ ์๋ฆฌ์ ์ด๋ฅผ ๋ฐฉ์งํ๋ ๋ฐฉ๋ฒ >
4.1. NullPointerException์ด๋?
NullPointerException์ ์ฐธ์กฐํ ๋ณ์๊ฐ null์ผ ๋ ํด๋น ๋ณ์๋ก ๊ฐ์ฒด์ ํ๋๋ ๋ฉ์๋์ ์ ๊ทผํ๋ ค๊ณ ํ๋ฉด ๋ฐ์ํ๋ ์์ธ์ด๋ค.
null์ ์ฐธ์กฐํ ๋ณ์๊ฐ ์ด๋ค ๊ฐ์ฒด๋ ๊ฐ๋ฆฌํค๊ณ ์์ง ์๋ค๋ ๊ฒ์ ๋ํ๋ธ๋ค.
์ฆ, ๋ณ์๋ ์ ์ธ๋์์ง๋ง ๋ฉ๋ชจ๋ฆฌ ์์ ์ค์ ๊ฐ์ฒด๊ฐ ์๋ค๋ ์ํ๋ฅผ ์๋ฏธํ๋ค.
Data data = null;
data.value = 10; // NullPointerException ๋ฐ์
์ ์ฝ๋์์ data๋ null ๊ฐ์ ๊ฐ์ง๊ณ ์์ผ๋ฏ๋ก, data.value์ ์ ๊ทผํ๋ฉด NullPointerException์ด ๋ฐ์ํ๋ค.
์ด ์ฝ๋๋ ์ง๊ด์ ์ผ๋ก๋ “๋น์ด ์๋ ๊ณณ์ 10์ ๋ฃ์ด์ฃผ๋ ๊ฒ”์ฒ๋ผ ๋ณด์ผ ์ ์์ง๋ง,
์ค์ ๋ก๋ null์ “์๋ฌด๊ฒ๋ ์๋ ์ํ”๋ฅผ ์๋ฏธํ๊ธฐ ๋๋ฌธ์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค.
์ด๊ฑธ ๋ ์ฝ๊ฒ ํ์ด์ ์ค๋ช ํ๊ฒ ๋ค.
1. data = null;์ ์๋ฏธ
Data data = null;
• ์ด ์ฝ๋๋ data๋ผ๋ ์ฐธ์กฐํ ๋ณ์๋ฅผ ์ ์ธํ๊ณ , ์๋ฌด ๊ฐ์ฒด๋ ๊ฐ๋ฆฌํค์ง ์๋ ์ํ(null)๋ก ์ด๊ธฐํํ ๊ฒ์ด๋ค.
์ฆ, data๋ ๋จ์ํ “๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ ์ ์๋ ๋ณ์”์ผ ๋ฟ, ํ์ฌ๋ ์ด๋ค ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ๋ ๊ฐ๋ฆฌํค์ง ์๋๋ค.
• data ์์ฒด๊ฐ ๋น์ด ์๋ ์ํ์ด๋ฏ๋ก, ์ด๋ฅผ ํตํด ์ด๋ค ๊ฐ์๋ ์ ๊ทผํ ์ ์๋ค.
2. data.value = 10;์ ๋์ ์๋ฆฌ
data.value = 10;
• ์ด ์ฝ๋๋ data๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ๊ฐ์ฒด์ value ํ๋์ 10์ ๋ฃ์ผ๋ผ๋ ๋ป์ด๋ค.
ํ์ง๋ง, ํ์ฌ data๋ null(์๋ฌด๊ฒ๋ ๊ฐ๋ฆฌํค์ง ์์) ์ํ์ด๊ธฐ ๋๋ฌธ์, ์ค์ ๋ก๋ value๋ผ๋ ํ๋๊ฐ ์กด์ฌํ์ง ์๋๋ค.
• ์ฆ, data๋ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ์ง ์์ผ๋ฏ๋ก ์ด ์ํ์์ data.value๋ฅผ ์ ๊ทผํ๋ ค๊ณ ํ๋ฉด NullPointerException์ด ๋ฐ์ํ๋ค.
๋น์ :
• data๋ ๋ง์น “์ฃผ์”์ฒ๋ผ ์๋ํ๋ค. ํ์ง๋ง ํ์ฌ null ์ํ์ด๋ฏ๋ก,
์ฃผ์๊ฐ ์๋ ์ํ์์ ์ง ์์ ๋ฌผ๊ฑด(value)์ ์ ๊ทผํ๋ ค๋ ์๋๋ฅผ ํ๋ ๊ฒ๊ณผ ๊ฐ๋ค.
• ์ฃผ์๊ฐ ์๋ค๋ฉด ์ง๋ ์์ผ๋ฏ๋ก, ๋น์ฐํ ์ง ์์ ๋ฌผ๊ฑด์ ์ฐพ์ ์ ์์ด ๋ฌธ์ ๊ฐ ์๊ธด๋ค.
3. null๊ณผ ๋น์ด ์๋ ๊ฐ์ฒด์ ์ฐจ์ด
null์ “์๋ฌด ๊ฐ์ฒด๋ ์กด์ฌํ์ง ์์”์ ์๋ฏธํ๋ค.
๋ง์ฝ “๋น์ด ์๋ ๊ฐ์ฒด”๋ฅผ ๋ง๋ค๊ณ ์ถ๋ค๋ฉด, ๊ฐ์ฒด๋ฅผ ์์ฑํด์ผ ํ๋ค.
Data data = new Data(); // ๋น์ด ์๋ ๊ฐ์ฒด ์์ฑ
data.value = 10; // ์ด์ value์ 10์ ์ ์ฅํ ์ ์์
์ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ์ ๊ณผ์ ์ ๊ฑฐ์น๋ค:
1. new Data()๋ก Data ๊ฐ์ฒด๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ์์ฑํ๋ค.
2. data ๋ณ์๋ ์์ฑ๋ ๊ฐ์ฒด์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ฐธ์กฐํ๊ฒ ๋๋ค.
3. ์ด์ data๋ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ณ ์์ผ๋ฏ๋ก, data.value๋ฅผ ํตํด ํด๋น ๊ฐ์ฒด์ value ํ๋์ ์ ๊ทผํ ์ ์๋ค.
4. ์ NullPointerException์ด ๋ฐ์ํ๋๊ฐ?
null ์ํ๋ ์๋ฌด๊ฒ๋ ์ฐธ์กฐํ์ง ์์์ ์๋ฏธํ๋ค.
๋ฐ๋ผ์, ๊ฐ์ฒด์ ํ๋๋ ๋ฉ์๋์ ์ ๊ทผํ๋ ค๋ฉด ๋ฐ๋์ ๊ฐ์ฒด๊ฐ ์กด์ฌํด์ผ ํ๋ค.
null ์ํ์์๋ ๊ฐ์ฒด๊ฐ ์๊ธฐ ๋๋ฌธ์, ์ด๋ฅผ ํตํด ๊ฐ์ ์ค์ ํ๊ฑฐ๋ ๋ฉ์๋๋ฅผ ํธ์ถํ๋ ค ํ๋ฉด ์์ธ๊ฐ ๋ฐ์ํ๋ค.
5. ์๋ชป๋ ์ดํด์ ์ฌ๋ฐ๋ฅธ ์ดํด
์๋ชป๋ ์ดํด:
• data๊ฐ null์ด๋ฉด, ๋ง์น ๋น์ด ์๋ ๊ฐ์ฒด์ฒ๋ผ ๋์ํ์ฌ ๋์ค์ ๊ฐ์ ๋ฃ์ ์ ์์ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ ์ ์๋ค.
• ํ์ง๋ง, null์ ๊ฐ์ฒด๊ฐ “์์ ์กด์ฌํ์ง ์๋ ์ํ”๋ฅผ ๋ํ๋ด๋ฉฐ, ์๋ฌด ํ๋๋ ๋ฉ์๋์๋ ์ ๊ทผํ ์ ์๋ค.
์ฌ๋ฐ๋ฅธ ์ดํด:
• null์ ๋จ์ง ์ฐธ์กฐ๊ฐ ์์์ ๋ํ๋ด๋ ๊ฐ์ผ ๋ฟ์ด๋ค.
• ๊ฐ์ฒด๋ฅผ ์์ฑํด์ผ๋ง(new Data()) ํด๋น ๊ฐ์ฒด์ ํ๋์ ์ ๊ทผํ๊ฑฐ๋ ๊ฐ์ ์ค์ ํ ์ ์๋ค.
data๊ฐ null์ด๋ฉด ๋์ค์ ๊ฐ์ ๋ฃ์ ์ ์๋๊ฒ ์๋๋ผ ์์ ์กด์ฌํ์ง ์๋ ์ํ.
Data data = null;๋ก ์ ์ธ๋ ๋ณ์๋ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ์ง ์๋ ์ํ์ด๋ค.
์ด ์ํ์์ data.value = 10;์ ์คํํ๋ ค๊ณ ํ๋ฉด,
data๊ฐ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค์ง ์์ผ๋ฏ๋ก NullPointerException์ด ๋ฐ์ํ๋ค.
data.value์ ์ ๊ทผํ๋ ค๋ฉด, ๋จผ์ ๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌ data๊ฐ ํด๋น ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋๋ก ํด์ผ ํ๋ค.
์ฌ๊ธฐ์ ์ฐ์ธ value ํ๋๋ ๋ญ์ง? - ํด๋์ค์ ๋ฉค๋ฒ ๋ณ์(๋๋ ํ๋)๋ก, ๊ฐ์ฒด๊ฐ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ๊ด๋ฆฌํ๊ธฐ ์ํด ์กด์ฌํ๋ค
1. ํ๋๋ ๋ฌด์์ธ๊ฐ?
ํ๋๋ ํด๋์ค์ ๊ตฌ์ฑ ์์ ์ค ํ๋๋ก, ๊ฐ์ฒด์ ์ํ(state)๋ฅผ ์ ์ฅํ๊ธฐ ์ํ ๋ณ์์ด๋ค.
ํ๋๋ ํด๋์ค ์์ ์ ์ธ๋๋ฉฐ, ๊ฐ์ฒด๊ฐ ์์ฑ๋ ๋ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋๋ค.
๊ฐ์ฒด์ ํ๋์๋ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ฑฐ๋ ํด๋น ๋ฐ์ดํฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์์ ์ ์ํํ ์ ์๋ค.
public class Data {
int value; // ์ซ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ํ๋
}
์ ์ฝ๋์์ value๋ Data ํด๋์ค์ ํ๋์ด๋ฉฐ, int ํ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ธฐ ์ํ ์ญํ ์ ํ๋ค.
2. value ํ๋์ ์ญํ
value ํ๋๋ Data ๊ฐ์ฒด๊ฐ ๊ฐ์ง๋ ์ํ ์ ๋ณด๋ฅผ ๋ํ๋ธ๋ค.
์๋ฅผ ๋ค์ด, Data๋ผ๋ ํด๋์ค๊ฐ ์ด๋ค ์ซ์ ๊ฐ์ ์ ์ฅํ๊ธฐ ์ํด ์ค๊ณ๋ ํด๋์ค๋ผ๋ฉด, value๋ ํด๋น ๊ฐ์ ์ ์ฅํ๋ ๋ฐ ์ฌ์ฉ๋๋ค.
public class Main {
public static void main(String[] args) {
Data data = new Data(); // Data ๊ฐ์ฒด ์์ฑ
data.value = 10; // value ํ๋์ ์ซ์ ์ ์ฅ
System.out.println(data.value); // value ์ถ๋ ฅ: 10
}
}
• ์ฌ๊ธฐ์ data.value = 10;์ Data ๊ฐ์ฒด์ value ํ๋์ 10์ ์ ์ฅํ๋ ์ญํ ์ ํ๋ค.
• System.out.println(data.value);์ value์ ์ ์ฅ๋ ๊ฐ์ ์ถ๋ ฅํ๋ ์ญํ ์ ํ๋ค.
3. ์ ํ๋๊ฐ ํ์ํ๊ฐ?
๊ฐ์ฒด๋ ํด๋์ค๋ผ๋ ์ค๊ณ๋์ ๋ฐ๋ผ ๋ง๋ค์ด์ง๋ ์ค์ ๋ฐ์ดํฐ ๋จ์์ด๋ค.
ํ๋๋ ๊ฐ์ฒด๊ฐ ๊ฐ์ง ํน์ฑ์ด๋ ์ํ๋ฅผ ์ ์ฅํ๋ ๋ฐ ํ์ํ๋ค.
ํด๋์ค ์ค๊ณ ์ ํ๋๋ ํด๋น ํด๋์ค๊ฐ ์ด๋ค ๋ฐ์ดํฐ๋ฅผ ๊ด๋ฆฌํด์ผ ํ๋์ง์ ๋ฐ๋ผ ์ ์๋๋ค.
์๋ฅผ ๋ค์ด:
1. ์ฌ๋ ์ ๋ณด ๊ด๋ฆฌ ํด๋์ค:
public class Person {
String name; // ์ด๋ฆ
int age; // ๋์ด
}
• name: ์ฌ๋์ ์ด๋ฆ์ ์ ์ฅ
• age: ์ฌ๋์ ๋์ด๋ฅผ ์ ์ฅ
1. ๋ฐ์ดํฐ ์ ์ฅ:
Data data = new Data();
data.value = 42; // value ํ๋์ ๊ฐ ์ ์ฅ
2. ๋ฐ์ดํฐ ์ฌ์ฉ:
System.out.println(data.value); // ํ๋ ๊ฐ์ ์ถ๋ ฅ
3. ๋ค๋ฅธ ์์ ์ํ:
data.value = data.value * 2; // ํ๋ ๊ฐ์ ์ฌ์ฉํ์ฌ ์ฐ์ฐ ์ํ
value ํ๋๋ ๊ฐ์ฒด๊ฐ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ๊ด๋ฆฌํ๊ธฐ ์ํด ํด๋์ค์ ์ ์๋ ๋ฉค๋ฒ ๋ณ์์ด๋ค.
ํ๋๋ ๊ฐ์ฒด์ ์ํ๋ฅผ ๋ํ๋ด๋ ์ ๋ณด๋ฅผ ์ ์ฅํ๋ฉฐ, ํด๋์ค์ ์ญํ ๊ณผ ์ค๊ณ์ ๋ฐ๋ผ ๋ค์ํ ๋ฐ์ดํฐ๋ฅผ ๋ด์ ์ ์๋ค.
Data ํด๋์ค์์ value ํ๋๋ ๋จ์ํ ์ซ์๋ฅผ ์ ์ฅํ๋ ์ญํ ์ ํ๋ฉฐ, ํ์์ ๋ฐ๋ผ ๋ฉ์๋์ ํจ๊ป ์ฌ์ฉ๋์ด ๊ฐ์ฒด์ ๋์์ ์ ์ํ๋ค.
4.2. NullPointerException ๋ฐ์ ์๋ฆฌ
์ฐธ์กฐํ ๋ณ์์ null์ด ํ ๋น๋ ์ํ์์ .(dot) ์ฐ์ฐ์๋ฅผ ํตํด ๊ฐ์ฒด์ ํ๋๋ ๋ฉ์๋์ ์ ๊ทผํ๋ ค ํ๋ฉด,
“๊ฐ์ฒด๊ฐ ์๋๋ฐ ๊ฐ์ ์ฐธ์กฐํ๋ ค๊ณ ํ๋ค”๋ ์ด์ ๋ก ์์ธ๊ฐ ๋ฐ์ํ๋ค.
public class NullMain2 {
public static void main(String[] args) {
Data data = null; // data๋ null ์ํ์ด๋ค.
data.value = 10; // NullPointerException ๋ฐ์
}
}
์์ธ ๋ฉ์์ง๋ ๋ค์๊ณผ ๊ฐ๋ค.
Exception in thread "main" java.lang.NullPointerException
4.3. ๋ฉค๋ฒ ๋ณ์๊ฐ null์ธ ๊ฒฝ์ฐ
๋ฉค๋ฒ ๋ณ์์ ์ด๊ธฐํ ๊ณผ์ ์์ ์ฐธ์กฐํ ๋ณ์๋ ๊ธฐ๋ณธ๊ฐ์ผ๋ก null์ด ์ค์ ๋๋ค. ๋ฐ๋ผ์ ๊ฐ์ฒด ์์ฑ ํ, ์ฐธ์กฐํ ๋ณ์์ ๊ฐ์ ํ ๋นํ์ง ์์ผ๋ฉด NullPointerException์ด ๋ฐ์ํ ์ ์๋ค.
BigData ํด๋์ค ์์ :
public class BigData {
Data data; // ์ฐธ์กฐํ ๋ฉค๋ฒ ๋ณ์์ด๋ค.
int count; // ๊ธฐ๋ณธํ ๋ฉค๋ฒ ๋ณ์์ด๋ค.
}
์คํ ์ฝ๋:
public class NullMain3 {
public static void main(String[] args) {
BigData bigData = new BigData(); // BigData ๊ฐ์ฒด ์์ฑ
System.out.println(bigData.count); // 0 ์ถ๋ ฅ
System.out.println(bigData.data); // null ์ถ๋ ฅ
// NullPointerException ๋ฐ์
System.out.println(bigData.data.value); // bigData.data๊ฐ null์ด๋ฏ๋ก ์์ธ ๋ฐ์
}
}
์คํ ๊ณผ์ :
1. BigData ๊ฐ์ฒด๊ฐ ์์ฑ๋๋ฉด, ์ฐธ์กฐํ ๋ฉค๋ฒ ๋ณ์ data๋ ์๋์ผ๋ก null๋ก ์ด๊ธฐํ๋๋ค.
2. bigData.data.value์ ์ ๊ทผํ๋ ค ํ๋ฉด, bigData.data๊ฐ null์ด๊ธฐ ๋๋ฌธ์ NullPointerException์ด ๋ฐ์ํ๋ค.
4.4. NullPointerException ํด๊ฒฐ ๋ฐฉ๋ฒ
4.4.1. ๊ฐ์ฒด๋ฅผ ์์ฑํ ํ ์ฌ์ฉํ๊ธฐ
null ์ํ์ ๋ณ์๋ฅผ ๋ฐ๋ก ์ฌ์ฉํ์ง ๋ง๊ณ , ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ฑฐ๋ ์ด๊ธฐํํ ํ์ ์ฌ์ฉํด์ผ ํ๋ค.
BigData bigData = new BigData();
bigData.data = new Data(); // Data ๊ฐ์ฒด ์์ฑ ๋ฐ ํ ๋น
bigData.data.value = 10; // ์ ์ ์คํ
4.4.2. null ์ฒดํฌํ๊ธฐ
์ฐธ์กฐ ๋ณ์๋ฅผ ์ฌ์ฉํ๊ธฐ ์ ์ null ์ํ์ธ์ง ํ์ธํด์ผ ํ๋ค.
if (bigData.data != null) {
bigData.data.value = 10;
} else {
System.out.println("data๊ฐ null ์ํ์ด๋ค.");
}
4.4.3. Optional ์ฌ์ฉํ๊ธฐ (Java 8 ์ด์)
Optional์ ์ฌ์ฉํ๋ฉด null ์ฒ๋ฆฌ๋ฅผ ๋ ์์ ํ๊ณ ๊ฐ๊ฒฐํ๊ฒ ํ ์ ์๋ค.
Optional<Data> optionalData = Optional.ofNullable(bigData.data);
optionalData.ifPresent(data -> data.value = 10);
4.5. NullPointerException ๋ฐ์ ์์ธ ์ฐพ๊ธฐ
NullPointerException์ด ๋ฐ์ํ์ ๋, ์์ธ ๋ฉ์์ง๋ฅผ ํตํด ์ด๋ค ๋ณ์๊ฐ null ์ํ์ธ์ง ํ์ธํ ์ ์๋ค.
์์ธ ๋ฉ์์ง๋ ๋ค์๊ณผ ๊ฐ๋ค:
Exception in thread "main" java.lang.NullPointerException: Cannot read field "value" because "bigData.data" is null
์ ๋ฉ์์ง๋ฅผ ํตํด bigData.data๊ฐ null์์ ์ ์ ์๋ค.
NullPointerException์ ์ฐธ์กฐํ ๋ณ์๊ฐ null ์ํ์์ ๊ฐ์ฒด์ ์์ฑ์ด๋ ๋ฉ์๋์ ์ ๊ทผํ๋ ค๊ณ ํ ๋ ๋ฐ์ํ๋ ์์ธ์ด๋ค.
์ด๋ฅผ ๋ฐฉ์งํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ ๋ฐฉ๋ฒ์ ์ฌ์ฉํด์ผ ํ๋ค.
1. ๊ฐ์ฒด๋ฅผ ์์ฑํ ํ์ ์ฌ์ฉํ๋ค.
2. ๋ณ์์ ๊ฐ์ด null์ธ์ง ํญ์ ํ์ธํ๋ค.
3. Optional๊ณผ ๊ฐ์ ๊ธฐ๋ฅ์ ํ์ฉํ์ฌ null์ ์์ ํ๊ฒ ์ฒ๋ฆฌํ๋ค.
NullPointerException์ ์๋ฐ์์ ๊ฐ์ฅ ํํ ๋ฐ์ํ๋ ๋ฌธ์ ์ค ํ๋์ด๋ฏ๋ก, ์ฐธ์กฐํ ๋ณ์์ null ์ํ๋ฅผ ํญ์ ์ฃผ์ํด์ผ ํ๋ค.