Design Pattern - Td1 - Eclipse

Le but de ce TD est de vous familiariser avec l'utilisation de l'IDE Eclipse

Exercice 1 - Perspective/Vue, Completion et Template

Lancer eclipse.
Créer un projet java nommé "eclipsedemo" (utiliser le premier icône de la barre d'outil)
Une fois le projet créer, il est possible de voir toutes ces propriétés en utilisant le menu contextuel sur l'item correspondant au projet dans l'arbre de la vue package explorer.
Par défaut, le projet java met à la racine du projet les sources et les classes. Modifier les paramétre de création d'un projet java (dans Window/Preference/Java/Build Path) pour mettre les sources dans "src" et les classes dans "classes" pour les futures projets créés.
Modifier ensuite le projet courant : (sur le projet courant, menu contextuel propertier/Java Build Path) pour avoir la même organisation (regarder les onglets Source et Libraries)

Expliquer ce qu'est une vue, un éditeur et une perspective.

Créer dans le projet un package "fr.umlv.eclipsedemo"
Créer une classe "HelloEcdlipse" possèdant une méthode "main" dans ce package (Penser à sauver la classe)
Par défaut, lors de la création d'une classe et d'une méthode éclipse rajoute des commentaire. Modifier les paramétres par défaut pour retirer ceux-ci (dans Window/Java/Code style/Code templates)
Supprimer la méthode main. Créer celle-ci en utilisant la completion: taper main puis ctrl + espace.
Ecrire un code affichant "hello eclipse" dans la console. (essayer de taper sysout puis ctrl + espace)
Que se passe-t'il lorsque l'on survol avec la souris un appel de méthode (comme println) en maintenant la touche controle appuyée.
Ajouter un template (Window/Preference/Java/Editor/Templates/) nommé "logdebug" qui affiche le nom de la classe et de la méthode. (eclipse1.png)
Dans un terminal, exécuter la classe "HelloEclipse" (attention, les classes sont dans le répertoire "classes")

Expliquer pourquoi il n'est pas nécessaire de compiler avec eclipse.

Exercice 2 - Quickfix et Refactor

Dans le même projet, dans le package "fr.umlv.eclipsedemo", Créer une classe "Stack" implantant les méthodes : "boolcan isEmpty()"/"push(Object o)"/"Object pop()" en utilisant en interne un ArrayList. (au cas où cela serait trop dur : cliquer ici)
Créer un package "fr.umlv.eclipsedemo.util" ; déplacer la classe Stack dans le package créé (par exemple par Glisser-Déplacer).
écrire une classe "Main" dans le package "fr.umlv.eclipsedemo" contenant une méthode "main" créant une pile (Stack) utilisant les méthodes isEmpty/push/pop utiliser les quickfix pour résoudre l'import. (cliquer sur l'icône dans la marge ou ctrl-1 (un))

Expliquer la différence entre l'auto-completion et le quickfix.

Changer le code de la classe "Main" par celui-ci
Extraire l'interface "IStack" à partir de la classe "Stack" (Refactor/Extract Interface...)
Modifier la classe "Main" pour introduire "IStack" là ou il faut
Renommer l'interface "IStack" en "Stack" et la classe "Stack" en "StackImpl" en vérifiant à chaque fois les changements sur la classe "Main"
Génerer la javadoc (Project/generate javadoc) dans un répertoire docs

Exercice 3 - Style de codage

Eclipse permet de paramétrer le style de code
Aller dans Window/Preference/Java/Code Style/Code Formater et créer un nouveau formateur à partir du formateur Java Convention.

Modifier le formateur nouvellement créé pour qu'il :

n'utilise pas de tab
indente de 2 espaces
indente les switch et les cases dans les switch
utilise les assignements dit "compact", pas d'espace avant et après une assignation
n'y ait pas d'espace juste après les if/for/while/switch/synchronized/catch et avant la parenthèse ouvrante

Appliquer le style créé à l'ensemble des sources du projets (Contextuel/Source/Format ou Ctrl-Shift-f).
Note: pour remettre en forme l'indentation d'un morceau du code sélectionné, utiliser Contextuel/Source/Correct Indentation ou Ctrl-i.

Exercice 4 - Exécuter et débugger

Executer le code de la classe "Main" (Run/Run As/Java Application ou Conxtuelle/Run As/Java Application)
Demander à la machine virtuel d'afficher les réclamation d'objet par le GC, pour cela ajouter l'argument -verbose:gc pour la machine virtuelle. (Run/Run... et Arguments/VM arguments)
Ajouter un argument sur la ligne de commande
Compiler le code pour qu'il marche avec toute version à partir de 1.3 (Window/Preference/Java/Compiler/Compliance and classfiles ou sur le projet Contextuel/Properties/Java Compiler/Compliance and classfiles)
Expliquer pourquoi l'exécution va quand même planter sur une VM 1.3 et changer le "Main" en conséquence (2 changements).
Faite exécuter la classe "Main" par la machine virtuelle 1.4 (Window/Preference/Java/Installed/JRE) déclarer le J2SDK1.4 Puis (Run/Run... et JRE).

Expliquer comment faire pour écrire du code valable pour un environnement java ayant une version inférieure à un environnement donné.

Revener à la machine virtuelle 1.5 et placer un point d'arrêt sur la première ligne de la méthode "main()" (sur la barre à côté du code Contextuel/Toggle breakpoint)
Faite exécuter votre programme par le debugger (Run/Debug... ou Run/Debug/Java Application) Noter le changement de perspective
Vérifier la valeur des arguments (vues Variables)
Avancer pas à pas dans le programme (éditeur Debug icône Step Into) et changer la valeur du résultat de parseInt() (double click sur la variable "count")
Laisser le programme terminer

Exercice 5 - Paramétrer le compilateur

Aller dans Window/Preference/Java/Compiler ou Properties/Java Compiler, écrire un exemple de code pour chaque option parmi les suivantes permettant de tester celle-ci :

Dans Style :
- Methods with a constructor name Exemple : fr.umlv.eclipsedemo.compiler.ConstructorExample
- Non-static access to static member
- Finally does not complete normally
Dans Advanced :
- Access to a non-accessible member of enclosing type
- Interface method conflicts with protected 'Object' method
Dans Unused Code :
- Parameter is never read
- Parameter is never read (check overriding ...)
- Hidden catch block

Enfin, paramétrer le compilateur pour qu'il soit le plus strict possible par rapport au code que vous écrivez normalement.

Exercice 6 - Utiliser Ant

Recopier le fichier build.xml

Dans External Tools (Run/External Tools/External Tools...), créer une nouvelle configuration ant utilisant le fichier
lancer le script
lancer uniquement la compilation
Pourquoi ne peut-on lancer l'exécution sans la compilation ?
Changer pour que la règle par défaut lance l'exécution.
Ajouter une règle (target) pour générer la documentation javadoc (le manuel est ici : http://ant.apache.org/manual/ puis regarder ant task/core tasks)

Pourquoi on utilise ant plutôt que makefile ?

Exercice 7 - Utiliser le JDK1.5

Créer une classe Main15 ayant une méthode main contenant le code suivant
```
        System.out.printf("%d\n",args.length);
       
```
Expliquer pourquoi ce code ne marche pas.

Nous allons maintenant utiliser un plugin spécial qui permet dans eclipse d'utiliser le compilateur de SUN.
Pour que cela marche, il faut que la machine virtuelle utiliser soit le JDK et non pas le JRE (car il ne possède pas le compilateur).

Sur le projet, dans le menu contextuel activer le support pour le plugin 1.5 (Java 1.5 Plugin/Add 1.5 Support)
Créer sur le projet deux répertoires (Folders et pas Source Folder) nommés "src15" et "classes15" (garder les répertoire "src" et "classes" par défaut)
Sur le projet, aller dans Contextuel/Properties... et Java 1.5 Compiler Properties. Faire pointer le répertoire de source sur "src15" et le répertoire destination sur "classes15". Puis ajouter "-Xlint:all" en option additionnel.
Expliquer pourquoi il ne faut pas utiliser les répertoires src/classes d'Eclipse.
Déplacer la classe "Main15" dans "src15" puis cliquer sur l'icône [1.5] pour compiler.
Dans la vue "Problems", cliquez sur le bouton "filters" et ajouter "jdk1.5 compiler problems"
Exécuter la classe.
Enfin modifier le script ant pour qu'il puisse compiler les classes 1.5

Après avoir mis en place le support de la version 1.5, nous allons tester les quelques nouveautées de cette version.

Exercice 8 - Installer une bibliothèque externe

On souhaite utiliser pour le projet la bibliothèque ASM (http://asm.objectweb.org/).

Télécharger la version 1.5.2 ne contenant que les fichiers binaires

Indiquer comment faire pour importer la bibliothèque dans le projet. (Window/Preference/Java/Build Path). Vous pouvez vous aider de la documentation (Help/Help Contents)
Tester la classe "fr.umlv.eclipsedemo.asm.ASMExample" qui contient la méthode "main" suivante :

       public static void main(String[] args) throws IOException {
         ClassReader reader=new ClassReader("fr.umlv.eclipsedemo.HelloEclipse");
         ASMifierClassVisitor visitor=new ASMifierClassVisitor(
           new PrintWriter(System.out));
         reader.accept(visitor,true);
       }

Vérifier que la completion indique les arguments des méthodes ainsi que la documentation.
Modifier ensuite le script ant pour qu'il puisse exécuter le code.