์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | ||||
4 | 5 | 6 | 7 | 8 | 9 | 10 |
11 | 12 | 13 | 14 | 15 | 16 | 17 |
18 | 19 | 20 | 21 | 22 | 23 | 24 |
25 | 26 | 27 | 28 | 29 | 30 | 31 |
- GoogleLogin
- Jenkins
- oauth
- @scheduler
- Java
- spring
- docker
- node.js mysql ์ฐ๋
- spring scheduler
- ํฐ์คํ ๋ฆฌ์ฑ๋ฆฐ์ง
- Node.js
- MySQL
- Personal Access Token
- ์ฝํ
- ๋ ผ๋ธ๋กํน
- ํฌ๋ก์ค์ฌ์ดํธ ์คํฌ๋ฆฝํธ
- ์ฝ๋ฉํ ์คํธ
- ๋์์ธํจํด
- SpringBoot
- ์๊ณ ๋ฆฌ์ฆ
- db์ํคํ ์ณ
- db์ ๋ต
- React
- dockerhub
- ์๋ฐ
- injection๊ณต๊ฒฉ
- ์ค๋ธ์
- CICD
- docker network
- java์ฑํ
- Today
- Total
<Hello Hosung๐/>
[Java] ๋์์ธ ํจํด ๋ณธ๋ฌธ
[Java] ๋์์ธ ํจํด
์ข์ถฉ์ฐ๋ ๋ฐฑ์๋ ๊ฐ๋ฐ์ ์ผ๊ธฐ๐ง 2024. 11. 14. 23:25๋์์ธ ํจํด์ด๋ ?
๋์์ธ ํจํด์ ์ํํธ์จ์ด ๊ฐ๋ฐ์์ ์์ฃผ ๋ฐ์ํ๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ์ฌ์ฌ์ฉ ๊ฐ๋ฅํ ์๋ฃจ์ ์ ๋๋ค. ๋์์ธ ํจํด์ ํน์ ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ด๋ฏธ ๊ฒ์ฆ๋ ๋ฐฉ๋ฒ์ ์ ์ํ๋ฉฐ, ์ด๋ฅผ ํตํด ์ฝ๋์ ํจ์จ์ฑ๊ณผ ์ ์ง ๋ณด์์ฑ์ ๋์ผ ์ ์์ต๋๋ค.
๋์์ธ ํจํด์ ๋ถ๋ฅ
๋์์ธ ํจํด์ ์ผ๋ฐ์ ์ผ๋ก ์ธ ๊ฐ์ง ์ฃผ์ ๋ฒ์ฃผ๋ก ๋๋ ์ง๋๋ค:
์์ฑ ํจํด (Creational Patterns): ๊ฐ์ฒด ์์ฑ๊ณผ ๊ด๋ จ๋ ํจํด
๊ตฌ์กฐ์ ํจํด (Structural Patterns): ํด๋์ค์ ๊ฐ์ฒด์ ๊ด๊ณ๋ฅผ ์กฐ์งํ๋ ํจํด
ํ๋ ํจํด (Behavioral Patterns): ๊ฐ์ฒด ๊ฐ์ ์ํธ์์ฉ๊ณผ ์ฑ
์์ ์ ์ํ๋ ํจํด
์์ฃผ ์ฌ์ฉ๋๋ ์๋ฐ ๋์์ธ ํจํด
(1) ์ฑ๊ธํค ํจํด (Singleton Pattern)
๋ชฉ์ : ํด๋์ค์ ์ธ์คํด์ค๊ฐ ํ๋๋ง ์กด์ฌํ๋๋ก ๋ณด์ฅํ๊ณ , ์ ์ญ ์ ๊ทผ์ ์ ์ ๊ณตํ๋ ํจํด.
์ฌ์ฉ ์์: ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๊ฒฐ, ์ค์ ํด๋์ค ๋ฑ ํ๋์ ์ธ์คํด์ค๋ง ํ์ํ ๋ ์ฌ์ฉ.
public class Singleton {
private static Singleton instance;
private Singleton() { }
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
(2) ํฉํ ๋ฆฌ ํจํด (Factory Pattern)
๋ชฉ์ : ๊ฐ์ฒด ์์ฑ์ ์๋ธํด๋์ค์์ ๊ฒฐ์ ํ๊ฒ ํ์ฌ, ๊ฐ์ฒด ์์ฑ ์ฝ๋๋ฅผ ์บก์ํํ๋ ํจํด.
์ฌ์ฉ ์์: ๊ฐ์ฒด ์์ฑ ๊ณผ์ ์ด ๋ณต์กํ๊ฑฐ๋, ๊ฐ์ฒด ์ ํ์ด ์์ฃผ ๋ณ๊ฒฝ๋ ๋ ์ ์ฉ.
public interface Animal {
void speak();
}
public class Dog implements Animal {
public void speak() {
System.out.println("Woof!");
}
}
public class Cat implements Animal {
public void speak() {
System.out.println("Meow!");
}
}
public class AnimalFactory {
public static Animal getAnimal(String type) {
if ("dog".equalsIgnoreCase(type)) {
return new Dog();
} else if ("cat".equalsIgnoreCase(type)) {
return new Cat();
}
return null;
}
}
(3) ์ต์ ๋ฒ ํจํด (Observer Pattern)
๋ชฉ์ : ๊ฐ์ฒด์ ์ํ ๋ณํ์ ๋ํด ์์กดํ๋ ๋ค๋ฅธ ๊ฐ์ฒด๋ค์ ์๋์ผ๋ก ์๋ฆผ์ ๋ณด๋ด๋ ํจํด.
์ฌ์ฉ ์์: ์ด๋ฒคํธ ์ฒ๋ฆฌ ์์คํ
, GUI์์ ์ฌ์ฉ์ ์ธํฐํ์ด์ค ์
๋ฐ์ดํธ ๋ฑ.
import java.util.ArrayList;
import java.util.List;
interface Observer {
void update(String message);
}
class ConcreteObserver implements Observer {
private String name;
public ConcreteObserver(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name + " received message: " + message);
}
}
class Subject {
private List<Observer> observers = new ArrayList<>();
public void addObserver(Observer observer) {
observers.add(observer);
}
public void notifyObservers(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
}
(4) ์คํธ๋ํฐ์ง ํจํด (Strategy Pattern)
๋ชฉ์ : ์๊ณ ๋ฆฌ์ฆ์ ํด๋์ค์ ์บก์ํํ์ฌ ๋์ ์ผ๋ก ๊ต์ฒดํ ์ ์๊ฒ ํด์ฃผ๋ ํจํด.
์ฌ์ฉ ์์: ๊ณ์ฐ๊ธฐ ํ๋ก๊ทธ๋จ, ์ ๋ ฌ ๋ฐฉ์ ์ ํ ๋ฑ.
public interface Strategy {
int execute(int a, int b);
}
class AddStrategy implements Strategy {
public int execute(int a, int b) {
return a + b;
}
}
class SubtractStrategy implements Strategy {
public int execute(int a, int b) {
return a - b;
}
}
class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public int executeStrategy(int a, int b) {
return strategy.execute(a, b);
}
}
๋์์ธ ํจํด์ ์ฅ์
์ฌ์ฌ์ฉ์ฑ: ์ด๋ฏธ ๊ฒ์ฆ๋ ํด๊ฒฐ์ฑ
์ ์ฌ์ฌ์ฉํจ์ผ๋ก์จ ๊ฐ๋ฐ ์๋๋ฅผ ํฅ์์ํฌ ์ ์์ต๋๋ค.
์ ์ง๋ณด์์ฑ: ์ฝ๋๊ฐ ๋ช
ํํ๊ฒ ๊ตฌ์กฐํ๋์ด ์ ์ง๋ณด์๊ฐ ์ฌ์์ง๋๋ค.
์ ์ฐ์ฑ: ๋ฌธ์ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ฝ๊ฒ ํ์ฅํ๊ฑฐ๋ ๋ณ๊ฒฝํ ์ ์์ต๋๋ค.
๋ง๋ฌด๋ฆฌ
์๋ฐ ๋์์ธ ํจํด์ ์ํํธ์จ์ด ๊ฐ๋ฐ์์ ๋ฐ์ํ๋ ์ฌ๋ฌ ๋ฌธ์ ๋ฅผ ํจ์จ์ ์ผ๋ก ํด๊ฒฐํ ์ ์๋ ๊ฐ๋ ฅํ ๋๊ตฌ์
๋๋ค. ๋ค์ํ ๋์์ธ ํจํด์ ์ ์ ํ ํ์ฉํ๋ฉด, ๋ ๊น๋ํ๊ณ ์ ์ง ๋ณด์๊ฐ ์ฉ์ดํ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค. ๊ฐ ํจํด์ ํน์ง์ ์ ์ดํดํ๊ณ , ์ค์ ํ๋ก์ ํธ์์ ์ ์ ํ ํ์ฉํด ๋ณด์ธ์.
์ด์ ๊ฐ์ ํ์์ผ๋ก ๋ธ๋ก๊ทธ ๊ธ์ ์์ฑํ๋ฉด ๋
์๋ค์ด ๋์์ธ ํจํด์ ์ ์ดํดํ ์ ์์ ๊ฒ์
๋๋ค. ๊ฐ ํจํด์ ๋ชฉ์ ๊ณผ ์ฌ์ฉ ์์๋ฅผ ํตํด ์ค์ ์ฝ๋์์ ์ด๋ป๊ฒ ์ ์ฉ๋ ์ ์๋์ง ๋ณด์ฌ์ฃผ๋ ๊ฒ๋ ์ค์ํฉ๋๋ค.
'๐ป Java > ใ คJava(Basic)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Java] ์ง๋ ฌํ(Serialization)๋? (2) | 2024.11.12 |
---|---|
[Java] ์ธํฐํ์ด์ค๋? (0) | 2024.11.10 |
[Java] ํ์ผ ์ ์ถ๋ ฅ (IO) ์ดํดํ๊ธฐ (1) | 2024.11.09 |
[Java] ์์ผํต์ ์ ๊ธฐ์ด(+์ฑํ ๐ง) (0) | 2024.11.07 |