์ํ ํจํด (State Pattern)
๊ฐ์ฒด์ ๋ด๋ถ ์ํ๊ฐ ๋ณ๊ฒฝ๋ ๋ ๊ฐ์ฒด์ ํ๋์ด ๋ฐ๋๋๋ก ํ๋ ํจํด์
๋๋ค. ๋ง์น ๊ฐ์ฒด์ ํด๋์ค๊ฐ ๋ฐ๋๋ ๊ฒ์ฒ๋ผ ๋ณด์
๋๋ค. ๊ฐ ์ํ๋ฅผ ๋ณ๋์ ํด๋์ค๋ก ์บก์ํํ๊ณ , ์ํ์ ๋ฐ๋ฅธ ํ๋์ ๊ฐ ์ํ ํด๋์ค์ ์์ํ์ฌ ์ฝ๋์ ์ ์ง๋ณด์์ฑ๊ณผ ํ์ฅ์ฑ์ ๋์
๋๋ค.
์ฃผ์ ๋ชฉ์
โข
๊ฐ์ฒด์ ์ํ์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ํ๋ํ๋ ๋ก์ง์ ๊ฐ๊ฐ์ ์ํ ํด๋์ค๋ก ๋ถ๋ฆฌ
โข
์๋ก์ด ์ํ๊ฐ ์ถ๊ฐ๋๋๋ผ๋ ๊ธฐ์กด ์ฝ๋์ ๋ณ๊ฒฝ ์์ด ํ์ฅ ๊ฐ๋ฅ
โข
์ํ ์ ํ ๋ก์ง์ ํ ๊ณณ์์ ๊ด๋ฆฌํ์ฌ ๋ณต์ก์ฑ ๊ฐ์
ํน์ง
โข
๊ฐ ์ํ๋ฅผ ๋
๋ฆฝ์ ์ธ ํด๋์ค๋ก ๊ตฌํ
โข
์ปจํ
์คํธ ๊ฐ์ฒด๊ฐ ํ์ฌ ์ํ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐ
โข
์ํ ์ ํ์ด ์์ฐ์ค๋ฝ๊ณ ๋ช
ํํจ
โข
์กฐ๊ฑด๋ฌธ(if-else) ์ฌ์ฉ์ ์ค์ฌ ์ฝ๋ ๊ฐ๋
์ฑ ํฅ์
์์ ์ฝ๋
// State ์ธํฐํ์ด์ค
interface State {
void handle();
}
// ๊ตฌ์ฒด์ ์ธ ์ํ ํด๋์ค๋ค
class StateA implements State {
public void handle() {
System.out.println("์ํ A ์ฒ๋ฆฌ");
}
}
class StateB implements State {
public void handle() {
System.out.println("์ํ B ์ฒ๋ฆฌ");
}
}
// ์ปจํ
์คํธ ํด๋์ค
class Context {
private State state;
public void setState(State state) {
this.state = state;
}
public void request() {
state.handle();
}
}
Java
๋ณต์ฌ
์ฝ๋ ์ค๋ช
์ ์์ ์ฝ๋๋ ์ํ ํจํด์ ๊ธฐ๋ณธ ๊ตฌ์กฐ๋ฅผ ๋ณด์ฌ์ค๋๋ค:
โข
State ์ธํฐํ์ด์ค: ๋ชจ๋ ์ํ๊ฐ ๊ตฌํํด์ผ ํ๋ ๊ณตํต ์ธํฐํ์ด์ค๋ฅผ ์ ์ํฉ๋๋ค. handle() ๋ฉ์๋๋ฅผ ํตํด ์ํ๋ณ ๋์์ ์ํํฉ๋๋ค.
โข
๊ตฌ์ฒด์ ์ธ ์ํ ํด๋์ค (StateA, StateB): State ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ์ฌ ๊ฐ ์ํ์ ํนํ๋ ๋์์ ์ ์ํฉ๋๋ค. ๊ฐ ํด๋์ค๋ ํน์ ์ํ์์์ ํ๋์ ์บก์ํํฉ๋๋ค.
โข
Context ํด๋์ค: ํ์ฌ ์ํ๋ฅผ ๋ํ๋ด๋ State ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ณ ์์ผ๋ฉฐ, ํด๋ผ์ด์ธํธ์ ์์ฒญ์ ํ์ฌ ์ํ ๊ฐ์ฒด์ ์์ํฉ๋๋ค.
์ด๋ฌํ ๊ตฌ์กฐ๋ฅผ ํตํด ์๋ก์ด ์ํ๋ฅผ ์ถ๊ฐํ ๋ ๊ธฐ์กด ์ฝ๋๋ฅผ ์์ ํ์ง ์๊ณ ๋ ์๋ก์ด ์ํ ํด๋์ค๋ง ์ถ๊ฐํ๋ฉด ๋๋ฏ๋ก, ๊ฐ๋ฐฉ-ํ์ ์์น(OCP)์ ๋ง์กฑ์ํต๋๋ค.
ํ์ฉ ์ฌ๋ก
โข
์ํ๊ธฐ์ ๋์ ์ํ ๊ด๋ฆฌ (๋์ ํฌ์
, ์ ํ ์ ํ, ์ ํ ๋ฐฐ์ถ ๋ฑ)
โข
๊ฒ์ ์บ๋ฆญํฐ์ ์ํ ๊ด๋ฆฌ (๋๊ธฐ, ๊ฑท๊ธฐ, ๋ฌ๋ฆฌ๊ธฐ, ์ ํ ๋ฑ)
โข
์ฃผ๋ฌธ ์ฒ๋ฆฌ ์์คํ
์ ์ํ ๊ด๋ฆฌ (์ฃผ๋ฌธ ์ ์, ์ฒ๋ฆฌ ์ค, ๋ฐฐ์ก ์ค, ์๋ฃ ๋ฑ)