๐ Contents
- 7. Java
- java ํ๋ก๊ทธ๋๋ฐ์ด๋
- Java SE์ Java EE ์ ํ๋ฆฌ์ผ์ด์ ์ฐจ์ด
- java์ c/c++์ ์ฐจ์ด์
- java ์ธ์ด์ ์ฅ๋จ์
- java์ ์ ๊ทผ ์ ์ด์์ ์ข ๋ฅ์ ํน์ง
- java์ ๋ฐ์ดํฐ ํ์
- Wrapper class
- OOP์ 4๊ฐ์ง ํน์ง
- OOP์ 5๋ ์์น
- ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ๊ณผ ์ ์ฐจ์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ์ฐจ์ด
- ๊ฐ์ฒด์งํฅ์ด๋
- java์ non-static ๋ฉค๋ฒ์ static ๋ฉค๋ฒ์ ์ฐจ์ด
- โjava์ main ๋ฉ์๋๊ฐ static์ธ ์ด์
- java์ final ํค์๋
- java์ ์ ๋ค๋ฆญ๊ณผ c++์ ํ ํ๋ฆฟ์ ์ฐจ์ด
- java์ ๊ฐ๋น์ง ์ปฌ๋ ์ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ
- java ์ง๋ ฌํ์ ์ญ์ง๋ ฌํ๋ ๋ฌด์์ธ๊ฐ
- ํด๋์ค ๊ฐ์ฒด ์ธ์คํด์ค์ ์ฐจ์ด
- ๊ฐ์ฒด๋ ๋ฌด์์ธ๊ฐ
- ์ค๋ฒ๋ก๋ฉ๊ณผ ์ค๋ฒ๋ผ์ด๋ฉ์ ์ฐจ์ด
- Call by Reference์ Call by Value์ ์ฐจ์ด
- ์ธํฐํ์ด์ค์ ์ถ์ ํด๋์ค์ ์ฐจ์ด
- JVM ๊ตฌ์กฐ
- Java Collections Framework
- java Map ์ธํฐํ์ด์ค ๊ตฌํ์ฒด์ ์ข ๋ฅ
- java Set ์ธํฐํ์ด์ค ๊ตฌํ์ฒด์ ์ข ๋ฅ
- java List ์ธํฐํ์ด์ค ๊ตฌํ์ฒด์ ์ข ๋ฅ
- Annotation
- String StringBuilder StringBuffer
- ๋๊ธฐํ์ ๋น๋๊ธฐํ์ ์ฐจ์ด
- java์์ ==์ equals()์ ์ฐจ์ด
- java์ ๋ฆฌํ๋ ์ ์ด๋
- Stream์ด๋
- Lambda๋
- Reference
- ๐ Home
- java์ c/c++์ ๊ฐ์ฅ ํฐ ์ฐจ์ด์ ์ ์คํ ํ๊ฒฝ์ด๋ค.
- java์์์ ๊ฐ๋ฐ: ์ปดํ์ผ ํน์ ์ปดํ์ผ + jar์์ถ
- ์๋ฐ๋ ๋งํฌ ๊ณผ์ ์ด ์์ด ์ปดํ์ผ๋ฌ๊ฐ ๋ฐ๋ก ๋ฐ์ดํธ ์ฝ๋๋ฅผ ์์ฑ
- c/c++์์์ ๊ฐ๋ฐ: ์ปดํ์ผ + ๋งํฌ
- ์ฅ์
- ์ด์์ฒด์ ์ ๋
๋ฆฝ์ ์ด๋ค.
- JVM์์ ๋์ํ๊ธฐ ๋๋ฌธ์, ํน์ ์ด์์ฒด์ ์ ์ข ์๋์ง ์๋๋ค.
- ๊ฐ์ฒด์งํฅ ์ธ์ด์ด๋ค.
- ๊ฐ์ฒด์งํฅ์ ์ผ๋ก ํ๋ก๊ทธ๋๋ฐ ํ๊ธฐ ์ํด ์ฌ๋ฌ ์ธ์ด์ ์ง์์ ํ๊ณ ์๋ค. (์บก์ํ, ์์, ์ถ์ํ, ๋คํ์ฑ ๋ฑ)
- ๊ฐ์ฒด์งํฅ ํจ๋ฌ๋ค์์ ํน์ฑ์ ๋น๊ต์ ์ดํดํ๊ณ ๋ฐฐ์ฐ๊ธฐ ์ฝ๋ค.
- ์๋์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ฅผ ํด์ค๋ค.
- JVM์์ Garbage Collector๋ผ๊ณ ๋ถ๋ฆฌ๋ ๋ฐ๋ชฌ ์ฐ๋ ๋์ ์ํด GC(Garbage Collection)๊ฐ ์ผ์ด๋๋ค. GC๋ก ์ธํด ๋ณ๋์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๊ฐ ํ์ ์์ผ๋ฉฐ ๋น์ง๋์ค ๋ก์ง์ ์ง์คํ ์ ์๋ค. (์ฐธ๊ณ )
- ์คํ์์ค์ด๋ค.
- ์ ํํ ๋งํ๋ฉด OpenJDK๊ฐ ์คํ์์ค์ด๋ค. OracleJDK๋ ์ฌ์ฉ ๋ชฉ์ ์ ๋ฐ๋ผ์ ์ ๋ฃ๊ฐ ๋ ์ ์๋ค.
- OracleJDK์ ์ ๋ฃํ ์ด์๋ ๋ค์์ ์ฐธ๊ณ . (์ฐธ๊ณ )
- ๋ง์ Java ๊ฐ๋ฐ์๊ฐ ์กด์ฌํ๊ณ ์ํ๊ณ๊ฐ ์ ๊ตฌ์ถ๋์ด์๋ค. ๋๋ถ์ ์คํ์์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ํ๋ถํ๋ฉฐ ์ ํ์ฉํ๋ค๋ฉด ์งง์ ๊ฐ๋ฐ ์๊ฐ ๋ด์ ์์ ์ ์ธ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ฝ๊ฒ ๊ตฌํํ ์ ์๋ค.
- ์ ํํ ๋งํ๋ฉด OpenJDK๊ฐ ์คํ์์ค์ด๋ค. OracleJDK๋ ์ฌ์ฉ ๋ชฉ์ ์ ๋ฐ๋ผ์ ์ ๋ฃ๊ฐ ๋ ์ ์๋ค.
- ๋ฉํฐ์ค๋ ๋๋ฅผ ์ฝ๊ฒ ๊ตฌํํ ์ ์๋ค.
- ์๋ฐ๋ ์ค๋ ๋ ์์ฑ ๋ฐ ์ ์ด์ ๊ด๋ จ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ API๋ฅผ ์ ๊ณตํ๊ณ ์๊ธฐ ๋๋ฌธ์ ์คํ๋๋ ์ด์์ฒด์ ์ ์๊ด์์ด ๋ฉํฐ ์ค๋ ๋๋ฅผ ์ฝ๊ฒ ๊ตฌํํ ์ ์๋ค.
- ๋์ ๋ก๋ฉ(Dynamic Loading)์ ์ง์ํ๋ค
- ์ ํ๋ฆฌ์ผ์ด์ ์ด ์คํ๋ ๋ ๋ชจ๋ ๊ฐ์ฒด๊ฐ ์์ฑ๋์ง ์๊ณ , ๊ฐ ๊ฐ์ฒด๊ฐ ํ์ํ ์์ ์ ํด๋์ค๋ฅผ ๋์ ๋ก๋ฉํด์ ์์ฑํ๋ค. ๋ํ ์ ์ง๋ณด์ ์ ํด๋น ํด๋์ค๋ง ์์ ํ๋ฉด ๋๊ธฐ ๋๋ฌธ์ ์ ์ฒด ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ค์ ์ปดํ์ผํ ํ์๊ฐ ์๋ค. ๋ฐ๋ผ์ ์ ์ง๋ณด์๊ฐ ์ฝ๊ณ ๋น ๋ฅด๋ค.
- ์ด์์ฒด์ ์ ๋
๋ฆฝ์ ์ด๋ค.
- ๋จ์
- ๋น๊ต์ ์๋๊ฐ ๋๋ฆฌ๋ค.
- ์๋ฐ๋ ํ ๋ฒ์ ์ปดํ์ผ๋ง์ผ๋ก ์คํ ๊ฐ๋ฅํ ๊ธฐ๊ณ์ด๊ฐ ๋ง๋ค์ด์ง์ง ์๊ณ JVM์ ์ํด ๊ธฐ๊ณ์ด๋ก ๋ฒ์ญ๋๊ณ ์คํํ๋ ๊ณผ์ ์ ๊ฑฐ์น๊ธฐ ๋๋ฌธ์ C๋ C++์ ์ปดํ์ผ ๋จ๊ณ์์ ๋ง๋ค์ด์ง๋ ์์ ํ ๊ธฐ๊ณ์ด๋ณด๋ค๋ ์๋๊ฐ ๋๋ฆฌ๋ค. ๊ทธ๋ฌ๋ ํ๋์จ์ด์ ์ฑ๋ฅ ํฅ์๊ณผ ๋ฐ์ดํธ ์ฝ๋๋ฅผ ๊ธฐ๊ณ์ด๋ก ๋ณํํด์ฃผ๋ JIT ์ปดํ์ผ๋ฌ ๊ฐ์ ๊ธฐ์ ์ ์ฉ์ผ๋ก JVM์ ๊ธฐ๋ฅ์ด ํฅ์๋์ด ์๋์ ๊ฒฉ์ฐจ๊ฐ ๋ง์ด ์ค์ด๋ค์๋ค.
- ์์ธ์ฒ๋ฆฌ๊ฐ ๋ถํธํ๋ค.
- ํ๋ก๊ทธ๋๋จธ ๊ฒ์ฌ๊ฐ ํ์ํ ์์ธ๊ฐ ๋ฑ์ฅํ๋ค๋ฉด ๋ฌด์กฐ๊ฑด ํ๋ก๊ทธ๋๋จธ๊ฐ ์ ์ธ์ ํด์ค์ผ ํ๋ค.
- ๋น๊ต์ ์๋๊ฐ ๋๋ฆฌ๋ค.
- ๊ธฐ๋ณธ ๋ฐ์ดํฐ ํ์
(Primitive Data Type)
- ๊ธฐ๋ณธ ํ์
์ ์ข
๋ฅ๋ byte, short, char, int, float, double, boolean์ด ์๋ค.
- ์ ์ํ : byte, short, int, long
- ์ค์ํ : float, double
- ๋ ผ๋ฆฌํ : boolean(ture/false)
- ๋ฌธ์ํ : char
- ๊ธฐ๋ณธ ํ์ ์ ํฌ๊ธฐ๊ฐ ์๊ณ ๊ณ ์ ์ ์ด๊ธฐ ๋๋ฌธ์ ๋ฉ๋ชจ๋ฆฌ์ Stack ์์ญ์ ์ ์ฅ๋๋ค.
- ๊ธฐ๋ณธ ํ์
์ ์ข
๋ฅ๋ byte, short, char, int, float, double, boolean์ด ์๋ค.
- ์ฐธ์กฐ ํ์
(Reference Data Type)
- ์ฐธ์กฐ ํ์
์ ์ข
๋ฅ๋ class, array, interface, Enumeration์ด ์๋ค.
- ๊ธฐ๋ณธํ์ ์ ์ธํ๊ณ ๋ ๋ชจ๋ ์ฐธ์กฐํ์ด๋ค.
- new ํค์๋๋ฅผ ์ด์ฉํ์ฌ ๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌ ๋ฐ์ดํฐ๊ฐ ์์ฑ๋ ์ฃผ์๋ฅผ ์ฐธ์กฐํ๋ ํ์ ์ด๋ค.
- String, StringBuffer, List, ๊ฐ์ธ์ด ๋ง๋ ํด๋์ค ๋ฑ
- String๊ณผ ๋ฐฐ์ด์ ์ฐธ์กฐ ํ์ ๊ณผ ๋ฌ๋ฆฌ new ์์ด ์์ฑ์ด ๊ฐ๋ฅํ์ง๋ง ๊ธฐ๋ณธ ํ์ ์ด ์๋ ์ฐธ์กฐ ํ์ ์ด๋ค.
- ์ฐธ์กฐ ํ์ ์ ๋ฐ์ดํฐ์ ํฌ๊ธฐ๊ฐ ๊ฐ๋ณ์ , ๋์ ์ด๊ธฐ ๋๋ฌธ์ ๋์ ์ผ๋ก ๊ด๋ฆฌ๋๋ Heap ์์ญ์ ์ ์ฅ๋๋ค.
- ๋ ์ด์ ์ฐธ์กฐํ๋ ๋ณ์๊ฐ ์์ ๋ ๊ฐ๋น์ง ์ปฌ๋ ์ ์ ์ํด ํ๊ดด๋๋ค.
- ์ฐธ์กฐ ํ์ ์ ๊ฐ์ด ์ ์ฅ๋ ๊ณณ์ ์ฃผ์๋ฅผ ์ ์ฅํ๋ ๊ณต๊ฐ์ผ๋ก ๊ฐ์ฒด์ ์ฃผ์๋ฅผ ์ ์ฅํ๋ค. (Call-By-Value)
- ์ฐธ์กฐ ํ์
์ ์ข
๋ฅ๋ class, array, interface, Enumeration์ด ์๋ค.
ํ๋ก๊ทธ๋จ์ ๋ฐ๋ผ ๊ธฐ๋ณธ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฒด๋ก ์ทจ๊ธํด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ์๋ค. ์๋ฅผ ๋ค์ด, ๋ฉ์๋์ ์ธ์๋ก ๊ฐ์ฒด ํ์ ๋ง์ด ์๊ตฌ๋๋ฉด, ๊ธฐ๋ณธ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ๊ทธ๋๋ก ์ฌ์ฉํ ์๋ ์๋ค. ์ด๋ ๊ธฐ๋ณธ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ๋จผ์ ๊ฐ์ฒด๋ก ๋ณํํ ํ ์์ ์ ์ํํด์ผ ํ๋ค.
๊ธฐ๋ณธ ํ์ | ๋ํผ ํด๋์ค |
---|---|
byte |
Byte |
short |
Short |
int |
Integer |
long |
Long |
float |
Float |
double |
Double |
char |
Character |
boolean |
Boolean |
์ด๋ ๊ฒ 8๊ฐ์ ๊ธฐ๋ณธ ํ์ ์ ํด๋นํ๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฒด๋ก ํฌ์ฅํด ์ฃผ๋ ํด๋์ค๋ฅผ ๋ํผ ํด๋์ค(Wrapper class)๋ผ๊ณ ํ๋ค. ๋ํผ ํด๋์ค๋ ๊ฐ๊ฐ์ ํ์ ์ ํด๋นํ๋ ๋ฐ์ดํฐ๋ฅผ ์ธ์๋ก ์ ๋ฌ๋ฐ์, ํด๋น ๊ฐ์ ๊ฐ์ง๋ ๊ฐ์ฒด๋ก ๋ง๋ค์ด ์ค๋ค. ์ด๋ฌํ ๋ํผ ํด๋์ค๋ ๋ชจ๋ java.lang ํจํค์ง์ ํฌํจ๋์ด ์ ๊ณต๋๋ค.
๋ํผ ํด๋์ค(Wrapper class)๋ ์ฐ์ ์ฐ์ฐ์ ์ํด ์ ์๋ ํด๋์ค๊ฐ ์๋๋ฏ๋ก, ์ธ์คํด์ค์ ์ ์ฅ๋ ๊ฐ์ ๋ณ๊ฒฝํ ์ ์๋ค. ๋จ์ง, ๊ฐ์ ์ฐธ์กฐํ๊ธฐ ์ํด ์๋ก์ด ์ธ์คํด์ค๋ฅผ ์์ฑํ๊ณ , ์์ฑ๋ ์ธ์คํด์ค์ ๊ฐ๋ง์ ์ฐธ์กฐํ ์ ์๋ค.
์์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ๊ธฐ๋ณธ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ ๋ํผ ํด๋์ค์ ์ธ์คํด์ค๋ก ๋ณํํ๋ ๊ณผ์ ์ ๋ฐ์ฑ(Boxing), ๋ํผ ํด๋์ค์ ์ธ์คํด์ค์ ์ ์ฅ๋ ๊ฐ์ ๋ค์ ๊ธฐ๋ณธ ํ์ ์ ๋ฐ์ดํฐ๋ก ๊บผ๋ด๋ ๊ณผ์ ์ ์ธ๋ฐ์ฑ(UnBoxing)์ด๋ผ๊ณ ํ๋ค.
JDK 1.5๋ถํฐ๋ ๋ฐ์ฑ๊ณผ ์ธ๋ฐ์ฑ์ด ํ์ํ ์ํฉ์์ ์๋ฐ ์ปดํ์ผ๋ฌ๊ฐ ์ด๋ฅผ ์๋์ผ๋ก ์ฒ๋ฆฌํด ์ค๋ค. ์ด๋ ๊ฒ ์๋ํ๋ ๋ฐ์ฑ๊ณผ ์ธ๋ฐ์ฑ์ ์คํ ๋ฐ์ฑ(AutoBoxing)๊ณผ ์คํ ์ธ๋ฐ์ฑ(AutoUnBoxing)์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค.
Integer num = new Integer(17); // ๋ฐ์ฑ
int n = num.intValue(); // ์ธ๋ฐ์ฑ
System.out.println(n); // ์ถ๋ ฅ ๊ฐ: 17
Character ch = 'X'; // Character ch = new Character('X'); : ์คํ ๋ฐ์ฑ
char c = ch; // char c = ch.charValue(); : ์คํ ์ธ๋ฐ์ฑ
System.out.println(c); // ์ถ๋ ฅ ๊ฐ: X
17
X
์คํ ๋ฐ์ฑ์ ์ด์ฉํ๋ฉด new
ํค์๋๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ๋ ์๋์ผ๋ก Character
์ธ์คํด์ค๋ฅผ ์์ฑํ ์ ์๋ค. ๋ฐ๋๋ก charValue()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ๋, ์คํ ์ธ๋ฐ์ฑ์ ์ด์ฉํ์ฌ ์ธ์คํด์ค์ ์ ์ฅ๋ ๊ฐ์ ๋ฐ๋ก ์ฐธ์กฐํ ์ ์๋ค.
public class Wrapper02 {
public static void main(String[] args) {
Integer num1 = new Integer(7); // ๋ฐ์ฑ
Integer num2 = new Integer(3); // ๋ฐ์ฑ
int int1 = num1.intValue(); // ์ธ๋ฐ์ฑ
int int2 = num2.intValue(); // ์ธ๋ฐ์ฑ
Integer result1 = num1 + num2; // 10
Integer result2 = int1 - int2; // 4
int result3 = num1 * int2; // 21
}
}
public class Wrapper03 {
public static void main(String[] args) {
Integer num1 = new Integer(10);
Integer num2 = new Integer(20);
Integer num3 = new Integer(10);
System.out.println(num1 < num2); // true
System.out.println(num1 == num3); // false
System.out.println(num1.equals(num3)); // true
}
}
๋ํผ ํด๋์ค์ ๋น๊ต ์ฐ์ฐ๋ ์คํ ์ธ๋ฐ์ฑ์ ํตํด ๊ฐ๋ฅํด์ง์ง๋ง, ์ธ์คํด์ค์ ์ ์ฅ๋ ๊ฐ์ ๋๋ฑ ์ฌ๋ถ ํ๋จ์ ๋น๊ต ์ฐ์ฐ์์ธ ๋๋ฑ ์ฐ์ฐ์(==
)๋ฅผ ์ฌ์ฉํด์๋ ์ ๋๋ฉฐ, equals()
๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ผ๋ง ํ๋ค.
๋ํผ ํด๋์ค๋ ๊ฐ์ฒด์ด๋ฏ๋ก ๋๋ฑ ์ฐ์ฐ์(==
)๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ฉด, ๋ ์ธ์คํด์ค์ ๊ฐ์ ๋น๊ตํ๋ ๊ฒ์ด ์๋๋ผ ๋ ์ธ์คํด์ค์ ์ฃผ์๊ฐ์ ๋น๊ตํ๋ค.
๋ฐ๋ผ์ ์๋ก ๋ค๋ฅธ ๋ ์ธ์คํด์ค๋ฅผ ๋๋ฑ ์ฐ์ฐ์(==
)๋ก ๋น๊ตํ๊ฒ ๋๋ฉด, ์ธ์ ๋ false
๊ฐ์ ๋ฐํํ๋ค.
๊ทธ๋ฌ๋ฏ๋ก ์ธ์คํด์ค์ ์ ์ฅ๋ ๊ฐ์ ๋๋ฑ ์ฌ๋ถ๋ฅผ ์ ํํ ํ๋จํ๋ ค๋ฉด equals()
๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ผํ๋ค.
- ์ถ์ํ(Abstraction)
- ๊ตฌ์ฒด์ ์ธ ์ฌ๋ฌผ๋ค์ ๊ณตํต์ ์ธ ํน์ง์ ํ์ ํด์ ์ด๋ฅผ ํ๋์ ๊ฐ๋ (์งํฉ)์ผ๋ก ๋ค๋ฃจ๋ ๊ฒ
- ์บก์ํ(Encapsulation)
- ์ ๋ณด ์๋(information hiding): ํ์๊ฐ ์๋ ์ ๋ณด๋ ์ธ๋ถ์์ ์ ๊ทผํ์ง ๋ชปํ๋๋ก ์ ํํ๋ ๊ฒ
- ๋์ ์์ง๋, ๋ฎ์ ๊ฒฐํฉ๋๋ฅผ ์ ์งํ์ฌ ์ ์ฐํจ๊ณผ ์ ์ง๋ณด์์ฑ ์ฆ๊ฐ
- ์ผ๋ฐํ ๊ด๊ณ(Inheritance, ์์)
- ์ฌ๋ฌ ๊ฐ์ฒด๋ค์ด ๊ฐ์ง ๊ณตํต๋ ํน์ฑ์ ๋ถ๊ฐ์์ผ ํ๋์ ๊ฐ๋ ์ด๋ ๋ฒ์น์ผ๋ก ์ฑ๋ฆฝ์ํค๋ ๊ณผ์
- ๋คํ์ฑ(Polymorphism)
- ์๋ก ๋ค๋ฅธ ํด๋์ค์ ๊ฐ์ฒด๊ฐ ๊ฐ์ ๋ฉ์์ง๋ฅผ ๋ฐ์์ ๋ ๊ฐ์์ ๋ฐฉ์์ผ๋ก ๋์ํ๋ ๋ฅ๋ ฅ
- ์ค๋ฒ๋ผ์ด๋ฉ(Overriding), ์ค๋ฒ๋ก๋ฉ(Overloading)
"SOLID" ์์น
- S: ๋จ์ผ ์ฑ
์ ์์น(SRP, Single Responsibility Principle)
- ๊ฐ์ฒด๋ ๋จ ํ๋์ ์ฑ ์๋ง ๊ฐ์ ธ์ผ ํ๋ค.
- O: ๊ฐ๋ฐฉ-ํ์ ์์น(OCP, Open Closed Principle)
- ๊ธฐ์กด์ ์ฝ๋๋ฅผ ๋ณ๊ฒฝํ์ง ์์ผ๋ฉด์ ๊ธฐ๋ฅ์ ์ถ๊ฐํ ์ ์๋๋ก ์ค๊ณ๊ฐ ๋์ด์ผ ํ๋ค.
- L: ๋ฆฌ์ค์ฝํ ์นํ ์์น(LSP, Liskov Substitution Principle)
- ์ผ๋ฐํ ๊ด๊ณ์ ๋ํ ์ด์ผ๊ธฐ๋ฉฐ, ์์ ํด๋์ค๋ ์ต์ํ ์์ ์ ๋ถ๋ชจ ํด๋์ค์์ ๊ฐ๋ฅํ ํ์๋ ์ํํ ์ ์์ด์ผ ํ๋ค.
- I: ์ธํฐํ์ด์ค ๋ถ๋ฆฌ ์์น(ISP, Interface Segregation Principle)
- ์ธํฐํ์ด์ค๋ฅผ ํด๋ผ์ด์ธํธ์ ํนํ๋๋๋ก ๋ถ๋ฆฌ์ํค๋ผ๋ ์ค๊ณ ์์น์ด๋ค.
- D: ์์กด ์ญ์ ์์น(DIP, Dependency Inversion Principle)
- ์์กด ๊ด๊ณ๋ฅผ ๋งบ์ ๋ ๋ณํํ๊ธฐ ์ฌ์ด ๊ฒ ๋๋ ์์ฃผ ๋ณํํ๋ ๊ฒ๋ณด๋ค๋ ๋ณํํ๊ธฐ ์ด๋ ค์ด ๊ฒ, ๊ฑฐ์ ๋ณํ๊ฐ ์๋ ๊ฒ์ ์์กดํ๋ผ๋ ๊ฒ์ด๋ค.
- ์ ์ฐจ์งํฅ ํ๋ก๊ทธ๋๋ฐ
- ์คํํ๊ณ ์ ํ๋ ์ ์ฐจ๋ฅผ ์ ํ๊ณ , ์ด ์ ์ฐจ๋๋ก ํ๋ก๊ทธ๋๋ฐํ๋ ๋ฐฉ๋ฒ
- ๋ชฉ์ ์ ๋ฌ์ฑํ๊ธฐ ์ํ ์ผ์ ํ๋ฆ์ ์ค์ ์ ๋๋ค.
- ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ
- ์ค์ธ์์ ๋ฌผ์ฒด๋ฅผ ๊ฐ์ฒด๋ก ํํํ๊ณ , ์ด๋ค ์ฌ์ด์ ๊ด๊ณ, ์ํธ ์์ฉ์ ํ๋ก๊ทธ๋จ์ผ๋ก ๋ํ๋ธ๋ค.
- ๊ฐ์ฒด๋ฅผ ์ถ์ถํ๊ณ ๊ฐ์ฒด๋ค์ ๊ด๊ณ๋ฅผ ๊ฒฐ์ ํ๊ณ ์ด๋ค์ ์ํธ ์์ฉ์ ํ์ํ ํจ์(๋ฉ์๋)์ ๋ณ์(ํ๋)๋ฅผ ์ค๊ณ ๋ฐ ๊ตฌํํ๋ค.
- ๊ฐ์ฒด ์งํฅ์ ํต์ฌ์ ์ฐ๊ด๋์ด ์๋ ๋ณ์์ ๋ฉ์๋๋ฅผ ํ๋์ ๊ทธ๋ฃน์ผ๋ก ๋ฌถ์ด์ ๊ทธ๋ฃนํํ๋ ๊ฒ์ด๋ค.
- ์ฌ๋์ ์ฌ๊ณ ์ ๊ฐ์ฅ ๋น์ทํ๊ฒ ํ๋ก๊ทธ๋๋ฐ์ ํ๊ธฐ ์ํด์ ์์ฑ๋ ๊ธฐ๋ฒ
- ํ๋์ ํด๋์ค๋ฅผ ๋ฐํ์ผ๋ก ์๋ก ๋ค๋ฅธ ์ํ๋ฅผ ๊ฐ์ง ์ธ์คํด์ค๋ฅผ ๋ง๋ค๋ฉด ์๋ก ๋ค๋ฅธ ํ๋์ ํ๊ฒ ๋๋ค. ์ฆ, ํ๋์ ํด๋์ค๊ฐ ์ฌ๋ฌ ๊ฐ์ ์ธ์คํด์ค๊ฐ ๋ ์ ์๋ค๋ ์ ์ด ๊ฐ์ฒด ์งํฅ์ด ์ ๊ณตํ๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์ฌํ์ฉ์ฑ์ด๋ผ๊ณ ํ ์ ์๋ค.
- ๊ฐ์ฒด(Object)
- ํ์ค์ธ๊ณ์ ์ค์ฒด ๋ฐ ๊ฐ๋ ์ ๋ฐ์ํ๋ ์ํ(Status)์ ํ์(Behavior)๋ฅผ ์ ์ํ ๋ฐ์ดํฐ์ ์งํฉ
- ๊ฐ์ฒด์งํฅ(Object-Oriented) ํ๋ก๊ทธ๋๋ฐ
- ๊ฐ์์ ์ญํ ์ ์ง๋ ๊ฐ์ฒด๋ค๋ผ๋ฆฌ ์๋ก ๋ฉ์์ง๋ฅผ ์ฃผ๊ณ ๋ฐ์ผ๋ฉฐ ๋์ํ ์ ์๋๋ก ํ๋ก๊ทธ๋๋ฐ ํ๋ ๊ฒ
๊ฐ์ฒด๋ฅผ ์ค์ฌ์ผ๋ก ํ๋ก๊ทธ๋๋ฐํ๊ธฐ ๋๋ฌธ์,
- ์ฌ๋์ ๊ด์ ์์ ํ๋ก๊ทธ๋จ์ ์ดํดํ๊ณ ํ์ ํ๊ธฐ ์ฝ๋ค.
- ๊ฐํ ์์ง๋ ฅ(Strong Cohesion)๊ณผ ์ฝํ ๊ฒฐํฉ๋ ฅ(Weak Coupling)์ ๊ฐ์ง๋ค.
- ์ฌ์ฌ์ฉ์ฑ, ํ์ฅ์ฑ, ์ตํต์ฑ์ด ๋๋ค.
์ด๋ฌํ ์ฅ์ ๋๋ฌธ์ ๋๋ฒ๊น ๊ณผ ์ ์ง๋ณด์๊ฐ ์ฉ์ดํ๊ณ ์ค๊ณ๊ณผ ๋ถ์์ด ๋น๊ต์ ์ฝ๋ค.
- ๊ฐ์ฒด ๊ฐ์ ์ ๋ณด ๊ตํ์ด ๋ชจ๋ ๋ฉ์์ง ๊ตํ์ ํตํด ์ผ์ด๋๋ฏ๋ก ์คํ ์์คํ
์ ๋ง์ overhead๊ฐ ๋ฐ์ํ๊ฒ ๋๋ค.
- ์ฒ๋ฆฌ์๋๊ฐ ์๋์ ์ผ๋ก ๋๋ฆฌ๋ค.
- ํ์ง๋ง ํ๋์จ์ด์ ๋ฐ์ ์ผ๋ก ์ด๋ฌํ ๋จ์ ์ ์ด๋์ ๋ ํด์๋์๋ค.
- ๊ฐ์ฒด๊ฐ ์ํ๋ฅผ ๊ฐ๊ธฐ ๋๋ฌธ์ ์์์น ๋ชปํ ๋ถ์์ฉ์ด ๋ฐ์ํ ์ ์๋ค. ๋ณ์๊ฐ ์กด์ฌํ๊ณ ์ด ๋ณ์๋ฅผ ํตํด ๊ฐ์ฒด๊ฐ ์์ธกํ ์ ์๋ ์ํ๋ฅผ ๊ฐ๊ฒ ๋์ด ์ ํ๋ฆฌ์ผ์ด์
๋ด๋ถ์์ ๋ฒ๊ทธ๋ฅผ ๋ฐ์์ํฌ ์ ์๋ค.
- ์ด๋ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ๋ฑ์ฅ์ ํจ๋ฌ๋ค์์ด๋ค.
- SRP(Single Responsibility Principle)๋จ์ผ ์ฑ
์ ์์น
- ํด๋์ค๋ ๋จ ํ๋์ ์ฑ ์์ ๊ฐ์ ธ์ผ ํ๋ฉฐ ํด๋์ค๋ฅผ ๋ณ๊ฒฝํ๋ ์ด์ ๋ ๋จ ํ๋์ ์ด์ ์ด์ด์ผ ํ๋ค.
- OCP(Open-Closed Principle) : ๊ฐ๋ฐฉ-ํ์ ์์น
- ํ์ฅ์๋ ์ด๋ ค ์์ด์ผ ํ๊ณ ๋ณ๊ฒฝ์๋ ๋ซํ ์์ด์ผ ํ๋ค.
- LSP(Liskov Substitution Principle) : ๋ฆฌ์ค์ฝํ ์นํ ์์น
- ์์ ํ์ ์ ๊ฐ์ฒด๋ฅผ ํ์ ํ์ ์ ๊ฐ์ฒด๋ก ์นํํด๋ ์์ ํ์ ์ ์ฌ์ฉํ๋ ํ๋ก๊ทธ๋จ์ ์ ์์ ์ผ๋ก ๋์ํด์ผ ํ๋ค.
- ISP(Interface Segregation Principle) : ์ธํฐํ์ด์ค ๋ถ๋ฆฌ ์์น
- ์ธํฐํ์ด์ค๋ ๊ทธ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ ํด๋ผ์ด์ธํธ๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ถ๋ฆฌํด์ผ ํ๋ค.
- DIP(Dependency Inversion Principle) : ์์กด ์ญ์ ์์น
- ๊ณ ์์ค ๋ชจ๋์ ์ ์์ค ๋ชจ๋์ ๊ตฌํ์ ์์กดํด์๋ ์๋๋ค.
- ์ถ์ํ
- ๊ฐ์ฒด์์ ๊ณตํต๋ ์์ฑ์ด๋ ๊ธฐ๋ฅ์ ์ถ์ถํ๋ ๊ฒ. ์ค์ํ์ง ์์ ๊ฒ(๊ด์ฌ ๋์์ด ์๋ ๊ฒ)์ ๊ฐ์ถ๊ฑฐ๋ ๋ฌด์ํ๊ณ , ์ค์ํ ๊ฒ(๊ด์ฌ์๋ ๊ฒ)๋ง์ ๊ฐ์กฐํ์ฌ ์ถ์ถํ๋ ๊ฒ. ๊ด์ ์ ๋ฐ๋ผ ์ถ์ํ์ ๊ฒฐ๊ณผ๊ฐ ๋ฌ๋ผ์ง ์ ์๋ค. ์ฃผ์ ๊ด์ฌ์ฌ์๋ง ์ง์คํจ์ผ๋ก์จ, ํ๋ก๊ทธ๋จ์ ๋ณต์ก๋๋ฅผ ๊ด๋ฆฌํ ์ ์๋ค.
- ์บก์ํ
- ๊ด์ฌ์๋ ๋ฐ์ดํฐ์ ๊ธฐ๋ฅ์ ๋ชจ์๋๊ณ ํจํนํ ๊ฒ์ด๋ค. ๊ฐ์ฒด์งํฅ์์๋ ์ด๋ฅผ ํด๋์ค๋ก ์ ์ํ๊ณ ์ธ๋ถ์์ ๋ง์๋๋ก ์ ๊ทผํ ์ ์๊ฒํ์๋ค. ๊ณผ๊ฑฐ ์ ์ฐจ์งํฅ ํ๋ก๊ทธ๋๋ฐ์์๋ ์์ค์ฝ๋๊ฐ ๊ฑฐ๋ํด์ง์๋ก ๋ฐ์ดํฐ๊ฐ ์ด๋์ ์ด๋ป๊ฒ ๋ณํํ๋์ง ํ์ ํ๊ธฐ ์ด๋ ค์ ๊ณ ์ ์ง๋ณด์๊ฐ ํ๋ค์ด์ง๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ์๋ค. ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์์๋ ์บก์ํ๋ฅผ ํตํด ์ด๋ ํ๋จ์ ํด๊ฒฐํ์๋ค. ์ด๋ ๊ฒ ๋ด๋ถ์ ๋ฐ์ดํฐ๋ ํจ์๋ฅผ ์ธ๋ถ์์ ์ฐธ์กฐํ์ง ๋ชปํ๋๋ก ์ฐจ๋จํ๋ ๊ฐ๋ ์ ์ ๋ณด ์๋ํ(Information Hiding)๋ผ๊ณ ํ๋ฉฐ ์ด๊ฒ์ด ๋ฐ๋ก ์บก์ํ๋ผ๋ ๊ฐ๋ ์ด๋ค.
- ๋คํ์ฑ
- ๊ฐ์ ์ฝ๋๋ผ ํ๋๋ผ๋ ์ํฉ์ ๋ฐ๋ผ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ๋์ํ๋ ์ฑ์ง. Java์์ ๋คํ์ฑ์ ๊ตฌํํ ์ ์๋ ๋ํ์ ์ผ๋ก Overriding๊ณผ Overloading์ด ์๋ค.
- Overriding
- ์์์ ํด๋์ค๊ฐ ๋ค๋ฅธ ํด๋์ค๋ฅผ ์์ ๋ฐ๊ฑฐ๋ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ์ ๋, ์์ ํด๋์ค ๋๋ ์ธํฐํ์ด์ค์ ์ ์๋์ด ์๋ ๋ฉ์๋๋ฅผ ์ฌ์ ์ ํ์ฌ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. ๋ฉ์๋ ํธ์ถ ์ ์ฌ์ ์๋์ด ์์ง ์๋ค๋ฉด ์์ ํด๋์ค์ ๋ฉ์๋๊ฐ ํธ์ถ๋๋ค. (์ธํฐํ์ด์ค๋ ์ค๋ฒ๋ผ์ด๋ฉ์ด ๊ฐ์ ๋๋ค.)
- Overloading
- ๋ฉ์๋์ ์ฃผ์ด์ง ์ธ์(parameter)์ ๋ฐ๋ผ ๋์์ ๋ค๋ฅด๊ฒ ๊ตฌํํ ์ ์๋ค. ์ฝ๋์ ์ค๋ณต์ด ์ค์ด๋ค๊ณ , ๊ฐ๋ ์ฑ์ด ๋์ด๋๋ค. ๋ฐํ ํ(return type)์ ๊ด๊ณ๊ฐ ์์ง๋ง, ์ธ์์ ๊ฐ์, ์ธ์์ ํ์ ์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ๊ตฌํํ ์ ์๋ค.
- ์์
- ๋ถ๋ชจ์ ํ์ง์ ์ด์ด๋ฐ๋๋ค๋ ์๋ฏธ๋ก, ๋ถ๋ชจ ํด๋์ค์ ์์ฑ๊ณผ ๋ฉ์๋๋ฅผ ๊ทธ๋๋ก ํ์ฉํ ์ ์๋ค. ์ฌ๊ธฐ์ ๋ํด ์๋ก์ด ์์ฑ๊ณผ ๋ฉ์๋๋ฅผ ์ถ๊ฐํ ์ ์์ผ๋ฉฐ ๊ฐ์ ๋ฉ์๋๋ผ ํ๋๋ผ๋ ์ค๋ฒ๋ผ์ด๋ฉ(Overriding)์ ํตํ์ฌ ์ฌ์ ์ํ์ฌ ๋ค๋ฅด๊ฒ ๋์ํ๊ฒ๋ ํ ์ ์๋ค. ์์ฝ๊ฒ ํด๋์ค๋ฅผ ์ฌํ์ฉํ ์ ์์ผ๋ฉฐ, ๋ถ๋ชจ๊ฐ ๊ฐ์ ํด๋์ค๋ค์ ๋์์ ์ฒ๋ฆฌํ๊ธฐ ์ฉ์ดํ๋ค.
- ํด๋์ค(class)
- ๊ฐ์ฒด๋ฅผ ๋ง๋ค๊ธฐ ์ํด ์ํ(field)์ ํ์(method)๋ฅผ ์ ์ํ ํ.
- ๋ฉ์์ง
- ๊ฐ์ฒด์งํฅ์ ์ผ๋ก ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ๊ฐ์ฒด๋ค๋ผ๋ฆฌ์ ๋ฉ์์ง๋ฅผ ์ฃผ๊ณ ๋ฐ๊ณ ์ํธ์์ฉํ๋ฉฐ ๋์ํ๋ค. ์ฝ๋์ ์ผ๋ก๋ ์์์ ๊ฐ์ฒด์๊ฒ ์ธ์(parameter)๋ฅผ ์ ๋ฌํ์ฌ ๋ฉ์๋๋ฅผ ํธ์ถํ๋ฉฐ ๋ฐํ๊ฐ(return value)์ ๋ฐ์ ์ฒ๋ฆฌ๋ฅผ ํ๋ค.
- non-static ๋ฉค๋ฒ
- ๊ณต๊ฐ์ ํน์ฑ: ๋ฉค๋ฒ๋ ๊ฐ์ฒด๋ง๋ค ๋ณ๋๋ก ์กด์ฌํ๋ค.
- ์ธ์คํด์ค ๋ฉค๋ฒ ๋ผ๊ณ ๋ถ๋ฅธ๋ค.
- ์๊ฐ์ ํน์ฑ: ๊ฐ์ฒด ์์ฑ ์์ ๋ฉค๋ฒ๊ฐ ์์ฑ๋๋ค.
- ๊ฐ์ฒด๊ฐ ์๊ธธ ๋ ๋ฉค๋ฒ๋ ์์ฑ๋๋ค.
- ๊ฐ์ฒด ์์ฑ ํ ๋ฉค๋ฒ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค.
- ๊ฐ์ฒด๊ฐ ์ฌ๋ผ์ง๋ฉด ๋ฉค๋ฒ๋ ์ฌ๋ผ์ง๋ค.
- ๊ณต์ ์ ํน์ฑ: ๊ณต์ ๋์ง ์๋๋ค.
- ๋ฉค๋ฒ๋ ๊ฐ์ฒด ๋ด์ ๊ฐ๊ฐ์ ๊ณต๊ฐ์ ์ ์งํ๋ค.
- ๊ณต๊ฐ์ ํน์ฑ: ๋ฉค๋ฒ๋ ๊ฐ์ฒด๋ง๋ค ๋ณ๋๋ก ์กด์ฌํ๋ค.
- static ๋ฉค๋ฒ
- ๊ณต๊ฐ์ ํน์ฑ: ๋ฉค๋ฒ๋ ํด๋์ค๋น ํ๋๊ฐ ์์ฑ๋๋ค.
- ๋ฉค๋ฒ๋ ๊ฐ์ฒด ๋ด๋ถ๊ฐ ์๋ ๋ณ๋์ ๊ณต๊ฐ์ ์์ฑ๋๋ค.
- ํด๋์ค ๋ฉค๋ฒ ๋ผ๊ณ ๋ถ๋ฅธ๋ค.
- ์๊ฐ์ ํน์ฑ: ํด๋์ค ๋ก๋ฉ ์์ ๋ฉค๋ฒ๊ฐ ์์ฑ๋๋ค.
- ๊ฐ์ฒด๊ฐ ์๊ธฐ๊ธฐ ์ ์ ์ด๋ฏธ ์์ฑ๋๋ค.
- ๊ฐ์ฒด๊ฐ ์๊ธฐ๊ธฐ ์ ์๋ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค. (์ฆ, ๊ฐ์ฒด๋ฅผ ์์ฑํ์ง ์๊ณ ๋ ์ฌ์ฉํ ์ ์๋ค.)
- ๊ฐ์ฒด๊ฐ ์ฌ๋ผ์ ธ๋ ๋ฉค๋ฒ๋ ์ฌ๋ผ์ง์ง ์๋๋ค.
- ๋ฉค๋ฒ๋ ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋ ๋ ์ฌ๋ผ์ง๋ค.
- ๊ณต์ ์ ํน์ฑ: ๋์ผํ ํด๋์ค์ ๋ชจ๋ ๊ฐ์ฒด๋ค์ ์ํด ๊ณต์ ๋๋ค.
- ๊ณต๊ฐ์ ํน์ฑ: ๋ฉค๋ฒ๋ ํด๋์ค๋น ํ๋๊ฐ ์์ฑ๋๋ค.
static
ํค์๋static
๋ฉค๋ฒ๋ ํด๋์ค ๋ก๋ฉ(ํ๋ก๊ทธ๋จ ์์) ์ ๋ฉ๋ชจ๋ฆฌ์ ๋ก๋๋์ด ์ธ์คํดํธ๋ฅผ ์์ฑํ์ง ์์๋ ํธ์ถ์ด ๊ฐ๋ฅํ๋ค.
- main ๋ฉ์๋๊ฐ
static
์ธ ์ด์-
public static void main(String[] args){...}
- ์์ ๊ฐ์ ํ์์ java์์์
main()
๊ด๋ก์ด๋ค. ์์ ๊ฐ์ ์๊ทธ๋์ฒ๋ฅผ ๊ฐ์ง ๋ฉ์๋๊ฐ ์์ผ๋ฉด ์คํ๋์ง ์๋๋ค. - JVM์ ์ธ์คํด์ค๊ฐ ์๋ ํด๋์ค์
main()
์ ํธ์ถํด์ผํ๊ธฐ ๋๋ฌธ์static
์ด์ด์ผ ํ๋ค.
-
- JVM๊ณผ
static
- ์ฝ๋๋ฅผ ์คํํ๋ฉด ์ปดํ์ผ๋ฌ๊ฐ
.java
์ฝ๋๋ฅผ.class
(byte code)๋ก ๋ณํํ๋ค. - ํด๋์ค ๋ก๋๊ฐ
.class
ํ์ผ์ ๋ฉ๋ชจ๋ฆฌ ์์ญ(Runtime Data Area)์ ๋ก๋ํ๋ค. - Runtime Data Area ์ค Meathod Area(= Class area = Static area)๋ผ๊ณ ๋ถ๋ฆฌ๋ ์์ญ์ Class Variable์ด ์ ์ฅ๋๋๋ฐ,
static
๋ณ์ ๋ํ ์ฌ๊ธฐ์ ํฌํจ๋๋ค. - JVM์ Meathod Area์ ๋ก๋๋
main()
์ ์คํํ๋ค.
- ์ฝ๋๋ฅผ ์คํํ๋ฉด ์ปดํ์ผ๋ฌ๊ฐ
- JVM์ Runtime Data Area - Minhyeok Jung
- Why is the Java main method static? - Stack Overflow
- main์ static ์ฌ์ฉํ๋์ด์ :: public static void main(String[] args) - PYH
- [์๋ฐ]static, JVM memory์ ๊ธฐ๋ณธ(1ํธ) - ITPangPang
- JAVA :: ์๋ฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ - 1. ๋ฉ์๋ ์์ญ(Method Area) - WANZARGEN
- final ํค์๋
- ๊ฐ๋ : ๋ณ์๋ ๋ฉ์๋ ๋๋ ํด๋์ค๊ฐ '๋ณ๊ฒฝ ๋ถ๊ฐ๋ฅ'ํ๋๋ก ๋ง๋ ๋ค.
- ์์(Primitive) ๋ณ์์ ์ ์ฉ ์
- ํด๋น ๋ณ์์ ๊ฐ์ ๋ณ๊ฒฝ์ด ๋ถ๊ฐ๋ฅํ๋ค.
- ์ฐธ์กฐ(Reference) ๋ณ์์ ์ ์ฉ ์
- ์ฐธ์กฐ ๋ณ์๊ฐ ํ(heap) ๋ด์ ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ๋ณ๊ฒฝํ ์ ์๋ค.
- ๋ฉ์๋์ ์ ์ฉ ์
- ํด๋น ๋ฉ์๋๋ฅผ ์ค๋ฒ๋ผ์ด๋ํ ์ ์๋ค.
- ํด๋์ค์ ์ ์ฉ ์
- ํด๋น ํด๋์ค์ ํ์ ํด๋์ค๋ฅผ ์ ์ํ ์ ์๋ค.
- finally ํค์๋
- ๊ฐ๋ : try/catch ๋ธ๋ก์ด ์ข ๋ฃ๋ ๋ ํญ์ ์คํ๋ ์ฝ๋ ๋ธ๋ก์ ์ ์ํ๊ธฐ ์ํด ์ฌ์ฉํ๋ค.
- finally๋ ์ ํ์ ์ผ๋ก try ํน์ catch ๋ธ๋ก ๋ค์ ์ ์ํ ๋ ์ฌ์ฉํ๋ค.
- finally ๋ธ๋ก์ ์์ธ๊ฐ ๋ฐ์ํ๋๋ผ๋ ํญ์ ์คํ๋๋ค.
- ๋จ, JVM์ด try ๋ธ๋ก ์คํ ์ค์ ์ข ๋ฃ๋๋ ๊ฒฝ์ฐ๋ ์ ์ธํ๋ค.
- finally ๋ธ๋ก์ ์ข ์ข ๋ท๋ง๋ฌด๋ฆฌ ์ฝ๋๋ฅผ ์์ฑํ๋ ๋ฐ ์ฌ์ฉ๋๋ค.
- finally ๋ธ๋ก์ try์ catch ๋ธ๋ก ๋ค์๊ณผ, ํต์ ๊ถ์ด ์ด์ ์ผ๋ก ๋ค์ ๋์๊ฐ๊ธฐ ์ ์ฌ์ด์ ์คํ๋๋ค.
- finalize() ๋ฉ์๋
- ๊ฐ๋ : ์ฐ๋ ๊ธฐ ์์ง๊ธฐ(GC, Garbage Collector)๊ฐ ๋ ์ด์์ ์ฐธ์กฐ๊ฐ ์กด์ฌํ์ง ์๋ ๊ฐ์ฒด๋ฅผ ๋ฉ๋ชจ๋ฆฌ์์ ์ญ์ ํ๊ฒ ๋ค๊ณ ๊ฒฐ์ ํ๋ ์๊ฐ ํธ์ถ๋๋ค.
- Object ํด๋์ค์ finalize() ๋ฉ์๋๋ฅผ ์ค๋ฒ๋ผ์ด๋ํด์ ๋ง์ถค๋ณ GC๋ฅผ ์ ์ํ ์ ์๋ค.
protected void finalize() throws Throwable { // ํ์ผ ๋ซ๊ธฐ, ์์ ๋ฐํ ๋ฑ๋ฑ }
- java์ ์ ๋ค๋ฆญ(Generic)
- ๊ฐ๋ : ๋ชจ๋ ์ข ๋ฅ์ ํ์ ์ ๋ค๋ฃฐ ์ ์๋๋ก ์ผ๋ฐํ๋ ํ์ ๋งค๊ฐ ๋ณ์(generic type)๋ก ํด๋์ค๋ ๋ฉ์๋๋ฅผ ์ ์ธํ๋ ๊ธฐ๋ฒ
-
- ์ฒ๋ฆฌ ๋ฐฉ๋ฒ: ํ์
์ ๊ฑฐ(type erasure)๋ผ๋ ๊ฐ๋
์ ๊ทผ๊ฑฐํ๋ค.
- ์์ค ์ฝ๋๋ฅผ JVM์ด ์ธ์ํ๋ ๋ฐ์ดํธ ์ฝ๋๋ก ๋ณํํ ๋ ์ธ์๋ก ์ฃผ์ด์ง ํ์ ์ ์ ๊ฑฐํ๋ ๊ธฐ์ ์ด๋ค.
- ์ ๋ค๋ฆญ์ด ์๋ค๊ณ ํด์ ํฌ๊ฒ ๋ฌ๋ผ์ง๋ ๊ฒ์ ์๋ค. ๋จ์ง ์ฝ๋๋ฅผ ์ข ๋ ์์๊ฒ ํ ๋ฟ์ด๋ค.
- ๊ทธ๋์ java์ ์ ๋ค๋ฆญ(Generic)์ ๋๋ก๋ ๋ฌธ๋ฒ์ ์๋ (syntactic sugar) ์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค.
Vector<String> vector = new Vector<String>();
vector.add(new String("hello"));
String str = vector.get(0);
// ์ปดํ์ผ๋ฌ๊ฐ ์๋์ ๊ฐ์ด ๋ณํ
Vector vector = new Vector();
vector.add(new String("hello"));
String str = (String) vector.get(0);
- c++์ ํ
ํ๋ฆฟ(Template)
- ๊ฐ๋
: ํ
ํ๋ฆฟ์ ํ๋์ ํด๋์ค๋ฅผ ์๋ก ๋ค๋ฅธ ์ฌ๋ฌ ํ์
์ ์ฌ์ฌ์ฉํ ์ ์๋๋ก ํ๋ ๋ฐฉ๋ฒ
- ์๋ฅผ ๋ค์ด ์ฌ๋ฌ ํ์ ์ ๊ฐ์ฒด๋ฅผ ์ ์ฅํ ์ ์๋ ์ฐ๊ฒฐ๋ฆฌ์คํธ์ ๊ฐ์ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋ง๋ค ์ ์๋ค.
- ์ฒ๋ฆฌ ๋ฐฉ๋ฒ: ์ปดํ์ผ๋ฌ๋ ์ธ์๋ก ์ฃผ์ด์ง ๊ฐ๊ฐ์ ํ์
์ ๋ํด ๋ณ๋์ ํ
ํ๋ฆฟ ์ฝ๋๋ฅผ ์์ฑํ๋ค.
- ์๋ฅผ ๋ค์ด MyClass๊ฐ MyClass์ ์ ์ ๋ณ์(static variable)๋ฅผ ๊ณต์ ํ์ง ์๋๋ค.
- ํ์ง๋ง java์์ ์ ์ ๋ณ์๋ ์ ๋ค๋ฆญ(Generic) ์ธ์๋ก ์ด๋ค ํ์ ์ ์ฃผ์๋์ง์ ๊ด๊ณ์์ด MyClass๋ก ๋ง๋ ๋ชจ๋ ๊ฐ์ฒด๊ฐ ๊ณต์ ํ๋ค.
- ์ฆ, ํ ํ๋ฆฟ์ ์ข ๋ ์ฐ์ํ ํํ์ ๋งคํฌ๋ก ๋ค.
- ๊ฐ๋
: ํ
ํ๋ฆฟ์ ํ๋์ ํด๋์ค๋ฅผ ์๋ก ๋ค๋ฅธ ์ฌ๋ฌ ํ์
์ ์ฌ์ฌ์ฉํ ์ ์๋๋ก ํ๋ ๋ฐฉ๋ฒ
/** MyClass.h **/
template<class T> class MyClass {
public:
static int val;
MyClass(int v) { val = v; }
};
/** MyClass.cpp **/
template<typename T>
int MyClass<T>::bar;
template class MyClass<Foo>;
template class MyClass<Bar>;
/** main.cpp **/
MyClass<Foo> * foo1 = new MyClass<Foo>(10);
MyClass<Foo> * foo2 = new MyClass<Foo>(15);
MyClass<Bar> * bar1 = new MyClass<Bar>(20);
MyClass<Bar> * bar2 = new MyClass<Bar>(35);
int f1 = foo1->val; // 15
int f2 = foo2->val; // 15
int b1 = bar1->val; // 35
int b2 = bar2->val; // 35
- java์ ์ ๋ค๋ฆญ๊ณผ c++์ ํ
ํ๋ฆฟ์ ์ฐจ์ด
- List์ฒ๋ผ ์ฝ๋๋ฅผ ์์ฑํ ์ ์๋ค๋ ์ด์ ์์ ๋๋ฑํ ๊ฐ๋ ์ผ๋ก ์ฐฉ๊ฐํ๊ธฐ ์ฝ์ง๋ง ๋ ์ธ์ด๊ฐ ์ด๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ์์ฃผ ๋ง์ด ๋ค๋ฅด๋ค.
- c++์ Template์๋ int์ ๊ฐ์ ๊ธฐ๋ณธ ํ์ ์ ์ธ์๋ก ๋๊ธธ ์ ์์ง๋ง, java์ Generic์์๋ Integer์ ๋์ ์ฌ์ฉํด์ผ ํ๋ค.
- c++์ Template์ ์ธ์๋ก ์ฃผ์ด์ง ํ์ ์ผ๋ก๋ถํฐ ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด ๋ผ ์ ์์ง๋ง, java์์๋ ๋ถ๊ฐ๋ฅํ๋ค.
- java์์ MyClass๋ก ๋ง๋ ๋ชจ๋ ๊ฐ์ฒด๋ Generic ํ์
์ธ์๊ฐ ๋ฌด์์ด๋์ ๊ด๊ณ์์ด ์ ๋ถ ๋๋ฑํ ํ์
์ด๋ค.(์คํ ์๊ฐ์ ํ์
์ธ์ ์ ๋ณด๋ ์ญ์ ๋๋ค.)
- c++์์๋ ๋ค๋ฅธ Template ํ์ ์ธ์๋ฅผ ์ฌ์ฉํด ๋ง๋ ๊ฐ์ฒด๋ ์๋ก ๋ค๋ฅธ ํ์ ์ ๊ฐ์ฒด์ด๋ค.
- java์ ๊ฒฝ์ฐ Generic ํ์
์ธ์๋ฅผ ํน์ ํ ํ์
์ด ๋๋๋ก ์ ํํ ์ ์๋ค.
- ์๋ฅผ ๋ค์ด CardDeck์ Generic ํด๋์ค๋ก ์ ์ํ ๋ CardGame์ ํ์ ํด๋์ค๋ง ์ฌ์ฉ๋๋๋ก ์ ํํ ์ ์๋ค.
- java์์ Generic ํ์
์ ์ธ์๋ ์ ์ ๋ฉ์๋๋ ๋ณ์๋ฅผ ์ ์ธํ๋ ๋ฐ ์ฌ์ฉ๋ ์ ์๋ค.
- ์๋ํ๋ฉด MyClass๋ MyClass๊ฐ ์ด ๋ฉ์๋์ ๋ณ์๋ฅผ ๊ณต์ ํ๊ธฐ ๋๋ฌธ์ด๋ค.
- c++ Template์ ์ด ๋ ํด๋์ค๋ฅผ ๋ค๋ฅธ ํด๋์ค๋ก ์ฒ๋ฆฌํ๋ฏ๋ก Template ํ์ ์ธ์๋ฅผ ์ ์ ๋ฉ์๋๋ ๋ณ์๋ฅผ ์ ์ธํ๋ ๋ฐ ์ฌ์ฉํ ์ ์๋ค.
-
java์ ๊ฐ๋น์ง ์ปฌ๋ ์ (Garbage Collection) ์ฒ๋ฆฌ ๋ฐฉ๋ฒ
- GC ์์
์ ์ํํ๋ ๊ฐ๋น์ง ์ฝ๋ ํฐ๊ฐ ํ๋ ์ผ
- ๋ฉ๋ชจ๋ฆฌ ํ ๋น
- ์ฌ์ฉ ์ค์ธ ๋ฉ๋ชจ๋ฆฌ ์ธ์
- ๋ฏธ์ฌ์ฉ ๋ฉ๋ชจ๋ฆฌ ์ธ์
- Stop the World
- ์๋ฐ ์ ํ๋ฆฌ์ผ์ด์ ์ GC ์คํ ์ GC ์คํ ์ค๋ ๋๋ฅผ ์ ์ธํ ๋ชจ๋ ์ค๋ ๋๋ฅผ ๋ฉ์ถ๊ณ , GC ์๋ฃ ํ ๋ค์ ์ค๋ ๋๋ค์ ์คํ ์ํ๋ก ๋ณ๊ฒฝ
- Stop the World๋ ๋ชจ๋ ์ ํ๋ฆฌ์ผ์ด์ ์ค๋ ๋์ ์์ ์ด ๋ฉ์ถ๋ ์ํ
- ์ด๋ค GC ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋๋ผ๋, Stop the World๋ ๋ถ๊ฐํผํ๋ฉฐ ์ต์ํํ๊ธฐ ์ํด GC ํ๋์ ์งํ
- ๊ฐ๋น์ง ์ฝ๋ ํฐ๊ฐ ๋ค๋ฅด๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์ Young ์์ญ์ ํฌํจ๋๋ Eden, Survivor1, Survivor2์ Old ์์ญ (Permanent ์์ญ์ Java 1.8 ๋ถํฐ ์ ๊ฑฐ)
- Young ์์ญ์ ์๋ ๊ฐ์ฒด๋ ๊ฐ ํ์ ์์ญ์ด ๊ฐ๋ ์ฐจ๋ฉด Miner GC๊ฐ ๋์ํ์ฌ ๋์ด์ ์ฐธ์กฐ๋์ง ์๋ ๊ฐ์ฒด ์ ๊ฑฐ
- Old ์์ญ์ ์๋ ๊ฐ์ฒด๋ ์์ญ์ด ๊ฐ๋ ์ฐจ๋ฉด Major GC(Full GC)๊ฐ ๋์ํ์ฌ ๋์ด์ ์ฐธ์กฐ๋์ง ์๋ ๊ฐ์ฒด ์ ๊ฑฐ
- ๋์ ๊ณผ์
- ๊ฐ์ฒด๋ฅผ ์ต์ด ์์ฑํ๋ฉด Young ์์ญ ์ค Eden ์์ญ์ ์์น
- Eden ์์ญ์์ Miner GC ๋ฐ์ ์, ์ฐธ์กฐ ์ค์ธ ๊ฐ์ฒด๋ผ๋ฉด Survivor1๋ก ์ด๋
- Survivor1์์ Miner GC ๋ฐ์ ์, ์ฐธ์กฐ ์ค์ธ ๊ฐ์ฒด๋ผ๋ฉด Survivor2๋ก ์ด๋
- Survivor2์์ Miner GC ๋ฐ์ ์, ์ฐธ์กฐ ์ค์ธ ๊ฐ์ฒด๋ผ๋ฉด ๋ค์ Survivor1 ์์ญ์ผ๋ก ์ด๋ (Survivor1 <--> 2 ๋ฐ๋ณต)
- Survivor ์์ญ์ด ๊ฐ๋ ์ฐจ๊ฑฐ๋ Young ์์ญ์์ ์ค๋ ์ด์๋จ์ ๊ฐ์ฒด๋ Old ์์ญ์ผ๋ก ์ด๋
- '์ค๋'์ ๊ธฐ์ค์ ๊ฐ์ฒด๋ง๋ค age bit๋ผ๋ ๊ฒ์ ๊ฐ์ง๊ณ ์๋๋ฐ ์ด๋ Miner GC์์ ์ด์๋จ์ ํ์๋ฅผ ๊ธฐ๋กํ๋ ๊ฐ
- Old ์์ญ์ ์๋ ๊ฐ์ฒด๋ Major GC๊ฐ ๋ฐ์ํ์ ๋ ์ฐธ์กฐ ์ฌ๋ถ์ ๋ฐ๋ผ ๊ณต๊ฐ์ด ์ ์ง๋๊ฑฐ๋ ์ ๊ฑฐ
- GC ์์
์ ์ํํ๋ ๊ฐ๋น์ง ์ฝ๋ ํฐ๊ฐ ํ๋ ์ผ
- Garbage First Garbage Collector
- Java 9, 10์ default GC
- Java 7, 8์ default GC๋ ParallelGC
- ํ์ฑํ ์ต์
-XX:+UseG1GC
- ํ์ฑํ ์ต์
- ํฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ์ง ๋ฉํฐ ํ๋ก์ธ์ค ์์คํ ์์ ์ฌ์ฉํ๊ธฐ ์ํด ๊ฐ๋ฐ๋ GC
- Stop the World ์ต์ํ ๋ชฉ์ (์ค์๊ฐ GC๋ ๋ถ๊ฐ๋ฅ)
- ํต๊ณ๋ฅผ ๊ณ์ฐํ๋ฉด์ GC ์์ ๋ ์กฐ์
- G1์ ์ฌ์ฉํ๋ฉด ์ข์ ๊ฒฝ์ฐ
- Java heap์ 50% ์ด์์ด ๋ผ์ด๋ธ ๋ฐ์ดํฐ์ผ ๋
- GC๊ฐ ๋๋ฌด ์ค๋ ๊ฑธ๋ฆด ๋(0.5์ด ~ 1์ด)
- ๋ค๋ฅธ GC์ ๋ค๋ฅด๊ฒ ์ ์ฒด ํ ๊ณต๊ฐ์ ์ฒด์คํ์ฒ๋ผ ์ฌ๋ฌ ์์ญ์ผ๋ก ๋๋์ด ๊ด๋ฆฌ
- GC ๋ฐ์ ์, ์ ์ฒด ํ์ด ์๋ ์ผ๋ถ ์์ญ์์๋ง GC ์ํ
- ๋ฐ๋ผ์ ํฐ ํ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง ๊ฒฝ์ฐ ์ ๋ฆฌ
- ์์ญ์ ์ฐธ์กฐ๋ฅผ ๊ด๋ฆฌํ ๋ชฉ์ ์ผ๋ก remember set์ ๋ง๋ค์ด ์ฌ์ฉ(set์ ์ ์ฒด ํ์ 5% ๋ฏธ๋ง ํฌ๊ธฐ)
- ํ์ : ๋น ์์ญ / ๋นจ๊ฐ์ : Eden ์์ญ / ๋นจ๊ฐ์ S : Survivor ์์ญ / ํ๋์ : Old ์์ญ(ํ๋์ H๋ ํฌ๊ธฐ๊ฐ ์ปค์ ์ฌ๋ฌ ์์ญ ์ฐจ์งํ๋ ๊ฐ์ฒด)
- Young๊ณผ Old ์์ญ์ ๊ตฌ๋ถ ์์ด ์ฌ์ฉ
- ๋น์ด์๋ ์์ญ์ ์๋ก ํ ๋นํ ๊ฐ์ฒด ์์น
- STW ์๊ฐ ์ต์ํ๋ฅผ ์ํด ๋ณ๋ ฌ GC ์์ ์ฒ๋ฆฌ(๊ฐ ์ค๋ ๋๊ฐ ์์ ๋ง์ ์์ญ์ ์ก๊ณ ์์ )
- Young ์์ญ(Eden, Survivor)์์๋ Young GC๊ฐ ์ํ๋๋ฉฐ Eden, Survivor ์์ญ ์ด๋
- ์ฎ๊ธฐ๋ฉด์ ๋น์์ง ์์ญ์ ์ฌ์ฉ ๊ฐ๋ฅํ ๋น ์์ญ์ผ๋ก ๋๋๋ฆผ
- Full GC ์ํ ๋จ๊ณ
- Initial Mark -> Root Region Scan -> Concurrent Mark -> Remark -> Cleanup -> Copy
- Initial Mark
- Old ์ง์ญ์ ์กด์ฌํ๋ ๊ฐ์ฒด๊ฐ ์ฐธ์กฐํ๋ Survivor ์์ญ ํ์
- STW ๋ฐ์
- Root Region Scan
- ์ด์ ๋จ๊ณ์์ ์ฐพ์ ์์ญ์ ๋ํ GC ๋์ ๊ฐ์ฒด ์ค์บ
- Concurrent Mark
- ์ ์ฒด ํ ์์ญ ์ค์บ
- GC ๋์ ๊ฐ์ฒด๊ฐ ์๋ ์์ญ์ ์ดํ ๋จ๊ณ์์ ์ ์ธ
- Remark
- STW๊ฐ ๋ฐ์ํ๋ฉฐ ์ต์ข ์ผ๋ก GC ๋์์์ ์ ์ธํ ๊ฐ์ฒด ์๋ณ
- Cleanup
- STW๊ฐ ๋ฐ์ํ๋ฉฐ ์ ๊ฑฐํ ๊ฐ์ฒด๊ฐ ๊ฐ์ฅ ๋ง์ ์ง์ญ์์ GC ์ํ
- ์๋ฃ ํ, ์์ ํ ๋น์์ง ์์ญ์ ์ฌ์ฌ์ฉํ๊ธฐ ์ํด Freelist์ ์ถ๊ฐ
- Copy
- GC ๋์์ด์์ง๋ง Cleanup ๋จ๊ณ์์ ์์ ํ ๋น์์ง์ง ์์ ์ง์ญ์ ๋จ์ ๊ฐ์ฒด๋ฅผ ์๋ก์ด ์์ญ์ ๋ณต์ฌํ์ฌ ์กฐ๊ฐ ๋ชจ์(Compaction) ์์ ์ํ
- ParallelGC๋ Old Generation ์์ญ์์๋ง Full GC(๊ณต๊ฐ ์ฌํ๋ณด ๋ฐ ์กฐ๊ฐ ๋ชจ์) ์ํ
- G1์ ๋ ์งง์ ์ฃผ๊ธฐ์ Full GC ์์ ์ ์ํํ์ฌ ์ ์ฒด์ ์ธ ์ฒ๋ฆฌ๋์ด ์ค์ด๋๋ ๋์ ์ผ์ ์ ์ง ์๊ฐ์ ํฌ๊ฒ ๋จ์ถ
- CMS๋ Old Generation์ ์กฐ๊ฐ ๋ชจ์(Compaction)์ ํ์ง ์์ผ๋ฏ๋ก Full GC ์๊ฐ์ด ๊ธธ์ด์ง๋ ๋ฌธ์ ๋ฐ์
- CMS๋ Old ์์ญ ์ฌ์ฉ๋์ด ํน์ ๊ธฐ์ค์น ๊ฐ ๋์ด๊ฐ๋ฉด ์ํ
- G1GC๋ Old ์์ญ์์ GC ๋ฐ์ ์, ํ ์ฌ์ฉ๋์ด ํน์ ๊ธฐ์ค์น ๊ฐ์ ๋์ด๊ฐ๋ฉด ์คํ
- ์๋ฐ ์ง๋ ฌํ(Serialization)๋
- ์๋ฐ ์์คํ ๋ด๋ถ์์ ์ฌ์ฉ๋๋ ๊ฐ์ฒด ๋๋ ๋ฐ์ดํฐ๋ฅผ ์ธ๋ถ์ ์๋ฐ ์์คํ ์์๋ ์ฌ์ฉํ ์ ์๋๋ก ๋ฐ์ดํธ(byte) ํํ๋ก ๋ฐ์ดํฐ ๋ณํํ๋ ๊ธฐ์
- ์์คํ ์ ์ผ๋ก ์ด์ผ๊ธฐํ์๋ฉด JVM(Java Virtual Machine ์ดํ JVM)์ ๋ฉ๋ชจ๋ฆฌ์ ์์ฃผ(ํ ๋๋ ์คํ)๋์ด ์๋ ๊ฐ์ฒด ๋ฐ์ดํฐ๋ฅผ ๋ฐ์ดํธ ํํ๋ก ๋ณํํ๋ ๊ธฐ์
- ์๋ฐ ์ง๋ ฌํ ์กฐ๊ฑด
- ์๋ฐ ๊ธฐ๋ณธ(primitive) ํ์
java.io.Serializable
์ธํฐํ์ด์ค๋ฅผ ์์๋ฐ์ ๊ฐ์ฒด
- ์ง๋ ฌํ ๋ฐฉ๋ฒ
java.io.ObjectOutputStream
๊ฐ์ฒด๋ฅผ ์ด์ฉ
- ์๋ฐ ์ญ์ง๋ ฌํ(Deserialization)๋
- ๋ฐ์ดํธ๋ก ๋ณํ๋ ๋ฐ์ดํฐ๋ฅผ ๋ค์ ๊ฐ์ฒด๋ก ๋ณํํ๋ ๊ธฐ์
- ์ง๋ ฌํ๋ ๋ฐ์ดํธ ํํ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฒด๋ก ๋ณํํด์ JVM์ผ๋ก ์์ฃผ์ํค๋ ํํ์ ๊ธฐ์
- ์๋ฐ ์ญ์ง๋ ฌํ ์กฐ๊ฑด
- ์ง๋ ฌํ ๋์์ด ๋ ๊ฐ์ฒด์ ํด๋์ค๊ฐ ํด๋์ค ํจ์ค์ ์กด์ฌํด์ผ ํ๋ฉฐ import ๋์ด ์์ด์ผ ํ๋ค.
- ์ค์ํ ์ ์ ์ง๋ ฌํ์ ์ญ์ง๋ ฌํ๋ฅผ ์งํํ๋ ์์คํ ์ด ์๋ก ๋ค๋ฅผ ์ ์๋ค๋ ๊ฒ์ ๋ฐ๋์ ๊ณ ๋ คํด์ผ ํ๋ค. (๊ฐ์ ์์คํ ๋ด๋ถ์ด๋ผ๋ ์์ค ๋ฒ์ ์ด ๋ค๋ฅผ ์ ์๋ค.)
- ์๋ฐ ์ง๋ ฌํ ๋์ ๊ฐ์ฒด๋ ๋์ผํ serialVersionUID ๋ฅผ ๊ฐ์ง๊ณ ์์ด์ผ ํ๋ค.
private static final long serialVersionUID = 1L;
- ์ง๋ ฌํ ๋์์ด ๋ ๊ฐ์ฒด์ ํด๋์ค๊ฐ ํด๋์ค ํจ์ค์ ์กด์ฌํด์ผ ํ๋ฉฐ import ๋์ด ์์ด์ผ ํ๋ค.
- ์ญ์ง๋ ฌํ ๋ฐฉ๋ฒ
java.io.ObjectInputStream
๊ฐ์ฒด๋ฅผ ์ด์ฉ
- ํด๋์ค(Class)
- ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด ๋ด๊ธฐ ์ํ ์ค๊ณ๋ ํน์ ํ
- ์ฐ๊ด๋์ด ์๋ ๋ณ์์ ๋ฉ์๋์ ์งํฉ
- ๊ฐ์ฒด(Object)
- ์ํํธ์จ์ด ์ธ๊ณ์ ๊ตฌํํ ๋์
- ํด๋์ค์ ์ ์ธ๋ ๋ชจ์ ๊ทธ๋๋ก ์์ฑ๋ ์ค์ฒด
- 'ํด๋์ค์ ์ธ์คํด์ค(instance)' ๋ผ๊ณ ๋ ๋ถ๋ฅธ๋ค.
- ๊ฐ์ฒด๋ ๋ชจ๋ ์ธ์คํด์ค๋ฅผ ๋ํํ๋ ํฌ๊ด์ ์ธ ์๋ฏธ๋ฅผ ๊ฐ๋๋ค.
- oop์ ๊ด์ ์์ ํด๋์ค์ ํ์ ์ผ๋ก ์ ์ธ๋์์ ๋ '๊ฐ์ฒด'๋ผ๊ณ ๋ถ๋ฅธ๋ค.
- ์ธ์คํด์ค(Instance)
- ์ค๊ณ๋๋ฅผ ๋ฐํ์ผ๋ก ์ํํธ์จ์ด ์ธ๊ณ์ ๊ตฌํ๋ ๊ตฌ์ฒด์ ์ธ ์ค์ฒด
- ์ฆ, ๊ฐ์ฒด๋ฅผ ์ํํธ์จ์ด์ ์ค์ฒดํ ํ๋ฉด ๊ทธ๊ฒ์ '์ธ์คํด์ค'๋ผ๊ณ ๋ถ๋ฅธ๋ค.
- ์ค์ฒดํ๋ ์ธ์คํด์ค๋ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋๋ค.
- ์ธ์คํด์ค๋ ๊ฐ์ฒด์ ํฌํจ๋๋ค๊ณ ๋ณผ ์ ์๋ค.
- oop์ ๊ด์ ์์ ๊ฐ์ฒด๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋์ด ์ค์ ์ฌ์ฉ๋ ๋ '์ธ์คํด์ค'๋ผ๊ณ ๋ถ๋ฅธ๋ค.
- ์ถ์์ ์ธ ๊ฐ๋
(๋๋ ๋ช
์ธ)๊ณผ ๊ตฌ์ฒด์ ์ธ ๊ฐ์ฒด ์ฌ์ด์ ๊ด๊ณ ์ ์ด์ ์ ๋ง์ถ ๊ฒฝ์ฐ์ ์ฌ์ฉํ๋ค.
- '~์ ์ธ์คํด์ค' ์ ํํ๋ก ์ฌ์ฉ๋๋ค.
- ๊ฐ์ฒด๋ ํด๋์ค์ ์ธ์คํด์ค๋ค.
- ๊ฐ์ฒด ๊ฐ์ ๋งํฌ๋ ํด๋์ค ๊ฐ์ ์ฐ๊ด ๊ด๊ณ์ ์ธ์คํด์ค๋ค.
- ์คํ ํ๋ก์ธ์ค๋ ํ๋ก๊ทธ๋จ์ ์ธ์คํด์ค๋ค.
- ์ฆ, ์ธ์คํด์ค๋ผ๋ ์ฉ์ด๋ ๋ฐ๋์ ํด๋์ค์ ๊ฐ์ฒด ์ฌ์ด์ ๊ด๊ณ๋ก ํ์ ์ง์ด์ ์ฌ์ฉํ ํ์๋ ์๋ค.
- ์ธ์คํด์ค๋ ์ด๋ค ์๋ณธ(์ถ์์ ์ธ ๊ฐ๋ )์ผ๋ก๋ถํฐ '์์ฑ๋ ๋ณต์ ๋ณธ'์ ์๋ฏธํ๋ค.
- ์ค๊ณ๋๋ฅผ ๋ฐํ์ผ๋ก ์ํํธ์จ์ด ์ธ๊ณ์ ๊ตฌํ๋ ๊ตฌ์ฒด์ ์ธ ์ค์ฒด
/* ํด๋์ค */
public class Animal {
...
}
/* ๊ฐ์ฒด์ ์ธ์คํด์ค */
public class Main {
public static void main(String[] args) {
Animal cat, dog; // '๊ฐ์ฒด'
// ์ธ์คํด์คํ
cat = new Animal(); // cat์ Animal ํด๋์ค์ '์ธ์คํด์ค'(๊ฐ์ฒด๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น)
dog = new Animal(); // dog์ Animal ํด๋์ค์ '์ธ์คํด์ค'(๊ฐ์ฒด๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น)
}
}
- Q. ํด๋์ค VS ๊ฐ์ฒด
- ํด๋์ค๋ '์ค๊ณ๋', ๊ฐ์ฒด๋ '์ค๊ณ๋๋ก ๊ตฌํํ ๋ชจ๋ ๋์'์ ์๋ฏธํ๋ค.
- Q. ๊ฐ์ฒด VS ์ธ์คํด์ค
- ํด๋์ค์ ํ์ ์ผ๋ก ์ ์ธ๋์์ ๋ ๊ฐ์ฒด๋ผ๊ณ ๋ถ๋ฅด๊ณ , ๊ทธ ๊ฐ์ฒด๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋์ด ์ค์ ์ฌ์ฉ๋ ๋ ์ธ์คํด์ค๋ผ๊ณ ๋ถ๋ฅธ๋ค.
- ๊ฐ์ฒด๋ ํ์ค ์ธ๊ณ์ ๊ฐ๊น๊ณ , ์ธ์คํด์ค๋ ์ํํธ์จ์ด ์ธ๊ณ์ ๊ฐ๊น๋ค.
- ๊ฐ์ฒด๋ '์ค์ฒด', ์ธ์คํด์ค๋ '๊ด๊ณ'์ ์ด์ ์ ๋ง์ถ๋ค.
- ๊ฐ์ฒด๋ฅผ 'ํด๋์ค์ ์ธ์คํด์ค'๋ผ๊ณ ๋ ๋ถ๋ฅธ๋ค.
- '๋ฐฉ๊ธ ์ธ์คํด์คํํ์ฌ ๋ ํผ๋ฐ์ค๋ฅผ ํ ๋นํ' ๊ฐ์ฒด๋ฅผ ์ธ์คํด์ค๋ผ๊ณ ๋งํ์ง๋ง, ์ด๋ ์๋ณธ(์ถ์์ ์ธ ๊ฐ๋ )์ผ๋ก๋ถํฐ ์์ฑ๋์๋ค๋ ๊ฒ์ ์๋ฏธ๋ฅผ ๋ถ์ฌํ๋ ๊ฒ์ผ ๋ฟ ์๊ฒฉํ๊ฒ ๊ฐ์ฒด์ ์ธ์คํด์ค๋ฅผ ๋๋๊ธด ์ด๋ ต๋ค.
- ์ถ์ํ ๊ธฐ๋ฒ
- ๋ถ๋ฅ(Classification)
- ๊ฐ์ฒด -> ํด๋์ค
- ์ค์ฌํ๋ ๊ฐ์ฒด๋ค์ ๊ณตํต์ ์ธ ์์ฑ์ ๊ณต์ ํ๋ ๋ฒ๋ถ ๋๋ ์ถ์์ ์ธ ๊ฐ๋ ์ผ๋ก ๋ฌถ๋ ๊ฒ
- ์ธ์คํด์คํ(Instantiation)
- ํด๋์ค -> ์ธ์คํด์ค
- ๋ถ๋ฅ์ ๋ฐ๋ ๊ฐ๋ . ๋ฒ์ฃผ๋ ๊ฐ๋ ์ผ๋ก๋ถํฐ ์ค์ฌํ๋ ๊ฐ์ฒด๋ฅผ ๋ง๋๋ ๊ณผ์
- ๊ตฌ์ฒด์ ์ผ๋ก ํด๋์ค ๋ด์ ๊ฐ์ฒด์ ๋ํด ํน์ ํ ๋ณํ์ ์ ์ํ๊ณ , ์ด๋ฆ์ ๋ถ์ธ ๋ค์, ๊ทธ๊ฒ์ ๋ฌผ๋ฆฌ์ ์ธ ์ด๋ค ์ฅ์์ ์์น์ํค๋ ๋ฑ์ ์์ ์ ํตํด ์ธ์คํด์ค๋ฅผ ๋ง๋๋ ๊ฒ์ ๋งํ๋ค.
- '์์(Exemplification)'๋ผ๊ณ ๋ ๋ถ๋ฅธ๋ค.
- ๋ถ๋ฅ(Classification)
- ๊ฐ์ฒด(Object)๋
- ์ค๋ฒ๋ก๋ฉ(Overloading)
- ๋ ๋ฉ์๋๊ฐ ๊ฐ์ ์ด๋ฆ์ ๊ฐ๊ณ ์์ผ๋ ์ธ์์ ์๋ ์๋ฃํ์ด ๋ค๋ฅธ ๊ฒฝ์ฐ
- Ex)
public double computeArea(Circle c) { ... }
public double computeArea(Circle c1, Circle c2) { ... }
public double computeArea(Square c) { ... }
- ์ค๋ฒ๋ผ์ด๋ฉ(Overriding)
- ์์ ํด๋์ค์ ๋ฉ์๋์ ์ด๋ฆ๊ณผ ์ฉ๋ก(signature)๊ฐ ๊ฐ์ ํจ์๋ฅผ ํ์ ํด๋์ค์ ์ฌ์ ์ํ๋ ๊ฒ
- ์์ ๊ด๊ณ์ ์๋ ํด๋์ค ๊ฐ์ ๊ฐ์ ์ด๋ฆ์ ๋ฉ์๋๋ฅผ ์ ์
- Ex) Circle์์ printMe() ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ๋ค.
public abstract class Shape {
public void printMe() { System.out.println("Shape"); }
public abstract double computeArea();
}
public class Circle extends Shape {
private double rad = 5;
@Override // ๊ฐ๋ฐ์์ ์ค์๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํด @Override(annotation) ์ฐ๋ ๊ฒ์ ๊ถ์ฅ
public void printMe() { System.out.println("Circle"); }
public double computeArea() { return rad * rad * 3.15; }
}
public class Ambiguous extends Shape {
private double area = 10;
public double computeArea() { return area; }
}
- Call by Value (๊ฐ์ ์ํ ํธ์ถ)
- ํจ์๊ฐ ํธ์ถ๋ ๋, ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ ์์์๋ ํจ์๋ฅผ ์ํ ๋ณ๋์ ์์ ๊ณต๊ฐ์ด ์์ฑ๋๋ค.
- ํจ์ ํธ์ถ์ ์ธ์๋ก ์ ๋ฌ๋๋ ๋ณ์์ ๊ฐ์ ๋ณต์ฌํ์ฌ ํจ์์ ์ธ์๋ก ์ ๋ฌํ๋ค.
- ๋ณต์ฌ๋ ์ธ์๋ ํจ์ ์์์ ์ง์ญ์ ์ผ๋ก ์ฌ์ฉ๋๋ local value์ ํน์ฑ์ ๊ฐ์ง๋ค.
- ๋ฐ๋ผ์ ํจ์ ์์์ ์ธ์์ ๊ฐ์ด ๋ณ๊ฒฝ๋์ด๋, ์ธ๋ถ์ ๋ณ์์ ๊ฐ์ ๋ณ๊ฒฝ๋์ง ์๋๋ค.
- Call by Reference (์ฐธ์กฐ์ ์ํ ํธ์ถ)
- ํจ์๊ฐ ํธ์ถ๋ ๋, ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ ์์์๋ ํจ์๋ฅผ ์ํ ๋ณ๋์ ์์ ๊ณต๊ฐ์ด ์์ฑ๋๋ค.
- ํจ์ ํธ์ถ์ ์ธ์๋ก ์ ๋ฌ๋๋ ๋ณ์์ ๋ ํผ๋ฐ์ค๋ฅผ ์ ๋ฌํ๋ค. (ํด๋น ๋ณ์๋ฅผ ๊ฐ๋ฆฌํจ๋ค.)
- ๋ฐ๋ผ์ ํจ์ ์์์ ์ธ์์ ๊ฐ์ด ๋ณ๊ฒฝ๋๋ฉด, ์ธ์๋ก ์ ๋ฌ๋ ๋ณ์์ ๊ฐ๋ ํจ๊ป ๋ณ๊ฒฝ๋๋ค.
- Java๋ Call by Value ์ผ๊น? Call by Reference ์ผ๊น?
class Person {
private String name;
public Person(String name) {
this.name = name;
}
public setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "name is " + this.name;
}
}
public class FunctionCallTest {
public static void assignNewPerson(Person p) {
p = new Person("hee");
}
public static void changeName(Person p) {
p.setName("hee");
}
public static void main(String[] args) {
Person p = new Person("doy");
assignNewPerson(p);
System.out.println(p); // name is doy
changeName(p);
System.out.println(p); // name is hee
}
}
public class FunctionCallTest2 {
/* parameter๋ ์ฐธ์กฐ๋ณ์ array ์์ฒด์ Reference๊ฐ ์๋ array๊ฐ "์ ์ฅํ๊ณ ์๋ ์ฃผ์๊ฐ(Value)" */
public static void changeContent(int[] array) {
// If we change the content of arr,
array[0] = 10; // Will change the content of array in main()
array[1] = 11;
}
public static void changeRef(int[] array) {
// If we change the reference,
array = new int[2]; // Will not change the array in main()
array[0] = 20;
array[1] = 21;
}
public static void main(String[] args) {
int[] array = new int[2];
array[0] = 0;
array[1] = 1;
changeContent(array);
for (int i = 0; i < array.length; i++) {
// Will print 10 11
System.out.print(array[i] + " "); // 10 11
}
changeRef(array);
for (int i = 0; i < array.length; i++) {
// Will still print 10 11
// (Change the reference doesn't reflect change here)
System.out.print(array[i] + " "); // 10 11
}
}
}
- ๊ธฐ๋ณธ์๋ฃํ์ Call By Value์ด๊ณ , ์ฐธ์กฐ์๋ฃํ์ Call By Reference์ด๋ค??
- ์คํด 1. ํน์ ๋ฉ์๋ ๋ด์์ ์ ๋ฌ ๋ฐ์ ๊ฐ์ฒด์ ์ํ๋ฅผ ๋ณ๊ฒฝ ํ ์ ์๋ค.
changeName
๋ฉ์๋๋ ์ฐธ์กฐ๋ณ์ p๊ฐ ๊ฐ๋ฆฌํค๋ [์ด๋ฆ ์์ฑ์ด "doy"์ธ Person ๊ฐ์ฒด]๋ฅผ [์ด๋ฆ ์์ฑ์ด "hee"์ธ ์๋ก์ด Person ๊ฐ์ฒด]๋ก ๋ณ๊ฒฝํ ๊ฒ์ด ์๋๋ผ, ๋จ์ง ์ด๋ฆ ์์ฑ๋ง ๋ณ๊ฒฝํ์ ๋ฟ์ด๋ค.
- ์คํด 2. ์ฐธ์กฐ๋ณ์๋ ์์์ ๊ฐ์ฒด์ ๋ํ ๋ ํผ๋ฐ์ค๋ฅผ ์ ์ฅํ๋ฏ๋ก ๋ฉ์๋๋ก ์ ๋ฌํ ๊ฐ์ด ๋ ํผ๋ฐ์ค(Call by Reference)์ด๋ค.
- ์ ๋ฌ๋ ๋ ํผ๋ฐ์ค๋ ์ฐธ์กฐ๋ณ์ p ์์ฒด์ ๋ ํผ๋ฐ์ค๊ฐ ์๋ p๊ฐ ์ ์ฅํ๊ณ ์๋ ๊ฐ(์ด๊ฒ๋ ๋ ํผ๋ฐ์ค)์ด๋ค.
- ๋ง์ฝ Java๊ฐ Call by Reference๋ฅผ ์ง์ํ๋ค๋ฉด
assignNewPerson
๋ฉ์๋ ์คํ ํ์ p ์ฐธ์กฐ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ฒด๊ฐ [์ด๋ฆ ์์ฑ์ด "hee"์ธ ์๋ก์ด Person ๊ฐ์ฒด]๋ก ๋ณ๊ฒฝ๋์ด์ผ ํ๋ค. - ๋ํ ์ฐธ์กฐ๋ณ์ p ์์ฒด์ ๋ ํผ๋ฐ์ค๋ฅผ ์ป์ ์ ์๋ ๋ฐฉ๋ฒ์ด ์์ด์ผ ํ๋ค. ๊ทธ๋ฌ๋ Java๋ ์ด ๋ฐฉ๋ฒ์ ์ง์ํ์ง ์๋๋ค.
- ๋ฐ๋ผ์ Java๋ ํญ์ Call by Value ์ด๋ค.
- ์ฌ๊ธฐ์ value ๋?
- ๊ธฐ๋ณธ์๋ฃํ์ ๊ฐ ๋๋ ๊ฐ์ฒด์ ๋ํ ๋ ํผ๋ฐ์ค
- ๊ธฐ๋ณธ์๋ฃํ์ ๊ฒฝ์ฐ ํด๋นํ๋ ๋ณ์์ ๊ฐ์ ๋ณต์ฌํด์ ์ ๋ฌํ๋ค.
- ์ฐธ์กฐ์๋ฃํ์ ๊ฒฝ์ฐ ํด๋นํ๋ ๋ณ์๊ฐ ๊ฐ์ง๋ ๊ฐ์ด ๋ ํผ๋ฐ์ค์ด๋ฏ๋ก ์ธ์๋ก ๋๊ธธ ๋ Call by Value์ ์ํด ๋ณ์๊ฐ ๊ฐ์ง๊ณ ์๋ ๋ ํผ๋ฐ์ค๊ฐ ๋ณต์ฌ๋์ด ์ ๋ฌ๋๋ค.
- ์ฌ๊ธฐ์ value ๋?
- ์ถ์ ๋ฉ์๋(Abstract Method)
- abstract ํค์๋์ ํจ๊ป ์ํ๋ง ์ ์ธ๋๊ณ , ์ฝ๋๋ ์์ฑ๋์ง ์์ ๋ฉ์๋
public abstract String getName(); // ์ถ์ ๋ฉ์๋
public abstract String fail() { return "Fail"; } // ์ถ์ ๋ฉ์๋ ์๋. ์ปดํ์ผ ์ค๋ฅ ๋ฐ์
- ์ถ์ ํด๋์ค(Abstract Class)
- ๊ฐ๋
: abstract ํค์๋๋ก ์ ์ธ๋ ํด๋์ค
- ์ถ์ ๋ฉ์๋๋ฅผ ์ต์ ํ ๊ฐ ์ด์ ๊ฐ์ง๊ณ abstract๋ก ์ ์ธ๋ ํด๋์ค
- ์ต์ ํ ๊ฐ์ ์ถ์ ๋ฉ์๋๋ฅผ ํฌํจํ๋ ๊ฒฝ์ฐ ๋ฐ๋์ ์ถ์ ํด๋์ค๋ก ์ ์ธํ์ฌ์ผ ํ๋ค.
- ์ถ์ ๋ฉ์๋๊ฐ ์์ด๋ abstract๋ก ์ ์ธํ ํด๋์ค
- ๊ทธ๋ฌ๋ ์ถ์ ๋ฉ์๋๊ฐ ํ๋๋ ์๋ ๊ฒฝ์ฐ๋ผ๋ ์ถ์ ํด๋์ค๋ก ์ ์ธํ ์ ์๋ค.
- ์ถ์ ๋ฉ์๋๋ฅผ ์ต์ ํ ๊ฐ ์ด์ ๊ฐ์ง๊ณ abstract๋ก ์ ์ธ๋ ํด๋์ค
- ์ถ์ ํด๋์ค์ ๊ตฌํ
- ์๋ธ ํด๋์ค์์ ์ํผ ํด๋์ค์ ๋ชจ๋ ์ถ์ ๋ฉ์๋๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ์ฌ ์คํ๊ฐ๋ฅํ ์ฝ๋๋ก ๊ตฌํํ๋ค.
- ์ถ์ ํด๋์ค์ ๋ชฉ์
- ๊ฐ์ฒด(์ธ์คํด์ค)๋ฅผ ์์ฑํ๊ธฐ ์ํจ์ด ์๋๋ฉฐ, ์์์ ์ํ ๋ถ๋ชจ ํด๋์ค๋ก ํ์ฉํ๊ธฐ ์ํ ๊ฒ์ด๋ค.
- ์ฌ๋ฌ ํด๋์ค๋ค์ ๊ณตํต๋ ๋ถ๋ถ์ ์ถ์ํ(์ถ์ ๋ฉ์๋) ํ์ฌ ์์๋ฐ๋ ํด๋์ค์๊ฒ ๊ตฌํ์ ๊ฐ์ ํํ๊ธฐ ์ํ ๊ฒ์ด๋ค. (๋ฉ์๋์ ๋์์ ๊ตฌํํ๋ ์์ ํด๋์ค๋ก ์ฑ ์์ ์์)
- ์ฆ, ์ถ์ ํด๋์ค์ ์ถ์ ๋ฉ์๋๋ฅผ ์์ ํด๋์ค๊ฐ ๊ตฌ์ฒดํํ์ฌ ๊ทธ ๊ธฐ๋ฅ์ ํ์ฅํ๋ ๋ฐ ๋ชฉ์ ์ด ์๋ค.
- ๊ฐ๋
: abstract ํค์๋๋ก ์ ์ธ๋ ํด๋์ค
/* ๊ฐ๋
a์ ์์ */
abstract class Shape { // ์ถ์ ํด๋์ค
Shape() {...}
void edit() {...}
abstract public void draw(); // ์ถ์ ๋ฉ์๋
}
/* ๊ฐ๋
b์ ์์ */
abstract class Shape { // ์ถ์ ํด๋์ค
Shape() {...}
void edit() {...}
}
/* ์ถ์ ํด๋์ค์ ๊ตฌํ */
class Circle extends Shape {
public void draw() { System.out.println("Circle"); } // ์ถ์ ๋ฉ์๋ (์ค๋ฒ๋ผ์ด๋ฉ)
void show() { System.out.println("๋๊ทธ๋ผ๋ฏธ ๋ชจ์"); }
}
- ์ธํฐํ์ด์ค(Interface)
- ๊ฐ๋ : ์ถ์ ๋ฉ์๋์ ์์๋ง์ ํฌํจํ๋ฉฐ, interface ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ธํ๋ค.
- ์ธํฐํ์ด์ค์ ๊ตฌํ
- ์ธํฐํ์ด์ค๋ฅผ ์์๋ฐ๊ณ , ์ถ์ ๋ฉ์๋๋ฅผ ๋ชจ๋ ๊ตฌํํ ํด๋์ค๋ฅผ ์์ฑํ๋ค.
- implements ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ๊ตฌํํ๋ค.
- ์ธํฐํ์ด์ค์ ๋ชฉ์
- ์์๋ฐ์ ์๋ธ ํด๋์ค์๊ฒ ๊ตฌํํ ๋ฉ์๋๋ค์ ์ํ์ ๋ชจ๋ ์๋ ค์ฃผ์ด, ํด๋์ค๊ฐ ์์ ์ ๋ชฉ์ ์ ๋ง๊ฒ ๋ฉ์๋๋ฅผ ๊ตฌํํ๋๋ก ํ๋ ๊ฒ์ด๋ค.
- ๊ตฌํ ๊ฐ์ฒด์ ๊ฐ์ ๋์์ ๋ณด์ฅํ๊ธฐ ์ํ ๋ชฉ์ ์ด ์๋ค.
- ์ฆ, ์๋ก ๊ด๋ จ์ด ์๋ ํด๋์ค์์ ๊ณตํต์ ์ผ๋ก ์ฌ์ฉํ๋ ๋ฐฉ์์ด ํ์ํ์ง๋ง ๊ธฐ๋ฅ์ ๊ฐ๊ฐ ๊ตฌํํ ํ์๊ฐ ์๋ ๊ฒฝ์ฐ์ ์ฌ์ฉํ๋ค.
- ์ธํฐํ์ด์ค์ ํน์ง
- ์ธํฐํ์ด์ค๋ ์์ ํ๋์ ์ถ์ ๋ฉ์๋๋ง์ผ๋ก ๊ตฌ์ฑ๋๋ค.
- ๋ชจ๋ ๋ฉ์๋๋ ์ถ์ ๋ฉ์๋๋ก์, abstract public ์์ฑ์ด๋ฉฐ ์๋ต ๊ฐ๋ฅํ๋ค.
- ์์๋ public static final ์์ฑ์ด๋ฉฐ, ์๋ตํ์ฌ ์ ์ธํ ์ ์๋ค.
- ์ธํฐํ์ด์ค๋ฅผ ์์๋ฐ์ ์๋ก์ด ์ธํฐํ์ด์ค๋ฅผ ๋ง๋ค ์ ์๋ค.
interface MobilePhone extends Phone { }
/* ์ธํฐํ์ด์ค์ ๊ฐ๋
*/
interface Phone { // ์ธํฐํ์ด์ค
int BUTTONS = 20; // ์์ ํ๋ (public static final int BUTTONS = 20;๊ณผ ๋์ผ)
void sendCall(); // ์ถ์ ๋ฉ์๋ (abstract public void sendCall();๊ณผ ๋์ผ)
abstract public void receiveCall(); // ์ถ์ ๋ฉ์๋
}
/* ์ธํฐํ์ด์ค์ ๊ตฌํ */
class FeaturePhone implements Phone {
// Phone์ ๋ชจ๋ ์ถ์ ๋ฉ์๋๋ฅผ ๊ตฌํํ๋ค.
public void sendCall() {...}
public void receiveCall() {...}
// ์ถ๊ฐ์ ์ผ๋ก ๋ค๋ฅธ ๋ฉ์๋๋ฅผ ์์ฑํ ์ ์๋ค.
public int getButtons() {...}
}
- ์ถ์ ํด๋์ค์ ์ธํฐํ์ด์ค์ ๊ณตํต์
- ์ธ์คํด์ค(๊ฐ์ฒด)๋ ์์ฑํ ์ ์๋ค.
- ์ ์ธ๋ง ์๊ณ ๊ตฌํ ๋ด์ฉ์ด ์๋ค.
- ์์ ํด๋์ค๊ฐ ๋ฉ์๋์ ๊ตฌ์ฒด์ ์ธ ๋์์ ๊ตฌํํ๋๋ก ์ฑ ์์ ์์ํ๋ค.
- ์ถ์ ํด๋์ค์ ์ธํฐํ์ด์ค์ ์ฐจ์ด์
- ์๋ก ๋ค๋ฅธ ๋ชฉ์ ์ ๊ฐ์ง๊ณ ์๋ค.
- ์ถ์ ํด๋์ค๋ ์ถ์ ๋ฉ์๋๋ฅผ ์์ ํด๋์ค๊ฐ ๊ตฌ์ฒดํํ์ฌ ๊ทธ ๊ธฐ๋ฅ์ ํ์ฅํ๋ ๋ฐ ๋ชฉ์ ์ด ์๋ค. (์์์ ์ํ ๋ถ๋ชจ ํด๋์ค)
- ์ธํฐํ์ด์ค๋ ์๋ก ๊ด๋ จ์ด ์๋ ํด๋์ค์์ ๊ณตํต์ ์ผ๋ก ์ฌ์ฉํ๋ ๋ฐฉ์์ด ํ์ํ์ง๋ง ๊ธฐ๋ฅ์ ๊ฐ๊ฐ ๊ตฌํํ ํ์๊ฐ ์๋ ๊ฒฝ์ฐ์ ์ฌ์ฉํ๋ค. (๊ตฌํ ๊ฐ์ฒด์ ๊ฐ์ ๋์์ ๋ณด์ฅ)
- ์ถ์ ํด๋์ค๋ ํด๋์ค์ด์ง๋ง ์ธํฐํ์ด์ค๋ ํด๋์ค๊ฐ ์๋๋ค.
- ์ถ์ ํด๋์ค๋ ๋จ์ผ ์์์ด์ง๋ง ์ธํฐํ์ด์ค๋ ๋ค์ค ์์์ด ๊ฐ๋ฅํ๋ค.
- ์ถ์ ํด๋์ค๋ โis a kind ofโ ์ธํฐํ์ด์ค๋ โcan do thisโ
- Ex) ์ถ์ ํด๋์ค: Appliances(Abstract Class) - TV, Refrigerator
- Ex) ์ธํฐํ์ด์ค: Flyable(Interface) - Plane, Bird
- ์๋ก ๋ค๋ฅธ ๋ชฉ์ ์ ๊ฐ์ง๊ณ ์๋ค.
- Map
- ๊ฒ์ํ ์ ์๋ ์ธํฐํ์ด์ค
- ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ ๋ Key์ Value์ ํํ๋ก ์ฝ์ ๋๋ฉฐ, Key๋ฅผ ์ด์ฉํด์ Value๋ฅผ ์ป์ ์ ์๋ค.
- Collection
- List
- ์์๊ฐ ์๋ Collection
- ๋ฐ์ดํฐ๋ฅผ ์ค๋ณตํด์ ํฌํจํ ์ ์๋ค.
- Set
- ์งํฉ์ ์ธ ๊ฐ๋ ์ Collection
- ์์์ ์๋ฏธ๊ฐ ์๋ค.
- ๋ฐ์ดํฐ๋ฅผ ์ค๋ณตํด์ ํฌํจํ ์ ์๋ค.
- List
- Collections Framework ์ ํ ๊ณผ์
- Map๊ณผ Collection ์ธํฐํ์ด์ค ์ค ์ ํ 1-1. Collection ์ ํ ์ ์ฌ์ฉ ๋ชฉ์ ์ ๋ฐ๋ผ List์ Set์ค ์ ํ
- ์ฌ์ฉ ๋ชฉ์ ์ ๋ฐ๋ผ Map, List, Set ๊ฐ๊ฐ์ ํ์ ๊ตฌํ์ฒด๋ฅผ ์ ํ 2-1. Map: HashMap, LinkedHashMap, HashTable, TreeMap 2-2. List: LinkedList, ArrayList 2-3. Set: TreeSet, HashSet
- Collections Framework ๋๊ธฐํ
- HashMap
- Entry<K,V>์ ๋ฐฐ์ด๋ก ์ ์ฅ๋๋ฉฐ, ๋ฐฐ์ด์ index๋ ๋ด๋ถ ํด์ฌ ํจ์๋ฅผ ํตํด ๊ณ์ฐ๋๋ค.
- ๋ด๋ถ hash๊ฐ์ ๋ฐ๋ผ์ ํค์์๊ฐ ์ ํด์ง๋ฏ๋ก ํน์ ๊ท์น์์ด ์ถ๋ ฅ๋๋ค.
- key์ value์ null๊ฐ์ ํ์ฉํ๋ค.
- ๋น๋๊ธฐ ์ฒ๋ฆฌ
- ์๊ฐ๋ณต์ก๋: O(1)
- LinkedHashMap
- HaspMap์ ์์๋ฐ์ผ๋ฉฐ, Linked List๋ก ์ ์ฅ๋๋ค.
- ์ ๋ ฅ ์์๋๋ก ์ถ๋ ฅ๋๋ค.
- ๋น๋๊ธฐ ์ฒ๋ฆฌ
- ์๊ฐ๋ณต์ก๋: O(n)
- TreeMap
- ๋ด๋ถ์ ์ผ๋ก ๋ ๋-๋ธ๋ ํธ๋ฆฌ(Red-Black tree)๋ก ์ ์ฅ๋๋ค.
- ํค๊ฐ์ด ๊ธฐ๋ณธ์ ์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ๋์ด ์ถ๋ ฅ๋๋ค.
- ํค๊ฐ์ ๋ํ Compartor ๊ตฌํ์ผ๋ก ์ ๋ ฌ ๋ฐฉ๋ฒ์ ์ง์ ํ ์ ์๋ค.
- ์๊ฐ๋ณต์ก๋: O(logn)
- ConCurrentHashMap
- multiple lock
- updateํ ๋๋ง ๋๊ธฐ ์ฒ๋ฆฌ
- key์ value์ null๊ฐ์ ํ์ฉํ์ง ์๋๋ค.
- HashTable
- single lock
- ๋ชจ๋ ๋ฉ์๋์ ๋ํด ๋๊ธฐ ์ฒ๋ฆฌ
- key์ value์ null๊ฐ์ ํ์ฉํ์ง ์๋๋ค.
- HashSet
- ์ ์ฅ ์์๋ฅผ ์ ์งํ์ง ์๋ ๋ฐ์ดํฐ์ ์งํฉ์ด๋ค.
- ํด์ ์๊ณ ๋ฆฌ์ฆ(hash algorithm)์ ์ฌ์ฉํ์ฌ ๊ฒ์ ์๋๊ฐ ๋งค์ฐ ๋น ๋ฅด๋ค.
- ๋ด๋ถ์ ์ผ๋ก HashMap ์ธ์คํด์ค๋ฅผ ์ด์ฉํ์ฌ ์์๋ฅผ ์ ์ฅํ๋ค.
- LinkedHashSet
- ์ ์ฅ ์์๋ฅผ ์ ์งํ๋ HashSet
- TreeSet
- ๋ฐ์ดํฐ๊ฐ ์ ๋ ฌ๋ ์ํ๋ก ์ ์ฅ๋๋ ์ด์ง ํ์ ํธ๋ฆฌ(binary search tree)์ ํํ๋ก ์์๋ฅผ ์ ์ฅํ๋ค.
- ์ด์ง ํ์ ํธ๋ฆฌ ์ค์ ์ฑ๋ฅ์ ํฅ์์ํจ ๋ ๋-๋ธ๋ ํธ๋ฆฌ(Red-Black tree)๋ก ๊ตฌํ๋์ด ์๋ค.
- Compartor ๊ตฌํ์ผ๋ก ์ ๋ ฌ ๋ฐฉ๋ฒ์ ์ง์ ํ ์ ์๋ค.
- ArrayList
- ๋จ๋ฐฉํฅ ํฌ์ธํฐ ๊ตฌ์กฐ๋ก ๊ฐ ๋ฐ์ดํฐ์ ๋ํ ์ธ๋ฑ์ค๋ฅผ ๊ฐ์ง๊ณ ์์ด ๋ฐ์ดํฐ ๊ฒ์์ ์ ํฉํ๋ค.
- ๋ฐ์ดํฐ์ ์ฝ์ , ์ญ์ ์ ํด๋น ๋ฐ์ดํฐ ์ดํ ๋ชจ๋ ๋ฐ์ดํฐ๊ฐ ๋ณต์ฌ๋๋ฏ๋ก ์ฝ์ , ์ญ์ ๊ฐ ๋น๋ฒํ ๋ฐ์ดํฐ์๋ ๋ถ์ ํฉํ๋ค.
- LinkedList
- ์๋ฐฉํฅ ํฌ์ธํฐ ๊ตฌ์กฐ๋ก ๋ฐ์ดํฐ์ ์ฝ์ , ์ญ์ ์ ํด๋น ๋ ธ๋์ ์ฃผ์์ง๋ง ๋ฐ๊พธ๋ฉด ๋๋ฏ๋ก ์ฝ์ , ์ญ์ ๊ฐ ๋น๋ฒํ ๋ฐ์ดํฐ์ ์ ํฉํ๋ค.
- ๋ฐ์ดํฐ์ ๊ฒ์ ์ ์ฒ์๋ถํฐ ๋ ธ๋๋ฅผ ์ํํ๋ฏ๋ก ๊ฒ์์๋ ๋ถ์ ํฉํ๋ค.
- ์คํ, ํ, ์๋ฐฉํฅ ํ ๋ฑ์ ๋ง๋ค๊ธฐ ์ํ ์ฉ๋๋ก ์ฐ์ธ๋ค.
- Vector
- ๋ด๋ถ์์ ์๋์ผ๋ก ๋๊ธฐํ ์ฒ๋ฆฌ๊ฐ ์ผ์ด๋๋ค.
- ์ฑ๋ฅ์ด ์ข์ง ์๊ณ ๋ฌด๊ฑฐ์ ์ ์ฐ์ด์ง ์๋๋ค.
- String
- ์๋ก์ด ๊ฐ์ ํ ๋นํ ๋๋ง๋ค ์๋ก ํด๋์ค์ ๋ํ ๊ฐ์ฒด๊ฐ ์์ฑ๋๋ค.
- String์์ ์ ์ฅ๋๋ ๋ฌธ์์ด์ private final char[]์ ํํ์ด๊ธฐ ๋๋ฌธ์ String ๊ฐ์ ๋ฐ๊ฟ์ ์๋ค.
- private: ์ธ๋ถ์์ ์ ๊ทผ ๋ถ๊ฐ
- final: ์ด๊ธฐ๊ฐ ๋ณ๊ฒฝ ๋ถ๊ฐ
- String + String + String...
- ๊ฐ๊ฐ์ String ์ฃผ์๊ฐ์ด Stack์ ์์ด๊ณ , Garbage Collector๊ฐ ํธ์ถ๋๊ธฐ ์ ๊น์ง ์์ฑ๋ String ๊ฐ์ฒด๋ค์ Heap์ ์์ด๊ธฐ ๋๋ฌธ์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ์ ์น๋ช ์ ์ด๋ค.
- String์ ์ง์ ๋ํ๋ ๊ฒ๋ณด๋ค๋ StringBuffer๋ StringBuilder๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค.
- StringBuilder, StringBuffer
- memory์ appendํ๋ ๋ฐฉ์์ผ๋ก, ํด๋์ค์ ๋ํ ๊ฐ์ฒด๋ฅผ ์ง์ ์์ฑํ์ง ์๋๋ค.
- StringBuilder
- ๋ณ๊ฒฝ๊ฐ๋ฅํ ๋ฌธ์์ด
- ๋น๋๊ธฐ ์ฒ๋ฆฌ
- StringBuffer
- ๋ณ๊ฒฝ๊ฐ๋ฅํ ๋ฌธ์์ด
- ๋๊ธฐ ์ฒ๋ฆฌ
- multiple thread ํ๊ฒฝ์์ ์์ ํ ํด๋์ค(thread safe)
- Java ๋ฒ์ ๋ณ String Class ๋ณ๊ฒฝ ์ฌํญ
- JDK 1.5 ๋ฒ์ ์ด์ ์์๋ ๋ฌธ์์ด ์ฐ์ฐ(+, concat)์ ํ ๋ ์กฐํฉ๋ ๋ฌธ์์ด์ ์๋ก์ด ๋ฉ๋ชจ๋ฆฌ์ ํ ๋นํ์ฌ ์ฐธ์กฐํด ์ฑ๋ฅ์์ ์ด์ ์กด์ฌ
- JDK 1.5 ๋ฒ์ ์ดํ์๋ ์ปดํ์ผ ๋จ๊ณ์์ String ๊ฐ์ฒด๋ฅผ StringBuilder๋ก ์ปดํ์ผ ๋๋๋ก ๋ณ๊ฒฝ๋จ
- ๊ทธ๋์ JDK 1.5 ์ดํ ๋ฒ์ ์์๋ String ํด๋์ค๋ฅผ ์ฌ์ฉํด๋ StringBuilder์ ์ฑ๋ฅ ์ฐจ์ด๊ฐ ์์ด์ง
- ํ์ง๋ง ๋ฐ๋ณต ๋ฃจํ๋ฅผ ์ฌ์ฉํด์ ๋ฌธ์์ด์ ๋ํ ๋์๋ ๊ฐ์ฒด๋ฅผ ๊ณ์ ์๋ก์ด ๋ฉ๋ชจ๋ฆฌ์ ํ ๋นํจ
- String ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ๊ฒ ๋ณด๋ค๋ ์ค๋ ๋์ ๊ด๋ จ์ด ์์ผ๋ฉด StringBuffer, ์ค๋ ๋ ์์ ์ฌ๋ถ์ ์๊ด์ด ์์ผ๋ฉด StringBuilder๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๊ถ์ฅ
-
๋๊ธฐํ(Syncronous)
- ํ ์์์ ๋์์ ์ ๊ทผํ๋ ๊ฒ ์ ํ
- ์์ฐจ์ ์ผ๋ก ์งํ
- ๋ค์์ ์คํ๋ ๋ช ๋ น์ ํ์ฌ ์คํ ์ค์ธ ๋ช ๋ น ์ข ๋ฃ ์๊น์ง ๋๊ธฐ (๋๊ธฐ์๊ฐ ๋ฒํผ๋ง ๋ฐ์)
- ์๋ฒ์ ํด๋ผ์ด์ธํธ๊ฐ ์ฃผ๊ณ ๋ฐ๋ ๊ฒ์ด ๋์์ ์ด๋ฃจ์ด์ง๋ ํํ
- ์๊ฐ์ ์ธ ๋๊ธฐํ๊ฐ ํ์ํ ๊ณณ์ ๋ง์ด ์ฌ์ฉ
- ex. ํ๊ธ์ธ์ถ๊ธฐ
- Java์์ synchronized ํค์๋ ์ฌ์ฉ
- ์๋ฐ์์ ๋ฉํฐ ์ค๋ ๋ ์ ๊ทผ ์ ํ ํค์๋
- ๋ฉ์๋ ๋จ์, ๋ธ๋ก ๋จ์ ์ ์ฉ ๊ฐ๋ฅ
- ๋จ, ๋ฉ์๋ ๋จ์๋ก ์ง์ ํ ๊ฒฝ์ฐ ๋ฉ์๋ ์ ์ฒด์ lock์ด ๊ฑธ๋ฆฌ๊ธฐ ๋๋ฌธ์ ๊ฐ๋ฅํ๋ฉด ๋ธ๋ก ํ์ฉ (์๊ณ ์์ญ์ ์์ ์๋ก ์ข์)
-
๋น๋๊ธฐํ(Asyncronous)
- ํ์ฌ ์คํ ์ค์ธ ๋ช ๋ น์ด ์ข ๋ฃ๋์ง ์์๋ ๋ค์ ๋ช ๋ น ์คํ ๊ฐ๋ฅ
- Callback ํจ์๋ฅผ ํตํด ๊ฒฐ๊ณผ ํ์ธ
- ex. Ajax, Thread
-
์ ์ฉ ์์
- synchronized ํค์๋ ์ ์ฉํ์ง ์์ ๊ฒฝ์ฐ
class User { private int userNo = 0; // ์๊ณ ์์ญ์ด ๋์ด์ผํ๋ ๋ฉ์๋ public void add(String name) { System.out.println(name + " : " + userNo++); } } class UserThread extends Thread { User user; UserThread(User user, String name) { super(name); this.user = user; } public void run() { try { for (int i = 0; i < 3; i++) { user.add(getName()); sleep(500); } } catch(InterruptedException e) { System.err.println(e.getMessage()); } } } public class SyncThread { public static void name(String[] args) { User user = new User(); // 3๊ฐ์ ์ค๋ ๋ ๊ฐ์ฒด ์์ฑ UserThread p1 = new UserThread(user, "A"); UserThread p2 = new UserThread(user, "B"); UserThread p3 = new UserThread(user, "C"); // ์ค๋ ๋ ์ค์ผ์ค๋ง : ์ฐ์ ์์ ๋ถ์ฌ p1.setPriority(p1.MAX_PRIORITY); p2.setPriority(p2.NORM_PRIORITY); p3.setPriority(p3.MIN_PRIORITY); p1.start(); p2.start(); p3.start(); } }
// ๊ฒฐ๊ณผ => ์์ ๋ค์ฃฝ๋ฐ์ฃฝ A : 0๋ฒ์งธ ์ฌ์ฉ B : 1๋ฒ์งธ ์ฌ์ฉ C : 2๋ฒ์งธ ์ฌ์ฉ A : 3๋ฒ์งธ ์ฌ์ฉ C : 5๋ฒ์งธ ์ฌ์ฉ B : 4๋ฒ์งธ ์ฌ์ฉ C : 7๋ฒ์งธ ์ฌ์ฉ A : 6๋ฒ์งธ ์ฌ์ฉ B : 8๋ฒ์งธ ์ฌ์ฉ
- ๋๊ธฐํ๊ฐ ํ์ํ User ํด๋์ค์ add ๋ฉ์๋์ synchronized ํค์๋ ์ ์ฉํ ๊ฒฝ์ฐ
class User { private int userNo = 0; public synchronized void add(String name) { System.out.println(name + " : " + userNo++); } }
// ๊ฒฐ๊ณผ A : 0๋ฒ์งธ ์ฌ์ฉ B : 1๋ฒ์งธ ์ฌ์ฉ C : 2๋ฒ์งธ ์ฌ์ฉ A : 3๋ฒ์งธ ์ฌ์ฉ B : 5๋ฒ์งธ ์ฌ์ฉ C : 4๋ฒ์งธ ์ฌ์ฉ A : 7๋ฒ์งธ ์ฌ์ฉ B : 6๋ฒ์งธ ์ฌ์ฉ C : 8๋ฒ์งธ ์ฌ์ฉ
- synchronized ํค์๋ ์ ์ฉํ์ง ์์ ๊ฒฝ์ฐ
- [์๋ฐ] ๋๊ธฐํ ์ฒ๋ฆฌ - Synchronized ์ Asynchronized
- Java์ ๋๊ธฐํ Synchronized ๊ฐ๋ ์ ๋ฆฌ#1
- ๋๊ธฐํ์ ๋น๋๊ธฐํ (synchronization and asynchronous) JAVA ์ ๋คํธ์ํฌ
- "=="
- ํญ๋ฑ ์ฐ์ฐ์(Operator) ์ด๋ค.
- <--> !=
- ์ฐธ์กฐ ๋น๊ต(Reference Comparison) ; (์ฃผ์ ๋น๊ต, Address Comparison)
- ๋ ๊ฐ์ฒด๊ฐ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๊ฐ๋ฆฌํค๋์ง ํ์ธํ๋ค.
- ๋ฐํ ํํ: boolean type
- ๊ฐ์ ์ฃผ์๋ฉด return true, ๋ค๋ฅธ ์ฃผ์๋ฉด return false
- ๋ชจ๋ ๊ธฐ๋ณธ ์ ํ(Primitive Types)์ ๋ํด ์ ์ฉํ ์ ์๋ค.
- byte, short, char, int, float, double, boolean
- ํญ๋ฑ ์ฐ์ฐ์(Operator) ์ด๋ค.
- "equals()"
- ๊ฐ์ฒด ๋น๊ต ๋ฉ์๋(Method) ์ด๋ค.
- <--> !(s1.equals(s2));
- ๋ด์ฉ ๋น๊ต(Content Comparison)
- ๋ ๊ฐ์ฒด์ ๊ฐ์ด ๊ฐ์์ง ํ์ธํ๋ค.
- ์ฆ, ๋ฌธ์์ด์ ๋ฐ์ดํฐ/๋ด์ฉ์ ๊ธฐ๋ฐ์ผ๋ก ๋น๊ตํ๋ค.
- ๊ธฐ๋ณธ ์ ํ(Primitive Types)์ ๋ํด์๋ ์ ์ฉํ ์ ์๋ค.
- ๋ฐํ ํํ: boolean type
- ๊ฐ์ ๋ด์ฉ์ด๋ฉด return true, ๋ค๋ฅธ ๋ด์ฉ์ด๋ฉด return false
- "==" VS "equals()" ์์
public class Test {
public static void main(String[] args) {
// Thread ๊ฐ์ฒด
Thread t1 = new Thread();
Thread t2 = new Thread(); // ์๋ก์ด ๊ฐ์ฒด ์์ฑ. ์ฆ, s1๊ณผ ๋ค๋ฅธ ๊ฐ์ฒด.
Thread t3 = t1; // ๊ฐ์ ๋์์ ๊ฐ๋ฆฌํจ๋ค.
// String ๊ฐ์ฒด
String s1 = new String("WORLD");
String s2 = new String("WORLD");
/* --print-- */
System.out.println(t1 == t3); // true
System.out.println(t1 == t2); // false(์๋ก ๋ค๋ฅธ ๊ฐ์ฒด์ด๋ฏ๋ก ๋ณ๋์ ์ฃผ์๋ฅผ ๊ฐ๋๋ค.)
System.out.println(t1.equals(t2)); // false
System.out.println(s1.equals(s2)); // true(๋ชจ๋ "WORLD"๋ผ๋ ๋์ผํ ๋ด์ฉ์ ๊ฐ๋๋ค.)
}
}
- ๋ฆฌํ๋ ์
(Reflection) ์ด๋?
- ์๋ฐ์์ ์ด๋ฏธ ๋ก๋ฉ์ด ์๋ฃ๋ ํด๋์ค์์ ๋ ๋ค๋ฅธ ํด๋์ค๋ฅผ ๋์ ์ผ๋ก ๋ก๋ฉ(Dynamic Loading)ํ์ฌ ์์ฑ์(Constructor), ๋ฉค๋ฒ ํ๋(Member Variables) ๊ทธ๋ฆฌ๊ณ ๋ฉค๋ฒ ๋ฉ์๋(Member Method) ๋ฑ์ ์ฌ์ฉํ ์ ์๋ ๊ธฐ๋ฒ์ด๋ค.
- ํด๋์ค์ ํจํค์ง ์ ๋ณด, ์ ๊ทผ ์ง์ ์, ์ํผ ํด๋์ค, ์ด๋ ธํ ์ด์ (Annotation) ๋ฑ์ ์ป์ ์ ์๋ค.
- ์ปดํ์ผ ์๊ฐ(Compile Time)์ด ์๋๋ผ ์คํ ์๊ฐ(Run Time)์ ๋์ ์ผ๋ก ํน์ ํด๋์ค์ ์ ๋ณด๋ฅผ ๊ฐ์ฒดํ๋ฅผ ํตํด ๋ถ์ ๋ฐ ์ถ์ถํด๋ผ ์ ์๋ ํ๋ก๊ทธ๋๋ฐ ๊ธฐ๋ฒ์ด๋ค.
- ์ฌ์ฉ ๋ฐฉ๋ฒ
Class.forName("ํด๋์ค์ด๋ฆ")
- ํด๋์ค์ ์ด๋ฆ์ผ๋ก๋ถํฐ ์ธ์คํด์ค๋ฅผ ์์ฑํ ์ ์๊ณ , ์ด๋ฅผ ์ด์ฉํ์ฌ ํด๋์ค์ ์ ๋ณด๋ฅผ ๊ฐ์ ธ์ฌ ์ ์๋ค.
public class DoHee { public String name; public int number; public void setDoHee (String name, int number) { this.name = name; this.number = number; } public void setNumber(int number) { this.number = number; } public void sayHello(String name) { System.out.println("Hello, " + name); } }
import java.lang.reflect.Method; import java.lang.reflect.Field; public class ReflectionTest { public void reflectionTest() { try { Class myClass = Class.forName("DoHee"); Method[] methods = myClass.getDeclaredMethods(); /* ํด๋์ค ๋ด ์ ์ธ๋ ๋ฉ์๋์ ๋ชฉ๋ก ์ถ๋ ฅ */ /* ์ถ๋ ฅ : public void DoHee.setDoHee(java.lang.String,int) public void DoHee.setNumber(int) public void DoHee.sayHello(java.lang.String) */ for (Method method : methods) { System.out.println(method.toString()); } /* ๋ฉ์๋์ ๋งค๊ฐ๋ณ์์ ๋ฐํ ํ์ ํ์ธ */ /* ์ถ๋ ฅ : Class Name : class DoHee Method Name : setDoHee Return Type : void */ Method method = methods[0]; System.out.println("Class Name : " + method.getDeclaringClass()); System.out.println("Method Name : " + method.getName()); System.out.println("Return Type : " + method.getReturnType()); /* ์ถ๋ ฅ : Param Type : class java.lang.String Param Type : int */ Class[] paramTypes = method.getParameterTypes(); for(Class paramType : paramTypes) { System.out.println("Param Type : " + paramType); } /* ๋ฉ์๋ ์ด๋ฆ์ผ๋ก ํธ์ถ */ Method sayHelloMethod = myClass.getMethod("sayHello", String.class); sayHelloMethod.invoke(myClass.newInstance(), new String("DoHee")); // ์ถ๋ ฅ : Hello, DoHee /* ๋ค๋ฅธ ํด๋์ค์ ๋ฉค๋ฒ ํ๋์ ๊ฐ ์์ */ Field field = myClass.getField("number"); DoHee obj = (DoHee) myClass.newInstance(); obj.setNumber(5); System.out.println("Before Number : " + field.get(obj)); // ์ถ๋ ฅ : Before Number : 5 field.set(obj, 10); System.out.println("After Number : " + field.get(obj)); // ์ถ๋ ฅ : After Number : 10 } catch (Exception e) { // Exception Handling } } public static void main(String[] args) { new ReflectionTest().reflectionTest(); } }
- ์ ์ฌ์ฉํ ๊น?
- ์คํ ์๊ฐ์ ๋ค๋ฅธ ํด๋์ค๋ฅผ ๋์ ์ผ๋ก ๋ก๋ฉํ์ฌ ์ ๊ทผํ ๋
- ํด๋์ค์ ๋ฉค๋ฒ ํ๋ ๊ทธ๋ฆฌ๊ณ ๋ฉ์๋ ๋ฑ์ ๊ดํ ์ ๋ณด๋ฅผ ์ป์ด์ผํ ๋
- ๋ฆฌํ๋ ์ ์์ด๋ ์์ฑ๋ ๋์ ์ฝ๋๋ฅผ ๊ตฌํํ ์ ์์ง๋ง ์ฌ์ฉํ๋ค๋ฉด ์กฐ๊ธ ๋ ์ ์ฐํ ์ฝ๋๋ฅผ ๋ง๋ค ์ ์๋ค.
- ์ฃผ์ํ ์
- ์ธ๋ถ์ ๊ณต๊ฐ๋์ง ์๋ private ๋ฉค๋ฒ๋
Field.setAccessible()
๋ฉ์๋๋ฅผ true๋ก ์ง์ ํ๋ฉด ์ ๊ทผ๊ณผ ์กฐ์์ด ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ์ฃผ์ํด์ผ ํ๋ค.
- ์ธ๋ถ์ ๊ณต๊ฐ๋์ง ์๋ private ๋ฉค๋ฒ๋
-
Stream์ด๋?
- java8์์ ์ถ๊ฐ๋ API
- ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๋๋ฐ ์์ฃผ ์ฌ์ฉ๋๋ ๋ฉ์๋ ์ ์
- ์ปฌ๋ ์ ํ์ ์ ๋ฐ์ดํฐ๋ฅผ Stream ๋ฉ์๋์์ ๋ด๋ถ ๋ฐ๋ณต์ ํตํด ์ ๋ ฌ, ํํฐ๋ง ๋ฑ ๊ฐ๋ฅ
-
ํน์ง
- ๋ณ๋ ฌ ์ฒ๋ฆฌ์ ์ ๋ฆฌ
- ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ฅผ ์ํด common fork join pool์ ์ฌ์ฉํ๋ parallel() ๋ฉ์๋ ์ ๊ณต
- common fork join pool
- ๊ฐ ์ค๋ ๋๊ฐ ๊ฐ๋ณ ํ๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ, ๋๊ณ ์๋ ์ค๋ ๋๊ฐ ์์ผ๋ฉด ์ผํ๋ ์ค๋ ๋์ ์์ ์ ๊ฐ์ ธ์ ์ํํ์ฌ ์ต์ ์ ์ฑ๋ฅ ๋์ถ
- ์ฝ์ด์ ์๊ฐ ๋ง์์๋ก, ์ฒ๋ฆฌํ ๋ฐ์ดํฐ ์๊ฐ ๋ง์์๋ก, ๋ฐ์ดํฐ๋น ์ฒ๋ฆฌ ์๊ฐ์ด ๊ธธ์๋ก ๋ณ๋ ฌ ์ฒ๋ฆฌ ์ฑ๋ฅ ํฅ์
- ๋ฐฐ์ด, ArrayList ์ฌ์ฉ ์ ์ ๋ฆฌ(LinkedList๋ ์์ฐจ ์งํ์ด ๋ ๋์ ์ ์์)
- Immutable
- ์๋ณธ ๋ฐ์ดํฐ ๋ณ๊ฒฝ ๋ถ๊ฐ๋ฅ
- ์ ์ด์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ์ง ์์ผ๋ฉฐ, ๋ณ๊ฒฝ๋๋ ๋ด์ฉ์ Stream์ ์ง์ํ๋ ์ปฌ๋ ์ ์ ๋ฐ์ดํฐ
- lazy
- ์คํธ๋ฆผ์๋ ์ค๊ฐ ์ฐ์ฐ๊ณผ ์ต์ข ์ฐ์ฐ์ด ์๋๋ฐ ์ค๊ฐ ์ฐ์ฐ์ ์ฌ๋ฌ๊ฐ ์์ฑ ์ ๋ชจ๋ ํฉ์ณ์ ์งํํ๊ณ , ํฉ์ณ์ง ์ฐ์ฐ์ ์ต์ข ์ฐ์ฐ์์ ํ ๋ฒ์ ์ฒ๋ฆฌ
- ๋ง์ง๋ง ์ต์ข
์ฐ์ฐ์ด ๋๋ ๋ ๊ฐ ๊ณ์ฐ
- ์ค๊ฐ ์ฐ์ฐ : filter, map, flatMap, ...
- ์ต์ข ์ฐ์ฐ : allMatch, findFirst, collect, count, ...
- ์ค๊ฐ ์ฐ์ฐ์ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ ์คํธ๋ฆผ์ ๋ฐํํ์ฌ ํ์ดํ๋ผ์ด๋ ๊ฐ๋ฅ
- ์ฌ์ฌ์ฉ ๋ถ๊ฐ๋ฅ
- ์ต์ข ์ฐ์ฐ ์๋ฃ ํ Stream์ด ๋ซํ๋ฏ๋ก ์ฌ์ฌ์ฉ ๋ถ๊ฐ๋ฅ
- ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ด์ ์ฒ๋ฆฌํ๋ ์ฉ๋์ด์ง ๋ฐ์ดํฐ ์ ์ฅ ๋ชฉ์ ์ด ์๋๊ธฐ ๋๋ฌธ
- ๋ณ๋ ฌ ์ฒ๋ฆฌ์ ์ ๋ฆฌ
-
์ฅ์
- ๋ด๋ถ ๋ฐ๋ณต์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ๋ถํ์ํ ์ฝ๋ฉ ๊ณผ์ ์ ์ค์ผ ์ ์๊ณ , ์ฝ๋ ๊ฐ๋ ์ฑ ํฅ์
- Java 8์์ ๋ฑ์ฅ
- ๋ฉ์๋๋ฅผ ํ๋์ ์์ผ๋ก ํํ
- ๋งค๊ฐ๋ณ์, ->(ํ์ดํ), {๋ชธํต} ๊ตฌ์กฐ
- ๋ฉ์๋์ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌํ ์ ์๊ณ , ๋ฉ์๋ ๊ฒฐ๊ณผ๋ก ๋ฐํ ๊ฐ๋ฅ
- ๋๋ค๋ ํจ์ํ ์ธํฐํ์ด์ค๋ฅผ ํตํด์๋ง ์ฌ์ฉ ๊ฐ๋ฅ
- ํจ์ํ ์ธํฐํ์ด์ค
- ์ธํฐํ์ด์ค ๋ด์ ํ ๊ฐ์ ์ถ์ ๋ฉ์๋๋ง ์ ์
- ์ธ๋ถ์์ ๋ฉ์๋ ํธ์ถ ์ ๋๋ค์์ด๋ ๋ฉ์๋ ์ฐธ์กฐ ๊ฐ๋ฅ
- ์๋ฐ์์ ํจ์๋ฅผ ์ผ๊ธ ๊ฐ์ฒด๋ก ์ฌ์ฉํ ์ ์๋ ๋จ์ ๋ณด์
- ํจ์ํ ์ธํฐํ์ด์ค์์ ๋ช
ํํ ํ๊ธฐ ์ํด
@FunctionalInterface
์ฌ์ฉ - ex. Comparator, Runnuble
- Lambda์ Stream์ ๋ฑ์ฅ ๊ณ๊ธฐ
- ํจ์ํ ํ๋ก๊ทธ๋๋ฐ, ํจ์ํ ํจ๋ฌ๋ค์์ ๋ฑ์ฅ์ ๋ฐ๋ผ ๋ฑ์ฅ
- [์ฐธ๊ณ ] ํจ์ํํ๋ก๊ทธ๋๋ฐ์ ๋ฑ์ฅ ๊ณ๊ธฐ
- ๊ธฐ์กด์ ์ต๋ช ํจ์๋ก ์์ฑํ๋ ์ฝ๋๋ฅผ ์ค์ฌ ๊ฐ๋จํ๊ฒ ์์ฑ ๊ฐ๋ฅ
- ๊ฐ๋ ์ฑ ์ฆ๊ฐ
- ๋ณ๋ ฌ ํ๋ก๊ทธ๋๋ฐ์ ์ฉ์ด
- ๋จ์ฉํ๋ฉด ์ฝ๋๋ฅผ ์ดํดํ๋๋ฐ ์ด๋ ค์
- ๊น๋ค๋ก์ด ์ฌ๊ท ํ์ฉ ๋ฐ ๋๋ฒ๊น
- ์ต๋ช ํจ์์๋ ๋ค๋ฅด๊ฒ ์ปดํ์ผ
- ์ต๋ช ํจ์๋ ๋ณ๋ ํด๋์ค์ ์ธ์คํด์ค๋ฅผ ์์ฑ
- Lambda๋ 'invokedynamic'์ ์ฌ์ฉํ์ฌ Lambda ํํ์ ๊ตฌํ์ ์ํ ์ฝ๋ ์์ฑ์ ๋ฐํ์ ์ ๊น์ง ์ฐ๊ธฐ
- ๋ฐํ์ ์์ ์ด๋ค ๋ฐฉ๋ฒ์ผ๋ก ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ง ๊ฒฐ์ ํ๋๋ฐ, ์ฑ๋ฅ ํฅ์์ ์ํ ์ต์ ํ๋ ๋ฐฉ๋ฒ ์ฌ์ฉ