Interface, classe abstraite, table de hachage, generics

A partir de ce TD nous allons utiliser un environement de développement (IDE) un peu meilleur que qu'un simple éditeur. Vous avez donc le choix entre eclipse (IBM) ou NetBeans (SUN). Eclipse est plus orienté code avec moins de wizards que Netbeans mais le compilo vous reporte plus de warnings (ce qui est mieux).
Ces deux environnement compilent le code à la voler et générent le bytecode lorsque l'on sauve le fichier (avec control S) et complète le code automatiquement (n'importe où même dans le commentaire) avec control+espace.
En terme d'arganisation des fichiers sur le disque, les deux IDE utilisent le principe de workspace qui est un répertoire contenant un ensemble de projets. Un projet est aussi un répertoire contenant un ensemble de source (dans le répertoire src) et de classes (dans classes). Sous eclipse par défaut, le répertoire contenant les classes s'appele bin mais on peut le changer dans les préférences.

On verra la suites des fonctionnalités de ses environements au fur et à mesure.

Le but de cet exercise est de construire un évaluateur d'expressions arithmétiques simples. Ces expressions sont représentés sous forme d'arbre.

On veut un type commun fr.umlv.calc.Expr représentant des expressions arithmétiques qui peuvent être soit une valeur réelle (de type fr.umlv.calc.Value) soit une opération d'addition (de type fr.umlv.calc.Add) qui permet d'effectuée l'addition de deux expression.
On veut de plus être capable d'évaluer de ces expressions en utilisant la méthode eval().

      Expr value=new Value(7.0);
      System.out.println(value.eval()); // affiche 7.0
      Expr add=new Add(new Value(3.0),value);
      System.out.println(add.eval());   // affiche 10.0
      Expr expr=new Add(new Value(2.0),add);
      System.out.println(expr.eval());  // affiche 12.0
    

1. Ecrire les trois classes Expr, Value et Add et leurs méthodes double eval() ainsi qu'une classe Main de test.
2. Implanter la méthode toString() sur les différentes expressions.
3. Discuter sur le fait de transformer la classe Expr en classe abstraite ou en interface. Faîtes les changements qui s'imposent.
4. Ajouter les classes Mult et Divide permettant d'effectuer respectivement la multiplication et la division. Refactoriser le code pour mettre à un seul endroit les codes communs.
5. Ecrire une classe Main et faites des tests.

Expliquer ce que fait le code suivant :

       import java.util.List;
       import java.util.ArrayList;
       import java.util.LinkedList;
       ...
         public static void main(String[] args) {
           List list;
           if (args.length==0)
             list=new ArrayList();
           else
             list=new LinkedList();

           for(String s:args)
             list.add(s);
         }
       ...
      

1. Quel différence y a t'il entre LinkedList et ArrayList ?
2. A quoi sert l'interface List ?

Le code précédent compile avec un warning, que doit-on faire pour supprimer celui-ci ?
Ré-écrire le code du main en conséquence

De la même façon, transformer le code suivant :

        public static void main(String[] args) {
          List list=new ArrayList();
          Collections.addAll(list,args);

          for(int i=0;i<list.size();i++) {
            String s=(String)list.get(i);
            System.out.printf("%s:%d\n",s,s.length());
          }
        }
      

Quel est l'intérêt des generics en Java ?

On souhaite afficher l'animal préférée de bob, alice ou june.
Alice a pour animal préféré edith le singe.
Bob a pour animal préféré izard le chamoix.
June a pour animal préféré gold le poisson rouge.