:: Enseignements :: Licence :: L3 :: 2020-2021 :: Programmation Objet avec Java ::

Interface, record, sealed

Exercice 1 - Arbre d'expressions

Le but de cet exercice est de construire un parseur d'expressions arithmétiques simples. Ces expressions sont représentées sous forme d'arbres.
L'ensemble des classes devront être définies dans le paquetage fr.umlv.calc si aucun paquetage n'est indiqué.

La classe OpOrValue définit des objets qui peuvent être soit des valeurs soit des opérations (avec un membre gauche et un membre droit).

Quel est le bug avec les constructeurs dans OpOrValue ?
Si vous ne voyez pas, utiliser javap sur OpOrValue.class
En fait, le record OpOrValue représente une expression qui est soit une valeur, soit l'opérateur ADD, soit l'opérateur SUB. On pourait donc l'écrire ainsi :
```
        Expr := Value | Add | Sub
      
```
Comment représente-t-on un "ou" entre plusieurs types en Java ?
Pourquoi est-ce une meilleure représentation que OpOrValue ?

On va créer Expr dans un fichier Expr.java avec le main suivant

       static void main(String[] args) {
         Expr expression = new Add(new Value(2), new Value(3));
         Expr expression2 = new Sub(new Add(new Value(2), new Value(3)), new Value(4));
       }

Et pour Value, Add et Sub, on utilisera des records chacun dans son propre fichier .java.
Créer les records avec leurs composants nécessaires pour que le main compile.

On peut noter qu'il n'y a rien qui empêche quelqu'un d'autre que le créateur de Expr de créer un sous-type de Expr (un autre record). Pour limiter cette possibilité, ajouter ce qu'il faut dans le code pour en empêcher que Expr puisse être autre chose qu'un Value, Add ou Sub.
En fait, les records n'ont pas besoin d'être déclarés dans leur propre fichier .java, il peuvent être tous déclarés dans le fichier Expr.java en tant que membre (attribut) de la classe Expr.
Faire le changement et expliquer pourquoi c'est intéressant.

On souhaite maintenant pouvoir évaluer (trouver la valeur) d'une expression (Expr) en appelant la méthode eval comme ceci

       static void main(String[] args) {
         Expr expression = new Add(new Value(2), new Value(3));
         Expr expression2 = new Sub(new Add(new Value(2), new Value(3)), new Value(4));
         System.out.println(expression2.eval());
       }

Modifier votre code en conséquence.

Écrire une méthode parse qui prend un Scanner en entrée et crée l'arbre d'expression correspondant sachant que l'arbre sera donné au scanner en utilisant la notation préfixe (opérateur devant). Par exemple, au lieu de 2 + 3 - 4, la notation préfixe est - + 2 3 4.
Indication : la méthode parse est naturellement récursive. Si l’expression contient encore des symboles (et qu'elle est bien formée) alors:
- soit le prochain symbole est un opérateur et il faut appeler parse() 2 fois pour obtenir le fils gauche et le fils droit et les combiner avec l'opérateur pour faire une nouvelle expression.
- soit le prochain symbole est un entier et il suffit d'en faire une feuille de l’arbre d'expression,
Enfin, pour rappel, scanner.next() renvoie le prochain mot, Integer.parseInt() permet de savoir si c'est un entier et il est possible d'utiliser le switch expression (le switch qui renvoie une valeur) sur des Strings en Java.
Déplacer le main dans une nouvelle classe Main dans le package fr.umlv.calc.main et faire les changements nécessaires.
Noter que prendre un Scanner en paramètre ne permet pas de ré-utiliser la méthode parse si, par exemple, l'expression à parser est stockée dans une List de String.
Quelle interface que doit-on utiliser à la place de Scanner pour que l'on puisse appeler la méthode parse avec un Scanner ou à partir d'une List.
Écrire la méthode d'affichage de l'arbre d'expression pour que l'affichage se fasse dans l'ordre de lecture habituel.
Note : il va falloir ajouter des parenthèses !
Enfin, on peut voir que le code de eval dans Add et Sub est quasiment identique, dans les deux cas : la méthode eval est appelée sur left et right.
On souhaite factoriser ce code (on ne le ferait probablement pas dans la vraie vie car il n'y a pas assez de code à partager, mais ce n'est pas la vraie vie, c'est un exercice) en introduisant un type intermédiaire BinOp, sous-type de Expr et super-type de Add et Sub.
Le type BinOp doit-il être un record, une classe ou une interface ?
Sachant que l'on veut écrire eval dans BinOp, comment eval doit être déclarée ? Et comment, dans eval de BinOp, peut-on accéder aux champs left et right, qui sont déclarés dans Add et Sub ?
Écrire le code de BinOp et modifier Add et Sub en conséquence.