1. ์๋ฐ(Java) ๋?
- JAVA๋ ๋คํธ์ํฌ์์์ ์ธ ์ ์๋๋ก ๋ฏธ๊ตญ์ ์ ๋ง์ดํฌ๋ก ์์คํ ์ฆ๊ฐ ๊ฐ๋ฐํ ๊ฐ์ฒด์งํฅํ๋ก๊ทธ๋๋ฐ์ธ์ด
1-1. ์๋ฐ(Java)์ ํน์ง
- ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ์ฝ๋์ ์ฌ์ฌ์ฉ์ด ๋๋ค
- ์ฝ๋์ ๋ณ๊ฒฝ์ด ์ฉ์ด
- ์ง๊ด์ ์ธ ์ฝ๋ ๋ถ์
- ๊ฐ๋ฐ์๋ ํฅ์
- ์์์ ํตํ ์ฅ์ ๊ทน๋ํ
2. Object
- Object(๊ฐ์ฒด)๋ OOP์์ ์์ฑ(๋ณ์)์ ๊ทธ ๋ฐ์ดํฐ์ ๊ด๋ จ๋๋ ๋์(ํจ์).
- ์๋ฐ์์๋ ์ด๋ฌํ ๊ฐ์ฒด์ ์์ฑ์ ํ๋(field), ๋์์ ๋ฉ์๋(method)๋ผ๊ณ ํ๋ค.
3. Overloading vs Overriding
- Overloading (์ค๋ฒ๋ก๋ฉ)
- ๊ฐ์ ์ด๋ฆ์ ๋ฉ์๋๋ฅผ ์ฌ๋ฌ๊ฐ ์ ์
- ๋งค๊ฐ๋ณ์์ ํ์ ์ด ๋ค๋ฅด๊ฑฐ๋ ๊ฐ์๊ฐ ๋ฌ๋ผ์ผ ํ๋ค.
- ์์ฑ์ ์ค๋ฒ๋ก๋ฉ
- ์์ฑ์์ธ๋ฐ ๋งค๊ฐ๋ณ์์ ํ์ , ๊ฐ์, ์์๋ฅผ ๋ค๋ฅด๊ฒ ์ฌ๋ฌ ๊ฐ ์ ์ธ > ๋งค๊ฐ๊ฐ์ผ๋ก ๊ฐ์ฒด์ ํ๋๋ฅผ ๋ค์ํ๊ฒ ์ด๊ธฐํํ๊ธฐ ์ํด
public class MyClass {
private int value1;
private String value2;
// ๊ธฐ๋ณธ ์์ฑ์
public MyClass() {
this.value1 = 0;
this.value2 = "Default";
}
// ๋งค๊ฐ๋ณ์๊ฐ ์๋ ์์ฑ์
public MyClass(int value1, String value2) {
this.value1 = value1;
this.value2 = value2;
}
// ๋ค๋ฅธ ํ์
์ ๋งค๊ฐ๋ณ์๋ฅผ ๋ฐ๋ ์์ฑ์
public MyClass(String value2) {
this.value1 = 0;
this.value2 = value2;
}
// ๋ค๋ฅธ ํ์
์ ๋งค๊ฐ๋ณ์๋ฅผ ๋ฐ๋ ์์ฑ์
public MyClass(int value1) {
this.value1 = value1;
this.value2 = "Default";
}
// ๊ฐ์ฒด์ ์ํ๋ฅผ ์ถ๋ ฅํ๋ ๋ฉ์๋
public void displayValues() {
System.out.println("Value1: " + value1);
System.out.println("Value2: " + value2);
}
public static void main(String[] args) {
// ๋ค์ํ ์์ฑ์๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ฒด ์์ฑ
MyClass obj1 = new MyClass();
MyClass obj2 = new MyClass(42, "Hello");
MyClass obj3 = new MyClass("Custom");
MyClass obj4 = new MyClass(24);
// ๊ฐ์ฒด์ ์ํ ์ถ๋ ฅ
obj1.displayValues();
obj2.displayValues();
obj3.displayValues();
obj4.displayValues();
}
}
- ๋ฉ์๋ ์ค๋ฒ๋ก๋ฉ
- ๋ฉ์๋์ ์ด๋ฆ์ ๊ฐ๋ ๋งค๊ฐ๋ณ์์ ํ์ ๊ฐฏ์ ์์๋ฅผ ๋ค๋ฅด๊ฒ ์ ์ธ > ๋ค์ํ ๋งค๊ฐ๊ฐ์ ์ฒ๋ฆฌํ๊ธฐ ์ํด
public class Calculator {
// ๋ ์ ์๋ฅผ ๋ํ๋ ๋ฉ์๋
public int add(int a, int b) {
return a + b;
}
// ์ธ ์ ์๋ฅผ ๋ํ๋ ๋ฉ์๋
public int add(int a, int b, int c) {
return a + b + c;
}
// ๋ ์ค์๋ฅผ ๋ํ๋ ๋ฉ์๋
public double add(double a, double b) {
return a + b;
}
// ๋ฌธ์์ด์ ์ด์ด๋ถ์ด๋ ๋ฉ์๋
public String add(String str1, String str2) {
return str1 + str2;
}
public static void main(String[] args) {
Calculator calculator = new Calculator();
// ๋ค์ํ ๋งค๊ฐ๋ณ์๋ฅผ ๊ฐ์ง๋ ๋ฉ์๋ ํธ์ถ
int result1 = calculator.add(2, 3);
int result2 = calculator.add(1, 4, 7);
double result3 = calculator.add(3.5, 2.7);
String result4 = calculator.add("Hello", "World");
// ๊ฒฐ๊ณผ ์ถ๋ ฅ
System.out.println("Result 1: " + result1);
System.out.println("Result 2: " + result2);
System.out.println("Result 3: " + result3);
System.out.println("Result 4: " + result4);
}
}
- Overriding (์ค๋ฒ๋ผ์ด๋ฉ)
- ์์์์ ๋์จ ๊ฐ๋
- ์์ ํด๋์ค(๋ถ๋ชจ ํด๋์ค)์ ๋ฉ์๋๋ฅผ ํ์ ํด๋์ค(์์ ํด๋์ค)์์ ์ ์
4. Servlet & Jsp
- Servlet
- ์๋ฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๋ ์น ๊ฐ๋ฐ ํ์ค ์ธ์ด
- Container๊ฐ ์ดํดํ ์ ์๊ฒ ๊ตฌ์ฑ๋ ์์ ์๋ฐ ์ฝ๋๋ก๋ง ์ด๋ฃจ์ด์ง ๊ฒ (Html in JAVA)
- ํด๋ผ์ด์ธํธ๋ก๋ถํฐ ์์ฒญ์ด ๋ค์ด์ค๋ฉด HTTP ํ๋กํ ์ฝ์ ์ฌ์ฉํ๊ฒ ๋๋ฏ๋ก Request, Response ๊ฐ์ฒด๋ฅผ ์์ฑ
- ์์ฒญ๋ URL์ ๋งคํ๋ ์๋ธ๋ฆฟ์ ์์ฑ์๋ฅผ ํธ์ถ
- ์์ฑ์๋ init() ๋ฉ์๋๋ฅผ ์คํ
- init() ๋ฉ์๋๋ service() ๋ฉ์๋๋ฅผ ํธ์ถํ๊ณ service() ๋ฉ์๋๋ ์ค๋ ๋์ ๋ด๊ฒจ์ง๋ค.
- ์์ฒญํ ๋ฐฉ์ (get. post)์ ๋ฐ๋ผ์ ํด๋น ๋ฉ์๋๋ก ์ด๋
- ์๋ตํ๊ณ ์ฐ๊ฒฐ์ ๋๋๋ค.
- JSP(Java Server Page)
- ์๋ฐ ๊ธฐ๋ฐ ์คํฌ๋ฆฝํธ ์ธ์ด
- Html ๊ธฐ๋ฐ์ JAVA ์ฝ๋๋ฅผ ๋ธ๋กํํ์ฌ ์ฝ์ (JAVA in Html)
- ํด๋ผ์ด์ธํธ(์น ๋ธ๋ผ์ฐ์ )๊ฐ JSP ํ์ด์ง๋ฅผ ์์ฒญ
- ์๋ฒ๋ JSP ํ์ด์ง๋ฅผ ์ฐพ์ ํด๋น ํ์ด์ง๋ฅผ ์๋ธ๋ฆฟ์ผ๋ก ๋ณํ
- ๋ณํ๋ ์๋ธ๋ฆฟ ์ฝ๋๊ฐ ์ปดํ์ผ๋์ด ์คํ ๊ฐ๋ฅํ Java ํด๋์ค ํ์ผ๋ก ์์ฑ
- ์๋ฒ๋ ์์ฑ๋ ์๋ธ๋ฆฟ์ ์คํํ๊ณ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ค์ ํด๋ผ์ด์ธํธ์๊ฒ ์ ์ก
- ํด๋ผ์ด์ธํธ๋ ๋ฐ์ ๊ฒฐ๊ณผ๋ฅผ ํ๋ฉด์ ํ์
5. JDBC
- Java Data Base Connection์ ์ฝ์
- JAVA ์ธ์ด๋ฅผ ํตํด ๋ฐ์ดํฐ ๋ฒ ์ด์ค์ ์ ๊ทผ ํ ์ ์๋ ํ๋ก๊ทธ๋๋ฐ์ ์๋ฏธ
6. Session๊ณผ Cookie
6-1 . Session๊ณผ Cookie ์ฌ์ฉ ์ด์
- ์๋ก์ด ํ์ด์ง๋ฅผ ์์ฒญ ํ ๋๋ง๋ค ์๋ก์ด ์ ์์ด ์ด๋ฃจ์ด์ง๋ฉฐ ์ด์ ํ์ด์ง์ ํ์ฌ ํ์ด์ง ๊ฐ์ ๊ด๊ณ๊ฐ ์ง์๋์ง ์๋๋ค. ์ด์ ๋ฐ๋ผ HTTP ํ๋กํ ์ฝ์ ์ด์ฉํ๊ฒ ๋๋ ์น์ฌ์ดํธ์๋ ์น ํ์ด์ง์ ํน์ ๋ฐฉ๋ฌธ์๊ฐ ๋จธ๋ฌด๋ฅด๊ณ ์๋ ๋์์ ๊ทธ ๋ฐฉ๋ฌธ์์ ์ํ๋ฅผ ์ง์์ํค๊ธฐ ์ํด ์ฟ ํค์ ์ธ์
์ ์ฌ์ฉ
6-2 . ์ธ์ (Session)
- ํน์ ์น์ฌ์ดํธ์์ ์ฌ์ฉ์๊ฐ ๋จธ๋ฌด๋ฅด๋ ๊ธฐ๊ฐ ํน์ ํ ๋ช ์ ์ฌ์ฉ์ ๋ฐฉ๋ฌธ์ ์๋ฏธ
- Session์ ๊ด๋ จ๋ ๋ฐ์ดํฐ๋ Server์ ์ ์ฅ
- ์น ๋ธ๋ผ์ฐ์ ์ ์บ์์ ์ ์ฅ๋์ด ๋ธ๋ผ์ฐ์ ๊ฐ ๋ซํ๊ฑฐ๋ ์๋ฒ์์ ์ญ์ ์ ์๋ฉธ
- ์ฟ ํค(Cookie)์ ๋นํ์ฌ ๋ณด์์ฑ์ด ์ข๋ค
6-3 . ์ฟ ํค (Cookie)
- ์ฌ์ฉ์ ์ ๋ณด๋ฅผ ์ ์งํ ์ ์๋ค๋ HTTP์ ํ๊ณ๋ฅผ ๊ทน๋ณตํ ์ ์๋ ๋ฐฉ๋ฒ
- ์ธํฐ๋ท ์น ์ฌ์ดํธ์ ๋ฐฉ๋ฌธ ๊ธฐ๋ก์ ๋จ๊ฒจ ์ฌ์ฉ์์ ์น์ฌ์ดํธ ์ฌ์ด๋ฅผ ๋งค๊ฐํด ์ฃผ๋ ์ ๋ณด
- ์ฟ ํค(Cookie)๋ ์ธํฐ๋ท ์ฌ์ฉ์๊ฐ ํน์ ์น์๋ฒ์ ์ ์ํ ๋, ์์ฑ๋๋ ๊ฐ์ธ ์์ด๋์ ๋น๋ฐ๋ฒํธ, ๋ฐฉ๋ฌธํ ์ฌ์ดํธ์ ์ ๋ณด๋ฅผ ๋ด์ ์์ ํ์ผ๋ก์, Server๊ฐ ์๋ Client์ ํ ์คํธ ํ์ผ๋ก ์ ์ฅ๋์ด ๋ค์์ ํด๋น ์น์๋ฒ๋ฅผ ์ฐพ์ ๊ฒฝ์ฐ ์น์๋ฒ์์๋ ๊ทธ๊ฐ ๋๊ตฌ์ธ์ง ์ด๋ค ์ ๋ณด๋ฅผ ์ฃผ๋ก ์ฐพ์๋์ง ๋ฑ์ ํ์ ํ ๋ ์ฌ์ฉ
- ์ฟ ํค(Cookie)๋ Client PC์ ์ ์ฅ ๋๋ ์ ๋ณด, ๋ค๋ฅธ ์ฌ์ฉ์์ ์ํด์ ์์๋ก ๋ณ๊ฒฝ์ด ๊ฐ๋ฅ
- ์ ๋ณด ์ ์ถ ๊ฐ๋ฅ, Session๋ณด๋ค ๋ณด์์ฑ์ด ๋ฎ์ ์ด์
Question ) ๋ณด์์ฑ์ด ๋ฎ์ Cookie ๋์ Session์ ์ฌ์ฉํ๋ฉด ๋๋๋ฐ ์ํ๋ ์ด์ ?
- ๋ชจ๋ ์ ๋ณด๋ฅผ Session์ ์ ์ฅํ๋ฉด Server์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ณผ๋ํ๊ฒ ์ฌ์ฉํ๊ฒ ๋์ด Server์ ๋ฌด๋ฆฌ๊ฐ ๊ฐ๋ค.
7. final ํ๋์ ์์
- final์ Java์์ ๋ณ์, ๋ฉ์๋, ํด๋์ค์ ์ ์ฉ๋๋ ํค์๋๋ก, ์ฌ์ฉ๋๋ ๊ณณ์ ๋ฐ๋ผ ์๋ฏธ๊ฐ ์กฐ๊ธ์ฉ ๋ค๋ฅด๋ค.
7-1. final ๋ณ์ (์์)
- final ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ธ๋ ๋ณ์๋ ํ ๋ฒ ํ ๋น๋๋ฉด ๊ฐ์ ๋ณ๊ฒฝํ ์ ์๋ ์์๊ฐ ๋ฉ๋๋ค. ์์๋ ๋๋ฌธ์๋ก ์์ฑํ๋ฉฐ, ๋จ์ด ์ฌ์ด๋ฅผ ์ธ๋์ค์ฝ์ด(_)๋ก ๊ตฌ๋ถํ๋ ๊ฒ์ด ๊ด๋ก์ ๋๋ค.
public class Example {
// final ๋ณ์ (์์)
final int MAX_VALUE = 100;
public void printMaxValue() {
System.out.println("Max value: " + MAX_VALUE);
}
public static void main(String[] args) {
Example example = new Example();
example.printMaxValue();
}
}
7-2. final ํ๋
- ํด๋์ค์ ๋ฉค๋ฒ ๋ณ์ ์ค final ํค์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ธ๋ ํ๋๋ ์ด๊ธฐํ ์ดํ์ ๊ฐ์ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค. final ํ๋๋ ์ฃผ๋ก ํ ๋ฒ ์ค์ ๋๋ฉด ๋ณ๊ฒฝ๋์ง ์์์ผ ํ๋ ๊ฒฝ์ฐ์ ์ฌ์ฉ๋ฉ๋๋ค.
public class Example {
// final ํ๋
final int fixedValue;
// ์์ฑ์์์ final ํ๋ ์ด๊ธฐํ
public Example(int value) {
this.fixedValue = value;
}
public void printFixedValue() {
System.out.println("Fixed value: " + fixedValue);
}
public static void main(String[] args) {
Example example = new Example(42);
example.printFixedValue();
}
}
8. ์ ๊ทผ์ ํ์
- ์๋ฐ์์ ์ ๊ทผ์ ํ์๋ public, private, protected 3๊ฐ์ง ์กด์ฌ
์ ๊ทผ ์ ํ์ | ์ ํ ๋์ | ์ ํ ๋ฒ์ | ์ฐ์ ์์ |
private | ํด๋์ค, ์์ฑ์, ๋ฉ์๋ | ๊ฐ์ ํด๋์ค ๋ด๋ถ | 1 |
default (package-private) | ํด๋์ค, ํ๋, ์์ฑ์, ๋ฉ์๋ | ๊ฐ์ ํจํค์ง | 2 |
protected | ํ๋, ์์ฑ์, ๋ฉ์๋ | ๊ฐ์ ํจํค์ง / ์์ ๊ฐ์ฒด |
3 |
public | ํด๋์ค, ํ์ค, ์์ฑ์, ๋ฉ์๋ | ์์ | 4 |
- private:
- private ์ ๊ทผ ์ ์ด์๋ ๊ฐ์ฅ ๋์ ์ฐ์ ์์๋ฅผ ๊ฐ์ง๋๋ค.
- ํด๋น ๋ฉค๋ฒ๋ ๋์ผํ ํด๋์ค ๋ด์์๋ง ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ฉฐ, ์ธ๋ถ ํด๋์ค๋ ํ์ ํด๋์ค์์๋ ์ง์ ์ ๊ทผํ ์ ์์ต๋๋ค.
- default (package-private):
- default๋ ๋ณ๋์ ์ ๊ทผ ์ ์ด์๋ฅผ ๋ช ์ํ์ง ์์ ๊ฒฝ์ฐ์ ๊ธฐ๋ณธ ๊ฐ์ ๋๋ค.
- ํด๋น ๋ฉค๋ฒ๋ ๋์ผํ ํจํค์ง ๋ด์์๋ ์ ๊ทผ์ด ๊ฐ๋ฅํ์ง๋ง, ์ธ๋ถ ํจํค์ง์์๋ ์ง์ ์ ๊ทผํ ์ ์์ต๋๋ค.
- protected:
- protected ์ ๊ทผ ์ ์ด์๋ default๋ณด๋ค ์ฐ์ ์์๊ฐ ๋์ต๋๋ค.
- ํด๋น ๋ฉค๋ฒ๋ ๋์ผํ ํจํค์ง ๋ด์์๋ ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ฉฐ, ํ์ ํด๋์ค์์๋ ์ ๊ทผ์ด ๊ฐ๋ฅํฉ๋๋ค. ํ์ง๋ง ์ธ๋ถ ํจํค์ง์์๋ ์ง์ ์ ๊ทผํ ์ ์์ต๋๋ค.
- public:
- public ์ ๊ทผ ์ ์ด์๋ ๊ฐ์ฅ ๋ฎ์ ์ฐ์ ์์๋ฅผ ๊ฐ์ง๋๋ค.
- ํด๋น ๋ฉค๋ฒ๋ ์ด๋์๋ ์ง ์ ๊ทผ์ด ๊ฐ๋ฅํฉ๋๋ค.
9. ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ 4๊ฐ์ง ํน์ฑ
- ์บก์ํ (Encapsulation):
- ์บก์ํ๋ ๊ฐ์ฒด์ ์ํ(๋ฐ์ดํฐ)์ ํ์(๋ฉ์๋)๋ฅผ ํ๋๋ก ๋ฌถ๊ณ , ์ธ๋ถ์์ ์ง์ ์ ๊ทผํ์ง ๋ชปํ๋๋ก ์ ๋ณด๋ฅผ ์๋ํ๋ ๊ฒ์ ๋งํ๋ค.
- ๊ฐ์ฒด ๋ด๋ถ์ ์ํ๋ฅผ ๋ณดํธํ๊ณ ์ธ๋ถ์์๋ ๊ฐ์ฒด์ ํน์ ๋ฉ์๋๋ฅผ ํตํด์๋ง ์ํธ์์ฉํ ์ ์๋๋ก ํ๋๋ฐ ์ค์
- ์ ๋ณด ์๋์ ํตํด ๊ฐ์ฒด์ ๋ด๋ถ ๊ตฌํ์ ๋ณ๊ฒฝํ๋๋ผ๋ ์ธ๋ถ์์๋ ์ํฅ์ ๋ฐ์ง ์๋๋ก ํ๋ค.
- ์์ (Inheritance):
- ์์์ ๋ถ๋ชจ ํด๋์ค(์ํผ ํด๋์ค)์ ํน์ง๊ณผ ๊ธฐ๋ฅ์ ์์ ํด๋์ค(์๋ธ ํด๋์ค)๊ฐ ๋ฌผ๋ ค๋ฐ๋ ๊ฒ์ ๋งํ๋ค
- ์ฝ๋์ ์ฌ์ฌ์ฉ์ฑ์ ๋์ฌ์ฃผ๊ณ , ๊ณ์ธต ๊ตฌ์กฐ๋ฅผ ํตํด ์ํํธ์จ์ด์ ๊ตฌ์กฐ๋ฅผ ์ดํดํ๊ธฐ ์ฝ๊ฒ ๋ง๋ ๋ค.
- ์๋ธ ํด๋์ค๋ ์ํผ ํด๋์ค์ ๋ฉ์๋๋ฅผ ์ฌ์ ์(์ค๋ฒ๋ผ์ด๋ฉ)ํ๊ฑฐ๋ ์๋ก์ด ๋ฉ์๋๋ฅผ ์ถ๊ฐํ ์ ์๋ค.
- ๋คํ์ฑ (Polymorphism):
- ๋คํ์ฑ์ ๋์ผํ ์ด๋ฆ์ ๋ฉ์๋๋ ์ฐ์ฐ์๊ฐ ๋ค์ํ ์ํฉ์์ ๋ค๋ฅด๊ฒ ๋์ํ ์ ์๋ ๋ฅ๋ ฅ์ ๋งํ๋ค.
- ๋ฉ์๋ ์ค๋ฒ๋ก๋ฉ๊ณผ ๋ฉ์๋ ์ค๋ฒ๋ผ์ด๋ฉ์ ํตํด ๋คํ์ฑ์ ๊ตฌํ
- ๋คํ์ฑ์ ์ฝ๋์ ๊ฐ๋ ์ฑ์ ๋์ด๊ณ ์ ์ง๋ณด์๋ฅผ ์ฉ์ดํ๊ฒ ๋ง๋ค์ด์ค๋ค.
- ์ถ์ํ (Abstraction):
- ์ถ์ํ๋ ๊ฐ์ฒด๊ฐ ๊ฐ๋ ๊ณตํต์ ์ธ ํน์ฑ์ ์ถ์ถํ์ฌ ๋ชจ๋ธ๋งํ๋ ๊ณผ์ ์ด๋ฉฐ, ์ค์ ์ธ๊ณ์ ๋ณต์กํ ์์คํ ์ ๋จ์ํํ๋ ๊ฐ๋
- ํด๋์ค์ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ์ฌ ์ถ์ํ๋ฅผ ๊ตฌํํ๋ฉฐ, ํ์ํ ๋ถ๋ถ๋ง์ ํํํ๊ณ ๋๋จธ์ง๋ ๊ฐ์ถ๋ค.
- ์ถ์ํ๋ฅผ ํตํด ๊ฐ๋ฐ์๋ ํต์ฌ ๊ธฐ๋ฅ์ ์ง์คํ ์ ์๊ณ , ์ฌ์ฉ์๋ ๊ฐ๋จํ ์ธํฐํ์ด์ค๋ฅผ ํตํด ์์คํ ์ ์ฌ์ฉํ ์ ์๋ค.
10. ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ 5๊ฐ์ง ์์น
- ์ํํธ์จ์ด ๋์์ธ์ ํต์ฌ, ์ด๋ฅผ 'SOLID'์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค.
- ๋จ์ผ ์ฑ
์ ์์น (Single Responsibility Principle, SRP):
- ํ ํด๋์ค๋ ๋จ ํ๋์ ์ฑ ์๋ง ๊ฐ์ ธ์ผ ํ๋ค.
- ํด๋์ค๊ฐ ์ฌ๋ฌ ์ฑ ์์ ๊ฐ์ง๊ฒ ๋๋ฉด ์ฝ๋์ ์๋๋ฅผ ํ์ ํ๊ธฐ ์ด๋ ค์์ง๊ณ , ์ ์ง๋ณด์๊ฐ ์ด๋ ต๋ค.
- ๊ฐ๋ฐฉ-ํ์ ์์น (Open-Closed Principle, OCP):
- ์ํํธ์จ์ด์ ๊ตฌ์ฑ ์์(ํด๋์ค, ๋ชจ๋, ํจ์ ๋ฑ)๋ ํ์ฅ์๋ ์ด๋ ค ์์ด์ผ ํ์ง๋ง, ๋ณ๊ฒฝ์๋ ๋ซํ ์์ด์ผ ํ๋ค.
- ๊ธฐ์กด์ ์ฝ๋๋ฅผ ์์ ํ์ง ์๊ณ ๋ ์๋ก์ด ๊ธฐ๋ฅ์ ์ถ๊ฐํ ์ ์์ด์ผ ํ๋ค.
- ๋ฆฌ์ค์ฝํ ์นํ ์์น (Liskov Substitution Principle, LSP):
- ํ์ ํ์ (์๋ธ ํด๋์ค)์ ์์ ํ์ (์ํผ ํด๋์ค)์ ๋์ฒดํ ์ ์์ด์ผ ํ๋ค.
- ์ฆ, ์์ ๊ด๊ณ์์๋ ํ์ ํด๋์ค๋ ์์ ํด๋์ค์ ํธํ์ฑ์ด ์์ด์ผ ํ๋ฉฐ, ์์ ํด๋์ค์ ๊ธฐ๋ฅ์ ํฌํจํด์ผ ํ๋ค.
- ์ธํฐํ์ด์ค ๋ถ๋ฆฌ ์์น (Interface Segregation Principle, ISP):
- ํด๋ผ์ด์ธํธ๋ ์์ ์ด ์ฌ์ฉํ์ง ์๋ ๋ฉ์๋์ ์์กด ๊ด๊ณ๋ฅผ ๋งบ์ผ๋ฉด ์ ๋๋ค.
- ์ฆ, ํด๋ผ์ด์ธํธ๋ ์์ ์ด ํ์๋ก ํ๋ ๋ฉ์๋๋ง์ ํฌํจํ๋ ์ธํฐํ์ด์ค์ ๊ด๊ณ๋ฅผ ๋งบ์ด์ผ ํ๋ค.
- ์์กด ์ญ์ ์์น (Dependency Inversion Principle, DIP):
- ๊ณ ์์ค ๋ชจ๋์ ์ ์์ค ๋ชจ๋์ ์์กดํด์๋ ์ ๋๋ฉฐ, ๋ ๋ชจ๋ ์ถ์ํ์ ์์กดํด์ผ ํ๋ค.
- ์ถ์ํ๋ ์ธํฐํ์ด์ค๋ฅผ ํตํด ์์กด ๊ด๊ณ๋ฅผ ๋ง๋ค์ด์ผ ํ๋ฉฐ, ๊ตฌ์ฒด์ ์ธ ๊ตฌํ์ ์์กดํ์ง ์์์ผ ํ๋ค.
'๐ Language > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java - Hibernate] ORM, ์์์ฑ, ์์์ฑ ์ปจํ ์คํธ๋ ๋ฌด์์ธ๊ฐ? (0) | 2024.01.22 |
---|---|
[Java] Hibernate๋? (0) | 2024.01.22 |
[Java] JVM(Java Virtual Machine) ์ด๋? (0) | 2024.01.13 |