El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Interpreter

Següent ►
►

Introducció

El patró de disseny Interpreter és un patró de comportament que proporciona una manera d'avaluar sentències en un llenguatge. Aquest patró és útil quan es necessita interpretar expressions en un llenguatge específic, com ara expressions matemàtiques, expressions lògiques o fins i tot llenguatges de programació petits.

Objectius del Mòdul

  • Entendre el concepte i la motivació darrere del patró Interpreter.
  • Aprendre a implementar el patró Interpreter.
  • Veure exemples pràctics d'ús del patró Interpreter.
  • Realitzar exercicis pràctics per reforçar els conceptes apresos.

Conceptes Clau

  • Context: Manté la informació global que és compartida per les expressions.
  • Expressió Abstracta: Declara una interfície per interpretar el context.
  • Expressió Terminal: Implementa una operació d'interpretació associada a símbols terminals en la gramàtica.
  • Expressió No Terminal: Implementa una operació d'interpretació associada a símbols no terminals en la gramàtica.

Implementació del Patró Interpreter

Diagrama UML

Diagrama UML del Patró Interpreter

Components

  1. Context: Manté informació que és global per a totes les expressions.
  2. AbstractExpression: Declara una interfície per interpretar el context.
  3. TerminalExpression: Implementa una operació d'interpretació associada a símbols terminals en la gramàtica.
  4. NonTerminalExpression: Implementa una operació d'interpretació associada a símbols no terminals en la gramàtica.

Exemple Pràctic

Suposem que volem interpretar expressions matemàtiques simples com "3 + 5 - 2".

Pas 1: Definir la Interfície d'Expressió

interface Expression {
    int interpret();
}

Pas 2: Implementar Expressions Terminals

class Number implements Expression {
    private int number;

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

    @Override
    public int interpret() {
        return this.number;
    }
}

Pas 3: Implementar Expressions No Terminals

class Add implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;

    public Add(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }

    @Override
    public int interpret() {
        return leftExpression.interpret() + rightExpression.interpret();
    }
}

class Subtract implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;

    public Subtract(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }

    @Override
    public int interpret() {
        return leftExpression.interpret() - rightExpression.interpret();
    }
}

Pas 4: Utilitzar el Patró Interpreter

public class InterpreterDemo {
    public static void main(String[] args) {
        Expression expression = new Subtract(
            new Add(new Number(3), new Number(5)),
            new Number(2)
        );

        int result = expression.interpret();
        System.out.println("Resultat: " + result); // Resultat: 6
    }
}

Exercicis Pràctics

Exercici 1: Implementar Multiplicació i Divisió

Implementa les classes Multiply i Divide per afegir funcionalitat de multiplicació i divisió a l'exemple anterior.

Solució

class Multiply implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;

    public Multiply(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }

    @Override
    public int interpret() {
        return leftExpression.interpret() * rightExpression.interpret();
    }
}

class Divide implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;

    public Divide(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }

    @Override
    public int interpret() {
        return leftExpression.interpret() / rightExpression.interpret();
    }
}

Exercici 2: Crear una Expressió Complexa

Utilitza les classes Add, Subtract, Multiply, i Divide per crear i interpretar l'expressió (3 + 5) * (10 / 2).

Solució

public class InterpreterComplexDemo {
    public static void main(String[] args) {
        Expression expression = new Multiply(
            new Add(new Number(3), new Number(5)),
            new Divide(new Number(10), new Number(2))
        );

        int result = expression.interpret();
        System.out.println("Resultat: " + result); // Resultat: 40
    }
}

Errors Comuns i Consells

  • Error Comú: No gestionar correctament les divisions per zero.

    • Consell: Assegura't de validar les entrades abans de realitzar operacions de divisió.

  • Error Comú: No seguir una estructura clara per a les expressions terminals i no terminals.

    • Consell: Mantén una clara separació entre les classes que representen expressions terminals i no terminals.

Resum

En aquest mòdul, hem après sobre el patró de disseny Interpreter, la seva motivació i com implementar-lo. Hem vist exemples pràctics i hem realitzat exercicis per reforçar els conceptes apresos. Aquest patró és especialment útil per interpretar llenguatges específics i expressions complexes de manera estructurada i reutilitzable.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats