Interpreter - wzorzec projektowy (design pattern)

I. Wzorce kreacyjne
1. Singleton
2. Budowniczy
3. Prototyp
4. Fabryka
5. Fabryka abstrakcyjna
II. Wzorce strukturalne
1. Adapter
2. Most
3. Kompozyt
4. Dekorator
5. Fasada
6. Pyłek
7. Pełnomocnik
III. Wzorce czynnościowe
1. Łańcuch zobowiązań
2. Polecenie
3. Interpreter
4. Iterator
5. Mediator
6. Pamiątka
7. Obserwator
8. Stan
9. Strategia
10. Metoda szablonowa
11. Odwiedzający

Interpreter - wzorzec projektowy (design pattern) - java

1. Cel:
Wzorzec Interpreter używamy do reprezentowania gramatyki języka.
Wiele narzędzi używa tego wzorca podczas analizowania różnych aspektów gramatyki.
2. Problem:
Mamy do zinterpretowania gramatykę, może to być notacja muzyczna
lub równania matematyczne, lub nawet w inny język.
Kompilatory często używają wzorca Interpreter by analizować kod źródłowy.
Na przykład kompilator javy interpretuje kod źródłowy do kodu bitowego.
Interpretor to tłumasz, translator.
Google translator to drugi przykład wzorca interpretor.

3. Rozwiązanie:
Implentujemy abstrakcyjne wyrażenie (expression) do wykonania operacji.
Ta operacja to metoda do interpretacji.
Wyrażenie jest podziezlone na wyrażenie końcowe (terminal expression) które jest liściem drzewa,
lub po prostu nie zawiera innego wyrażenia oraz wyrażenia które nie są końcowe
tzn. złożone z co najmniej jednego, które jest wykonane rekursywnie dopóki będzie końcowe.
Tworzymy jedną klase per role.

4. Diagram klas wzorca Interpreter:

5. Implementacja:
Klasa testująca:

public class InterpreterTest {
 
   //Rola: Mateusz i Tomasz są mężczyznami
   public static Expression getMaleExpression(){
      Expression mateusz = new TerminalExpression("Mateusz");
      Expression tomasz = new TerminalExpression("Tomasz");
      return new OrExpression(mateusz, tomasz);		
   }
 
   //Rola: Julia jest żoną
   public static Expression getMarriedWomanExpression(){
      Expression julia = new TerminalExpression("Julia");
      Expression żona = new TerminalExpression("żona");
      return new AndExpression(julia, żona);		
   }
 
   public static void main(String[] args) {
      Expression isMale = getMaleExpression();
      Expression isMarriedWoman = getMarriedWomanExpression();
 
      System.out.println("John is male? " + isMale.interpret("John"));
      System.out.println("Julia to żona Mateusza" ? " + isMarriedWoman.interpret("Julia to żona Mateusza"));
   }
}

Implementacja wzorca:

public interface Expression {
   public boolean interpret(String context);
}
 
public class TerminalExpression implements Expression {
 
   private String data;
 
   public TerminalExpression(String data){
      this.data = data; 
   }
 
   @Override
   public boolean interpret(String context) {   
      return context.contains(data);
   }
}
 
public class OrExpression implements Expression {
 
   private Expression expr1;
   private Expression expr2;
 
   public OrExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }
 
   @Override
   public boolean interpret(String context) {		
      return expr1.interpret(context) || expr2.interpret(context);
   }
}
 
public class AndExpression implements Expression {
 
   private Expression expr1;
   private Expression expr2;
 
   public AndExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }
 
   @Override
   public boolean interpret(String context) {		
      return expr1.interpret(context) && expr2.interpret(context);
   }
}

6. Zastosowanie w kodzie java:
- java.util.Pattern
- java.text.Normalizer
- java.text.Format