Interpreter

์ธํ„ฐํ”„๋ฆฌํ„ฐ ํŒจํ„ด์€ ์ฃผ์–ด์ง„ ์–ธ์–ด(๋˜๋Š” ํ‘œํ˜„์‹)๋ฅผ ํ•ด์„ํ•˜๋Š” ๊ทœ์น™์„ ํด๋ž˜์Šค๋กœ ํ‘œํ˜„ํ•˜์—ฌ, ํ•ด๋‹น ์–ธ์–ด์˜ ๋ฌธ๋ฒ•์„ ํ•ด์„ํ•˜๊ณ  ์‹คํ–‰ํ•  ์ˆ˜ ์žˆ๋„๋ก ํ•˜๋Š” ๋””์ž์ธ ํŒจํ„ด์ž…๋‹ˆ๋‹ค.

          +--------------------------+
          |      Expression          |  <-- ์ธํ„ฐํ”„๋ฆฌํ„ฐ ์ธํ„ฐํŽ˜์ด์Šค
          +--------------------------+
          | + interpret(context)     |
          +--------------------------+
                     โ–ฒ
        โ”Œโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”ดโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”
        โ”‚                         โ”‚
+-------------------+    +-------------------------+
| TerminalExpression|    | NonTerminalExpression   |
|   (์ˆซ์ž, ๋ณ€์ˆ˜ ๋“ฑ)  |    |  (์—ฐ์‚ฐ์ž ๋“ฑ ๋ณตํ•ฉ ํ‘œํ˜„)    |
+-------------------+    +-------------------------+
| + interpret()     |    | + interpret()           |
+-------------------+    +-------------------------+

ํ‘œํ˜„์‹(๋ฌธ๋ฒ• ๊ทœ์น™)์„ ์บก์Аํ™”ํ•œ ๊ฐ์ฒด๋“ค(TerminalExpression, NonTerminalExpression)์„ ์‚ฌ์šฉํ•˜์—ฌ ๋ณต์žกํ•œ ์–ธ์–ด๋ฅผ ํŒŒ์‹ฑํ•˜๊ณ  ํ•ด์„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

  • ํƒ€๊ฒŸ(Target): ํด๋ผ์ด์–ธํŠธ๊ฐ€ ์‚ฌ์šฉํ•˜๋Š” ์ธํ„ฐํŽ˜์ด์Šค์ž…๋‹ˆ๋‹ค.

  • ์–ด๋Œ‘ํ‹ฐ(Adaptee): ๊ธฐ์กด์— ์กด์žฌํ•˜๋Š”, ์›ํ•˜๋Š” ์ธํ„ฐํŽ˜์ด์Šค์™€ ๋‹ค๋ฅธ ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ๊ฐ€์ง„ ํด๋ž˜์Šค์ž…๋‹ˆ๋‹ค.

  • ์–ด๋Œ‘ํ„ฐ(Adapter): ์–ด๋Œ‘ํ‹ฐ์˜ ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ํƒ€๊ฒŸ ์ธํ„ฐํŽ˜์ด์Šค๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ํด๋ž˜์Šค์ž…๋‹ˆ๋‹ค.


How do code

import java.util.Map;

// Expression ์ธํ„ฐํŽ˜์ด์Šค: ํ•ด์„ ๋ฉ”์„œ๋“œ๋ฅผ ์ •์˜
public interface Expression {
    int interpret(Map<String, Integer> context);
}

// TerminalExpression: ์ˆซ์ž์™€ ๋ณ€์ˆ˜ ๋“ฑ์˜ ํ„ฐ๋ฏธ๋„ ํ‘œํ˜„์‹์„ ๊ตฌํ˜„
public class NumberExpression implements Expression {
    private int number;

    public NumberExpression(int number) {
        this.number = number;
    }

    @Override
    public int interpret(Map<String, Integer> context) {
        return number;
    }
}

// NonTerminalExpression: ๋‘ Expression์„ ๋”ํ•˜๋Š” ๋ง์…ˆ ํ‘œํ˜„์‹์„ ๊ตฌํ˜„
public class AddExpression implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;

    public AddExpression(Expression left, Expression right) {
        this.leftExpression = left;
        this.rightExpression = right;
    }

    @Override
    public int interpret(Map<String, Integer> context) {
        // ์™ผ์ชฝ๊ณผ ์˜ค๋ฅธ์ชฝ ํ‘œํ˜„์‹์„ ํ•ด์„ํ•˜์—ฌ ๊ฒฐ๊ณผ๋ฅผ ๋”ํ•จ
        return leftExpression.interpret(context) + rightExpression.interpret(context);
    }
}
  • Expression ์ธํ„ฐํŽ˜์ด์Šค: ๋ชจ๋“  ํ•ด์„ ๋Œ€์ƒ(๋ฌธ๋ฒ• ์š”์†Œ)์ด ๊ตฌํ˜„ํ•ด์•ผ ํ•˜๋Š” ์ธํ„ฐํŽ˜์ด์Šค๋กœ, interpret() ๋ฉ”์„œ๋“œ๋ฅผ ํ†ตํ•ด ํ•ด์„ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

  • TerminalExpression (NumberExpression): ์ˆซ์ž๋‚˜ ๋ณ€์ˆ˜์™€ ๊ฐ™์ด ๋” ์ด์ƒ ๋ถ„ํ•ดํ•  ์ˆ˜ ์—†๋Š” ๊ธฐ๋ณธ ์š”์†Œ๋ฅผ ํ‘œํ˜„ํ•ฉ๋‹ˆ๋‹ค. ์ด ์˜ˆ์ œ์—์„œ๋Š” ์ˆซ์ž ๊ฐ’์„ ๋‹จ์ˆœํžˆ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

  • NonTerminalExpression (AddExpression): ๋‘ ๊ฐœ์˜ Expression ๊ฐ์ฒด๋ฅผ ๊ฒฐํ•ฉํ•˜์—ฌ ์—ฐ์‚ฐ(์—ฌ๊ธฐ์„œ๋Š” ๋ง์…ˆ)์„ ์ˆ˜ํ–‰ํ•ฉ๋‹ˆ๋‹ค. ๋‚ด๋ถ€์ ์œผ๋กœ ์™ผ์ชฝ๊ณผ ์˜ค๋ฅธ์ชฝ Expression์„ ํ•ด์„ํ•˜์—ฌ ๊ฒฐ๊ณผ๋ฅผ ๊ฒฐํ•ฉํ•ฉ๋‹ˆ๋‹ค.

  • Context: ํ•ด์„ ์‹œ ํ•„์š”ํ•œ ์™ธ๋ถ€ ์ •๋ณด๋ฅผ ๋‹ด์€ ๊ฐ์ฒด(์—ฌ๊ธฐ์„œ๋Š” ๋ณ€์ˆ˜ ๊ฐ’ ๋“ฑ)๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ์˜ˆ์ œ์—์„œ๋Š” ์‚ฌ์šฉํ•˜์ง€ ์•Š์•˜์ง€๋งŒ, ๋ณต์žกํ•œ ์–ธ์–ด๋ฅผ ํ•ด์„ํ•  ๋•Œ ๋ณ€์ˆ˜ ๋งคํ•‘ ๋“ฑ์„ ์œ„ํ•ด ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.

Last updated