Exercice polymorphisme et récursivité expressions arithmétiques

But:
Révisions: Comparaison d'une approche procédurale avec une approche orientée objet
Thème:
Polymorphisme, Récursivité
Fichiers:
Arith.java

Johnny C. est étudiant en première année à l'EPFL. Il doit écrire un programme Java simple permettant d'évaluer des expressions arithmétiques. Ces expressions sont constituées de nombres, d'additions et de multiplications; comme ceci :


	2 + 5 * 3

Johnny n'a pas encore très bien absorbé les concepts orientés objets permis par Java et il produit la solution suivante :

Arith.java

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/** Structure de donnee pour les expressions*/
class Expression {
    public int type;
    public int value;
    public Expression leftOp;
    public Expression rightOp;
 
    public Expression(int type, int value, Expression leftOp, Expression rightOp) {
        this.type = type;
        this.value = value;
        this.leftOp = leftOp;
        this.rightOp = rightOp;
    }
}
 
/** Classe principale */
class Arith {
 
    /** Constantes pour representer les types*/
    public static final int TYPE_NUMBER = 1;
    public static final int TYPE_SUM = 2;
    public static final int TYPE_PROD = 3;
 
    public static void main(String [] args) {
        // construit l'expression 3 + 2 * 5
        Expression term = new Expression(TYPE_SUM, 0,
            new Expression(TYPE_NUMBER, 3, null, null),
            new Expression(TYPE_PROD, 0,
                new Expression(TYPE_NUMBER, 2, null, null),
                new Expression(TYPE_NUMBER, 5, null, null)));
 
        System.out.println(evaluate(term));
    }
 
    /** Evalue recursivement l'expression */
    public static int evaluate(Expression term) {
        switch (term.type) {
            case TYPE_NUMBER:
                return term.value;
            case TYPE_SUM:
                return evaluate(term.leftOp) + evaluate(term.rightOp);
            case TYPE_PROD:
                return evaluate(term.leftOp) * evaluate(term.rightOp);
            default:
                return 0;   //erreur, ne devrait jamais se produire 
 
        }
 
    }
 
}

 

Le programme de Johnny fonctionne, mais est écrit dans un style "procédural" plutôt qu'orienté objet. Il peut donc, à cet égard, être amélioré.

 

  1. Réflechissez à la solution de Johnny et essayez d'expliquer pourquoi elle n'est pas très bonne et comment elle pourrait être améliorée.
  2. Ecrivez une version améliorée (commencez par lire l'intégralité des recommandations avant de commencer à programmer) :
    • Définissez une classe abstraite Expression qui déclarera une méthode abstraite evaluate.
    • Créez des classes distinctes pour chaque type d'expressions (Number, Sum, Product) et faites les hériter de Expression.
    • Vous pouvez éviter de la duplication inutile de code en créeant une classe abstraite intermédiaire BinOp qui contiendra les attributs leftOp et rightOp représentants respectivement les opérandes gauche et droit d'un expression binaire. Faites hériter Sum et Product de Binop.
    • Adaptez la méthode main de la classe principale à votre nouvelle structure.
  3. Pour comparer la solution originale de Johnny à la votre, faites évoluer votre programme dans le sens suivant :
    • Ajouter la possibilité de générer la représentation de votre expression sous la forme d'une chaîne de caractère. Par exemple si votre expression est le nombre 13, cette fonctionalité doit vous retourner la chaîne "13". Si c'est une Sum avec 12 et 13 comme leftOp et rightOp respectivement, la fonctionalité en question devra retourner la chaîne "12 * 13".
    • Ajouter un nouveau type d'expression binaire : Modulo représentant des expressions binaires dont l'évaluation retourne le reste de la division entière de leftOp par rightOp.

 

Portez un regard critique à votre nouvelle version. Si vous avez dû faire du "copier-coller" de portions de votre code pour ajouter ces facilités, c'est qu'il y a encore des problèmes de conception. Essayer de faire en sorte qu'il n'y ait aucune duplication inutile de code.

Une fois satisfait de votre version, essayez d'ajouter les mêmes facilités au programme de Johnny.

Laquelle des deux versions a été la plus facile à modifier ?

Note : cet exercice a essentiellement pour but d'illustrer l'intérêt du polymorphisme. Afin de nous concentrer sur cet aspect nous nous autoriserons quelques "entorses" au principe d'une bonne encapsulation (privacité des attributs). Une fois que vous aurez réussi à produire une solution polymorphique et à en dégager l'intérêt par rapport au code d'origine, le soin vous est laissé de parfaire votre code en vous concentrant cette fois sur son encapsulation.


Le programme de Johnny fonctionne, mais est écrit dans un style "procédural" plutôt qu'orienté objet. Il peut donc, à cet égard, être amélioré.

 

  1. Réflechissez à la solution de Johnny et essayez d'expliquer pourquoi elle n'est pas très bonne et comment elle pourrait être améliorée.
  2. Ecrivez une version améliorée (commencez par lire l'intégralité des recommandations avant de commencer à programmer) :
    • Définissez une classe abstraite Expression qui déclarera une méthode abstraite evaluate.
    • Créez des classes distinctes pour chaque type d'expressions (Number, Sum, Product) et faites les hériter de Expression.
    • Vous pouvez éviter de la duplication inutile de code en créeant une classe abstraite intermédiaire BinOp qui contiendra les attributs leftOp et rightOp représentants respectivement les opérandes gauche et droit d'un expression binaire. Faites hériter Sum et Product de Binop.
    • Adaptez la méthode main de la classe principale à votre nouvelle structure.
  3. Pour comparer la solution originale de Johnny à la votre, faites évoluer votre programme dans le sens suivant :
    • Ajouter la possibilité de générer la représentation de votre expression sous la forme d'une chaîne de caractère. Par exemple si votre expression est le nombre 13, cette fonctionalité doit vous retourner la chaîne "13". Si c'est une Sum avec 12 et 13 comme leftOp et rightOp respectivement, la fonctionalité en question devra retourner la chaîne "12 * 13".
    • Ajouter un nouveau type d'expression binaire : Modulo représentant des expressions binaires dont l'évaluation retourne le reste de la division entière de leftOp par rightOp.

 

Portez un regard critique à votre nouvelle version. Si vous avez dû faire du "copier-coller" de portions de votre code pour ajouter ces facilités, c'est qu'il y a encore des problèmes de conception. Essayer de faire en sorte qu'il n'y ait aucune duplication inutile de code.

Une fois satisfait de votre version, essayez d'ajouter les mêmes facilités au programme de Johnny.

Laquelle des deux versions a été la plus facile à modifier ?

Note : cet exercice a essentiellement pour but d'illustrer l'intérêt du polymorphisme. Afin de nous concentrer sur cet aspect nous nous autoriserons quelques "entorses" au principe d'une bonne encapsulation (privacité des attributs). Une fois que vous aurez réussi à produire une solution polymorphique et à en dégager l'intérêt par rapport au code d'origine, le soin vous est laissé de parfaire votre code en vous concentrant cette fois sur son encapsulation.