์ธํฐํ๋ฆฌํฐ ํจํด (Interpreter Pattern)
์ธํฐํ๋ฆฌํฐ ํจํด์ ๋ฌธ๋ฒ ๊ท์น์ ํด๋์คํํ์ฌ ํด์๊ธฐ๋ฅผ ๊ตฌํํ๋ ๋์์ธ ํจํด์
๋๋ค. ์ฃผ๋ก ๊ฐ๋จํ ๋ฌธ๋ฒ์ ํด์ํด์ผ ํ๋ ๊ฒฝ์ฐ์ ์ฌ์ฉ๋๋ฉฐ, ๊ฐ ๋ฌธ๋ฒ ๊ท์น์ ํด๋์ค๋ก ํํํ๊ณ ์ด๋ฅผ ์กฐํฉํ์ฌ ๋ณต์กํ ํด์ ์์
์ ์ํํ ์ ์๊ฒ ํฉ๋๋ค.
์ฃผ์ ๋ชฉ์
โข
ํน์ ์ธ์ด๋ ํํ์์ ๋ฌธ๋ฒ์ ์ ์ํ๊ณ ํด์ํ๋ ๋ฐฉ๋ฒ์ ์ ๊ณต
โข
๋ฌธ๋ฒ ๊ท์น์ ํด๋์ค ๊ตฌ์กฐ๋ก ํํํ์ฌ ํ์ฅ์ฑ๊ณผ ์ ์ง๋ณด์์ฑ ํฅ์
โข
๋ณต์กํ ํด์ ๋ก์ง์ ์์ ๋จ์๋ก ๋ถ๋ฆฌํ์ฌ ๊ด๋ฆฌ
ํน์ง
โข
๊ฐ ๋ฌธ๋ฒ ๊ท์น์ด ๋
๋ฆฝ์ ์ธ ํด๋์ค๋ก ๊ตฌํ๋จ
โข
์๋ก์ด ๋ฌธ๋ฒ ๊ท์น ์ถ๊ฐ๊ฐ ์ฉ์ดํจ
โข
๋ฌธ๋ฒ์ด ๋ณต์กํด์ง์๋ก ํด๋์ค ์๊ฐ ๋ง์์ง ์ ์์
โข
์ฃผ๋ก ๊ฐ๋จํ ๋ฌธ๋ฒ ํด์์ ์ ํฉ
์์ ์ฝ๋
// Abstract Expression
interface Expression {
int interpret();
}
// Terminal Expression
class NumberExpression implements Expression {
private int number;
public NumberExpression(int number) {
this.number = number;
}
public int interpret() {
return number;
}
}
// Non-terminal Expression
class AddExpression implements Expression {
private Expression left;
private Expression right;
public AddExpression(Expression left, Expression right) {
this.left = left;
this.right = right;
}
public int interpret() {
return left.interpret() + right.interpret();
}
}
Java
๋ณต์ฌ
ํฐ๋ฏธ๋ ํํ์
๊ธฐ๋ณธ์ ์ธ ํํ์์ผ๋ก, ๋ ์ด์ ํด์ํ ํ์๊ฐ ์๋ ๊ฐ์ด๋ ์ฐ์ฐ์ ๋ํ๋
๋๋ค.
๋นํฐ๋ฏธ๋ ํํ์
๋ค๋ฅธ ํํ์์ ์กฐํฉํ๊ฑฐ๋ ๋ ๊ฐ ์ด์์ ํฐ๋ฏธ๋ ํํ์์ ๊ฒฐํฉํ์ฌ ์๋ก์ด ํํ์์ ๋ง๋ญ๋๋ค.
โข
ํฐ๋ฏธ๋ ํํ์ (NumberExpression): ์ค์ ๊ฐ(์ซ์)์ ํํํฉ๋๋ค. ํด์์ด ๋๋ ์ํ์์ ๊ฐ์ ๊ทธ๋๋ก ๋ฐํํฉ๋๋ค.
โข
๋ํฐ๋ฏธ๋ ํํ์ (AddExpression): ๋ค๋ฅธ ํํ์๋ค์ ๋ฐ์์ ๊ทธ๋ค์ ๊ฒฐ๊ณผ๋ฅผ ๊ฒฐํฉํ๋ ๋ณตํฉ์ ์ธ ์ฐ์ฐ์ ์ํํฉ๋๋ค. AddExpression์ ๋ ๊ฐ์ ํํ์์ด๋ฏ๋ก, ์ด๋ค์ ํด์ํ์ฌ ๊ทธ ํฉ์ ๋ฐํํฉ๋๋ค.
์ฝ๋ ์ค๋ช
์ ์์ ์ฝ๋๋ ๊ฐ๋จํ ์์ ํด์๊ธฐ๋ฅผ ๊ตฌํํ ๊ฒ์
๋๋ค:
โข
Expression ์ธํฐํ์ด์ค: ๋ชจ๋ ํํ์์ด ๊ตฌํํด์ผ ํ๋ ๊ธฐ๋ณธ ์ธํฐํ์ด์ค๋ฅผ ์ ์ํฉ๋๋ค. interpret() ๋ฉ์๋๋ฅผ ํตํด ํํ์์ ๊ฒฐ๊ณผ๊ฐ์ ๋ฐํํฉ๋๋ค.
โข
NumberExpression ํด๋์ค: ์ซ์๋ฅผ ๋ํ๋ด๋ ํฐ๋ฏธ๋ ํํ์์
๋๋ค. ๋จ์ํ ์ ์ฅ๋ ์ซ์๊ฐ์ ๋ฐํํฉ๋๋ค.
โข
AddExpression ํด๋์ค: ๋ง์
์ฐ์ฐ์ ๋ํ๋ด๋ ๋นํฐ๋ฏธ๋ ํํ์์
๋๋ค. ์ขํญ๊ณผ ์ฐํญ์ interpret() ๊ฒฐ๊ณผ๋ฅผ ๋ํ ๊ฐ์ ๋ฐํํฉ๋๋ค.
์ด๋ฌํ ๊ตฌ์กฐ๋ฅผ ํตํด "3 + 4"์ ๊ฐ์ ๊ฐ๋จํ ์์์ ๋ค์๊ณผ ๊ฐ์ด ํด์ํ ์ ์์ต๋๋ค:
Expression three = new NumberExpression(3);
Expression four = new NumberExpression(4);
Expression add = new AddExpression(three, four);
System.out.println(add.interpret()); // ์ถ๋ ฅ: 7
Java
๋ณต์ฌ