Il Pattern Interpreter fornisce un modo per valutare la grammatica o l’espressione della lingua e per questo motivo rientra nei modelli Comportamentali.
Questo modello prevede l’implementazione di un’interfaccia Espressione che la interpreta in un contesto specifico. Questo tipo di design pattern viene utilizzato ad esempio nel fase di parsing SQL.
DIAGRAMMA UML
IMPLEMENTAZIONE INTERPRETER
Creiamo l’interfaccia Espressione e le classi concrete che la implementano. La classe EspressioneTerminale è definita come principale Interpreter del contesto in questione. Le classi EspressioneAnd ed EspressioneOr verranno utilizzate per creare espressione combinate.
Step 1: Creiamo l’interfaccia Espressione
public interface Espressione {
public boolean interpreta(String contesto);
}
Step 2: Creiamo le classi concrete che la implementano
EspressioneTerminale.java
public class EspressioneTerminale implements Espressione {
private String data;
public EspressioneTerminale(String data){
this.data = data;
}
@Override
public boolean interpreta(String contesto) {
if(contesto.contains(data)){
return true;
}
return false;
}
}
EspressioneAnd.java
public class EspressioneAnd implements Espressione {
private Espressione espr1 = null;
private Espressione espr2 = null;
public EspressioneAnd(Espressione expr1, Espressione expr2) {
this.espr1 = expr1;
this.espr2 = expr2;
}
@Override
public boolean interpreta(String context) {
return espr1.interpreta(context) && espr2.interpreta(context);
}
}
EspressioneOr.java
public class EspressioneOr implements Espressione {
private Espressione expr1 = null;
private Espressione expr2 = null;
public EspressioneOr(Espressione espr1, Espressione espr2) {
this.expr1 = espr1;
this.expr2 = espr2;
}
@Override
public boolean interpreta(String contesto) {
return expr1.interpreta(contesto) || expr2.interpreta(contesto);
}
}
Step 3: Creiamo il main
public class Main {
//Regola: Roberto e Giovanni sono uomini
public static Espressione getUomo(){
Espressione roberto = new EspressioneTerminale("Roberto");
Espressione gianni = new EspressioneTerminale("Gianni");
return new EspressioneOr(roberto, gianni);
}
//Regola: Giulia è sposata
public static Espressione getSposata(){
Espressione giulia = new EspressioneTerminale("Giulia");
Espressione sposata = new EspressioneTerminale("Sposata");
return new EspressioneAnd(giulia, sposata);
}
public static void main(String[] args) {
Espressione isUomo = getUomo();
Espressione isSposata = getSposata();
System.out.println("[MAIN]: Gianni e' uomo? -> " + isUomo.interpreta("Gianni"));
System.out.println("[MAIN]: Giulia e' sposata? -> " + isSposata.interpreta("Giulia Sposata"));
}
}
Step 4: Output
[MAIN]: Gianni e' uomo? -> true
[MAIN]: Giulia e' sposata? -> true
0 Comments