Design Pattern #13 – Interpreter

128 Views 0 Comment

Il Pattern Interpreter fornisce un modo per valutare la grammatica o l’espressione della lingua e per questo motivo rientra nei modelli Comportamentali.

interpreter

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

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

 

LINK UTILI


Continua a seguirci su:

Facebook Instagram Telegram Rss
0 Comments

Leave a Comment