Visiteurs et expressions arithmétiques1#1

On doit représenter les expressions arithmétiques et effectuer un certain nombre de traitements sur celles-ci, par exemple, les évaluer, les imprimer de façon infixe, ou suffixe, etc. Une expression est soit une constante, soit l'addition de deux expressions, soit la multiplication de deux expressions, etc. On transcrit cette définition en une hiérarchie de types : le type parent est une interface Expr, qui est réalisée par des classes concrètes Const, Plus, Mult, etc. Supposons ces types définis ; il sera naturel de construire, par exemple, l'objet suivant :

    Expr expr =                         // expr = 2 + (3+6)
      new Plus(new Const(2), 
               new Plus(new Const(3),
                        new Const(6)));

Les classes concrètes Const, Plus, etc., sont des réalisations de l'interface Expr :

interface Expr {
  ...
}

class Const implements Expr {
  private int c;
  Const(int c) {
    this.c = c;
  }
   ...
}

class Plus implements Expr {
  private Expr expr1, expr2;
  Plus(Expr expr1, Expr expr2) {
    this.expr1 = expr1;
    this.expr2 = expr2;
  }
   ...
}

Une façon de procéder est de déclarer des méthodes d'évaluation (éval) et d'affichage (infixe) dans l'interface Expr et de les définir dans ses réalisations.

    Expr expr = ...                      // expr = 2 + (3+6)
    Object valeur = expr.éval();         // valeur = 11
    Object chaine = expr.infixe();       // chaine = "2+(3+6)"

interface Expr {
  int éval();
  String infixe();
}

class Const implements Expr {
  // ...
  public int éval() {
    return c;
  }
  public String infixe() {
    return new String(c);
  }
}

class Plus implements Expr {
  // ...
  public int éval() {
    return expr1.éval() + expr2.éval();
  }
  public String infixe() {
    return expr1.infixe() + " + " + expr2.infixe();
  }

}