9. Le refactoring

Eclipse intègre de puissantes fonctionnalités pour faciliter le refactoring. Le refactoring consiste à modifier la structure d'un fichier source et si nécessaire à propager ces modifications dans les autres fichiers sources pour maintenir autant que possible l'intégrité du code existant.

Un menu nommé « Propager les modifications » permet d'utiliser certaines de ces fonctionnalités : il est présent dans le menu principal et dans de nombreux menus contextuels. Chacune de ces fonctionnalités est applicable sur un ou plusieurs types d'entités selon le cas : projets, classes et membres d'une classe. Certaines de ces fonctionnalités possèdent un raccourci clavier.

Type de modification	Fonctionnalités	Entité(s) concernée(s)	Raccourci clavier
Structure du code	Renommer	projets, packages, classes, champs, méthodes, variables locales, paramètres	Alt+Maj+R
	Déplacer	projets, packages, classes, méthodes et champs statiques	Alt+Maj+V
	Changer la signature de la méthode	méthodes
	Convertir une classe anonyme en classe imbriquée	classes anonymes
	Convertir un type imbriqué au niveau supérieur	classes imbriquées
Structure au niveau de la classe	Transférer	méthodes ou champs
	Extraire	méthodes ou champs
	Extraire une interface	classes
	Utiliser le supertype si possible	classes
Structure à l'intérieure d'une classe	Intégrer	méthodes, constantes et variable locales	Alt+Maj+I
	Extraire la méthode	morceau de code sélectionné	Alt+Maj+M
	Extraire la variable locale	morceau de code sélectionné pouvant être transformé en variable	Alt+Maj+L
	Extraire une constante	morceau de code sélectionné pouvant être transformé en constante
	Convertir la variable locale en zone	variables locales
	Encapsuler la zone	champs

Le menu « Propager les modifications » permetant d'utiliser les fonctionnalité de refactoring a été renommé en «Restructurer».

L'accès aux fonctions de refactoring est contextuel : seules les fonctions applicables dans le contexte courant peuvent être activées. L'éditeur propose un menu contextuel pour accéder rapidement aux fonctions de refactoring en utilisant la combinaison de touche Alt+Maj+T Les fonctions proposées le sont en fonction du contexte (le type d'entité sur lequel le curseur est placé).

Avant de pouvoir utiliser ces fonctionnalités, il faut sauvegarder l'élément qui sera modifié sinon un message d'erreur est affiché.

L'usage de ces fonctions utilise toujours le même principe de fonctionnement :

1. sélection de l'élément concerné par la fonction de refactoring
2. appel de la fonction en utilisant l'option du menu « Propager les modifications »
3. renseigner les informations utiles à la fonction dans la boîte de dialogue
4. pré-visualiser et valider individuellement les modifications qui seront apportées
5. demander la mise en oeuvre des modifications en cliquant sur « Ok » (ceci peut être fait sans demander la prévisualisation)

Les fonctionnalités du refactoring sont accessibles à partir des vues "Packages" et "Structure" ou de l'éditeur de code Java selon l'entité concernée par la modification. Dans les vues, il suffit de sélectionner le ou les éléments concernés. Dans l'éditeur de code, il faut sélectionner le nom de l'élement ou de positionner le curseur dessus avant d'appeler la fonctionnalité.

Toutes les fonctionnalités utilisent un assistant qui propose toujours à la fin un bouton « Apercu > » permettant d'ouvrir une boîte de dialogue qui permet de pré-visualiser chacune des modifications résultant de l'usage de la fonction.

Une arborescence permet d'afficher chacun des éléments qui sera modifié ainsi que toutes les modifications pour ces éléments. Il est possible de cocher ou non tout ou partie des modifications pour qu'elles soient appliquées ou non.

La partie inférieure présente, pour l'élément sélectionné, le code source actuel à gauche et le code source tel qu'il sera après l'application de la fonction à droite.

Un clic sur le bouton « OK » permet de mettre en oeuvre toutes les modifications qui sont cochées.

 

9.1. Extraction d'une méthode

Cette fonction permet de transférer un morceau de code dans une méthode qui sera créée pour l'occasion.

Pour l'utiliser, il faut sélectionner le morceau de code.

Il faut sélectionner l'option « Extraire la méthode ...  » du menu principal ou du menu contextuel « Propager les modifications ». Une boite de dialogue permet de saisir le nom de la méthode et de sélectionner le modificateur d'accès.

Un clic sur le bouton « OK » permet de mettre en oeuvre automatiquement les modifications.

Dans le cas ou le code sélectionné contient une ou plusieurs variables, la boîte de dialogue contient en plus la liste des variables détectées dans le code.

Il faut saisir le nom de la méthode, sélectionner son modificateur d'accès et éventuellement modifier les paramètres puis cliquer sur le bouton "OK".

La liste des variables détectées dans le code est affichée dans la liste des paramètres. Pour modifier le nom d'un des paramètres, il suffit de le sélectionner et de cliquer sur le bouton « Editer... ».

Le bouton « Aperçu » permet de voir et de valider les modifications qui seront apportées.

 

9.2. Intégrer

L'intégration permet de remplacer l'appel d'une méthode par le code contenu dans cette méthode.

Puis il faut utiliser l'option « Propager les modifications/Intégrer... » du menu principal ou contextuel.

En fonction du contexte d'appel, une boîte de dialogue permet de sélectionner la portée des modifications.

Si le code sélectionné ne correspond pas à une méthode, un message d'erreur est affiché.

 

9.3. Renommer

La fonction "Renommer" permet d'attribuer un nouveau nom à une entité présente dans l'espace de travail. La grand intérêt de réaliser une telle opération via cette fonctionnalité plutôt que de le faire à la "main" et qu'elle automatise la recherche et la mise à jour de toute les références à l'élement dans l'espace de travail.

Les exemples de cette section utilisent les deux classes suivantes :

Le renommage concerne l'entité sélectionnée dans la vue "Package" ou "Structure" ou sous le curseur dans l'éditeur de code Java.

Par exemple, pour renommer une méthode, il suffit de positioner le curseur sur le nom de la déclaration d'une méthode dans le code source et sélectionner l'option « Propager les modifications / Renommer » du menu contextuel.

Il suffit alors de saisir le nouveau nom. Eclipse permet de renommer la méthode dans sa classe de définition mais remplace aussi tous les appels de la méthode contenue dans l'espace de travail.

Pour renommer une classe, il y a deux possibilités : selectionner la classe dans la vue « Packages » ou positionner le curseur sur la définition du nom de la classe dans l'éditeur. Puis il faut utiliser l'option « Renommer » du menu contextuel « Propager les modifications ».

Il est possible de préciser les types d'entités qui doivent être mise à jour.

A la validation, Eclipse effectue toutes les modifications nécessaires suite au renommage de la classe, notamment le remplacement à tous les endroits dans l'espace de travail ou la classe est utilisée.

Le principe est le même pour renommer un package.

Si Eclipse détecte des problèmes potenciels lors de l'analyse de la demande, il affiche dans une boite de dialogue la liste de ces problèmes et demande un confirmation avant de poursuivre les traitements.

Si la sélection ne correspond à aucun élément renommable, un message d'erreur est affiché.

 

Lors d'une opération de refactoring de renommage, l'assistant propose de mettre en oeuvre un délégué. Exemple : Exemple : package fr.jmdoudoux.test; public class MaClasse1 extends MaSousClasseMere { public MaClasse1(int valeur) { this.valeur = valeur; } public int additionner(int val) { return valeur+val; } } Sélectionnez une méthode et utiliser l'option « Restructurer / Renommer ... » du menu contextuel. Saisissez le nouveau nom de la méthode et cochez la case « Conserver la méthode originale en tant que délégué de la méthode renommée ». Par défaut la case à cocher « Marquer comme étant déprécié » est cochée. Cliquez sur le bouton « OK » Exemple : package fr.jmdoudoux.test; public class MaClasse1 extends MaSousClasseMere { public MaClasse1(int valeur) { this.valeur = valeur; } /** * @deprecated Utilisez {@link#additionnerRenomme(int)} à la place */ public int additionner(int val) { return additionnerRenomme(val); } public int additionnerRenomme(int val) { return valeur+val; } } La nouvelle est renommée avec le nom fournie et l'ancienne méthode est définie avec l'attribut deprecated  : elle appelle simplement la nouvelle méthode. Cette fonctionnalité permet de garder une compatibilité ascendante. Elle est mise en oeuvre dans plusieurs outils de refactoring tel que Renommer, Changer la signature de la méthode ou Introduire le paramètre.   Lors d'une opération de refactoring de type Renommer, il est possible de demander le renommage des entités dont le nom est similaire à l'entité renommée. Exemple : package fr.jmdoudoux.test ; public class Fenetre { public Fenetre() {} public Fenetre creerFenetre() { Fenetre fenetre = new Fenetre(); return fenetre ; } public void testerFenetre(Fenetre fenetre) { System.out.println(" Fenetre ="+ fenetre); } } Sélectionnez la classe et utilisez l'option « Restructurer / Renommer » du menu contextuel. Saisissez le nouveau nom et cochez la case « Mettre à jour les méthode et les variables nommées de manières identiques ». Cliquez sur le lien « Configurer ... » pour préciser les paramètres de recherche et de remplacement. Sélectionnez l'option désirée et cliquez sur le bouton « OK ». Voici le résultat avec l'option par défaut : Exemple : package fr.jmdoudoux.test ; public class Window { public Window() {} public Window creerFenetre () { Window window = new Window( ); return window; } public Window creerFenetreModale () { Window window = new Window( ); return window; } public void testerFenetre (Window window) { System.out.println(" Fenetre ="+window); } } Voici le résultat avec l'option « Rechercher également les noms imbriqués » : Exemple : package fr.jmdoudoux.test; public class Window { public Window() {} public Window creerWindow () { Window window = new Window(); return window; } public Window creerWindowModale () { Window window = new Window(); return window; } public void testerWindow (Window window) { System.out.println(" Fenetre ="+window); } } Lors du renommage d'un package, il est possible de demander le renommage des sous packages Il suffit de cocher la case « Renommer les sous packages » pour que tous les sous packages soient automatiquement renommés lors de l'opération.

 

9.4. Déplacer

La fonction "Déplacer" permet de déplacer certains éléments précis notamment une classe dans l'espace de travail pour la déplacer dans un autre package. La grand intérêt de réaliser une telle opération via cette fonctionnalité est d'automatiser la recherche et la mise à jour de toute les références à l'élement dans l'espace de travail.

Par exemple, pour déplacer une classe dans un autre package, il faut sélectionner la classe dans la vue "Packages" et de sélectionner l'option "déplacer" du menu "Propager les modifications"

En plus du déplacement de la classe, les clauses import correspondantes sont modifiées dans les classes qui utilisent la classe déplacée.

Si le code sélectionné dans l'éditeur de code Java ne correspond pas à une entité concernée par cet action, un message d'erreur est affiché.

Dans l'éditeur de code il faut sélectionner ou mettre le curseur sur un élément statique, avant d'utiliser la fonctionnalité.

Une boite de dialogue permet de sélectionner la classe dans laquelle la méthode va être transférée.

Le bouton "Parcourir" permet d'ouvrir une boîte de dialogue pour sélectionner la classe de destination.

 

9.5. Changer la signature de la méthode

Cette fonction permet de modifier la signature d'une méthode : changer les attributs de visibilités, les paramètres (ajouter/supprimer un paramètre ou modifier le nom, le type ou l'ordre des paramètres) ou le type de retour de la méthode.

Pour utiliser cette fonction, il faut sélectionner dans l'éditeur le nom d'une méthode et appeler la fonction par le menu contextuel. Une boîte de dialogue permet de modifier les éléments qui constituent la signature de la méthode.

Les actions réalisées par les boutons "Ajouter" et "Supprimer" sont assez explicite. Le bouton "Editer" permet de modifier le paramètre sélectionné.

Les boutons "Haut" et "Bas" permettent de modifier l'ordre du paramètre sélectionné.

La valeur par défaut est importante car elle sera utilisée lors de la modification de l'utilisation de la méthode, pour éviter les erreurs de compilation.

Si le code sélectionné dans l'éditeur de code lors de l'appel de la fonction ne correspond pas à une entité concernée par cet action, un message d'erreur est affiché.

Cette fonction a été améliorée avec plusieurs fonctionnalités. La boîte de dialogue permet maintenant aussi de renommer le nom de la méthode. Le type peut être recherché grâce à un assistant en utilisant la combinaison de touche Ctrl+Espace. L'onglet "Exceptions" permet de modifier les exceptions propager par la méthode Lors des mises à jours liées à cette fonctionnalité, la documentation Javadoc de la méthode sera mise à jour.

 

9.6. Convertir une classe anonyme en classe imbriquée

Cette fonction permet de transformer une classe anonyme souvent utilisée pour créer des listeners en une classe imbriquée.

Pour utiliser cette fonction, il faut placer le curseur dans le code de la classe anonyme. Si tel n'est pas le cas lors de l'appel de la fonction, une message d'erreur est affiché.

Une boîte de dialogue permet de saisir les informations concernant la classe qui sera générée.

La nouvelle classe imbriquée est crée en tenant compte des informations saisies.

 

9.7. Convertir un type imbriqué au niveau supérieur

Cette fonction permet de convertir une classe imbriquée en une classe définie dans un fichier particulier.

Pour utiliser cette fonction, il faut sélectionner une classe imbriquée dans la vue "Packages" ou "Structure" ou sélectionner dans l'éditeur de code le nom d'une classe imbriquée.

Si le code sélectionné ne correspond pas à une entité concernée par cet action, un message d'erreur est affiché.

Lors de la l'appel de la fonction, une boite de dialogue permet de préciser des informations sur la classe qui va être déplacée.

Voici un exemple de l'aperçu de l'utilisation de cet fonction

Le nom pour l'instance de délimitation permet de stocker une instance de la classe englobante si la classe avait besoin de l'accès à des membres de l'ancienne classe englobante.

 

9.8. Extraire

Cette fonction permet de déplacer la déclaration d'un membre d'une classe fille dans une de ces classes meres.

Pour utiliser cette fonction, il faut sélectionner un membre d'une classe fille ou positionner le curseur sur un de ces membres sinon un message d'erreur est affiché.

Une boîte de dialogue permet de sélectionner le ou les membres concernés dont celui à partir duquel la fonction a été appelée.

Il suffit de cocher le ou les membres concernées et de sélectionner la classe mère dans la liste déroulante.

Pour les méthodes, le bouton "Editer" permet de sélectionner l'action qui sera réalisée.

L'action "extraire" permet de déplacer la déclaration et le code de la méthode dans la classe mère sélectionnée. L'action "déclarer abstrait dans la déclaration" permet de déclarer la classe choisie abstraite avec une déclaration de la méthode elle aussi abstraite. Dans ce dernier cas, le code de la méthode est laissé dans la classe fille en tant que rédéfinition.

 

9.9. Transferer

Cette fonction permet de transferer une méthode dans les classes filles.

Pour utiliser cette fonction il faut sélectionner un membre d'une classe possèdant au moins une classe fille ou mettre le curseur sur un de ces membres dans l'éditeur de code. Si la fonction est appelée sur une classe qui ne possède pas de classe fille, un message d'erreur est affiché.

Une boîte de dialogue permet de sélectionner le ou les membres concernés par le transfert.

Pour une méthode, le bouton "Editer" permet de sélectionner l'action qui sera réaliser.

L'action "transfert" permet de déplacer la déclaration et le code de la méthode dans la ou les classes filles. L'action "laisser la déclaration abstraite" permet de laisser la déclaration abstraite de la méthode dans la classe mère.

 

9.10. Extraire une interface

Cette fonction permet de définir à postériori une interface à partir d'une ou plusieurs méthodes définies dans une classe. Il faut sélectionner dans le code le nom d'une classe.

Si la partie sélectionnée ne correspond pas à un nom de classe, un message d'erreur est affiché.

Il suffit ensuite d'utiliser l'option « Extraire une interface » du menu « Propager les modifications ». Une boite de dialogue permet de préciser le nom de l'interface et de sélectionner les membres à déclarer dans l'interface.

Pour respecter les spécifications du langage Java, les membres qu'il est possible d'intégrer dans l'interface sont des méthodes et des constantes publiques, par exemple :

Le résultat est la création de l'interface et son implémentation par la classe sélectionnée.

 

9.11. Utiliser le supertype si possible

Cette fonction permet de remplacer l'utilisation d'un type par un de ces super types si celui ci en possède.

Pour utiliser cette fonction, il faut sélectionner un type dans le code de l'éditeur ou mettre le curseur sur ce dernier sinon un message d'erreur est affiché :

Lors de l'appel de cette fonction, une boîte de dialogue permet de sélectionner une des classes mère du type sélectionné.

La pré-visualisation permet de voir les modifications qui seront apportées dans le code.

Si l'utilisation du super type sélectionné n'est pas possible (par exemple car une méthode utilisée n'est pas définie dans le type sélectionné), aucune modification n'est faite dans le code et l'aperçu affiche le message suivant :

 

9.12. Convertir la variable locale en zone

La fonction « Convertir la variable locale en zone » permet de transformer une variable locale à une méthode en un champ de la classe.

Pour utiliser cette fonction, il faut sélectionner dans le code une variable locale, puis utiliser l'option « Convertir la variable locale en zone » du menu « Propager les modifications ».

Si la sélection ne correspond pas à une variable locale, un message d'erreur est affiché.

Une boîte de dialogue permet de préciser le nom du champ, le modificateur d'accès et l'endroit dans le code où le champ sera initialisé.

Le résultat de l'exécution de la fonction est le suivant :

 

9.13. Encapsuler la zone

Cette fonction permet d'encapsuler un attribut en générant un getter et éventuellement un setter.

Il faut sélectionner dans le code un champ de la classe.

Il faut ensuite utiliser l'option « Encapsuler la zone » du menu « Propager les modifications ».

Si la sélection dans le code ne correspond pas à un champ de la classe, un message d'erreur est affiché.

Une boite de dialogue permet de préciser les options pour la génération du getter et du setter

Le résultat de l'exécution génère le getter et le setter et remplace l'utilisation du champ par ces méthodes.

En sélectionnant l'option « conserver les références de zones », ces méthodes ne sont pas utilisées dans la classe où le champ est utilisé.

 

9.14. Extraire la variable locale

Cette fonction permet de définir une constante à partir d'une expression.

Il faut sélectionner une expression dans le code source.

Puis utiliser l'option « Extraire la variable locale » du menu « Propager les modifications ».

Une boîte de dialogue permet de saisir le nom de la variable, de préciser si toutes les occurrences doivent être modifiées et si la variable doit être une constante.

Si la sélection dans le code source est incorecte, un message d'erreur est affiché.

Le résultat de l'exécution de cette fonction est le suivant :

 

9.15. Extraire une constante

Cette fonction permet de définir une constante à partir d'une valeur en dur utilisée dans le code. Il suffit de sélectionner cette valeur dans le code source.

Puis d'utiliser l'option « Extraire une constante ...  » du menu « Propager les modifications ». Une boite de dialogue apparaît pour préciser le nom de la constante à créer et son modificateur d'accès.

Il est possible de préciser si toutes les occurrences de la valeur doivent être remplacées dans le code source.

Il est aussi possible de préciser l'utilisation de la qualification de la constante avec le nom de la classe dans laquelle elle est définie.

 

9.16. Généraliser le type

Cette fonction permet de remplacer le type d'une variable par un de ces super types. Il faut positionner le curseur sur la déclaration d'une variable, d'un champ, d'un paramètre ou d'une valeur de retour. Une boite de dialogue affiche la liste des super types. Il suffit de sélectionner le type désiré et de cliquer sur le bouton « Ok » pour que le code soit mise à jour. Cette fonctionnalité est très utile car elle facilite la mise en oeuvre d'une bonne pratique de programmation consistant à utiliser un super type comme type d'une variable lorsque cela est possible.

 

9.17. Introduire une fabrique

Cette fonction permet d'obliger l'utilisation d'une fabrique pour créer une occurrence de la classe. Il faut positionner le curseur sur un constructeur puis appeler la fonction. Le code est modifié en créant la méthode de fabrication et en rendant le constructeur privé.

 

9.18. Introduire un paramètre

Cette fonction permet de remplacer une expression utilisée dans une méthode par un paramètre fourni à cette méthode. Il faut positionner le curseur sur une expression littérale et appeler la fonction. Une boîte de dialogue permet de saisie le nom du paramètres En cliquant sur le bouton « Ok », le paramètre est ajouté dans la signature de la méthode et la valeur littérale est remplacée par le paramètre.

 

9.19. Introduction de l'adressage indirect

Ce refactoring permet de rediriger l'appel d'une méthode vers une nouvelle méthode qui appel elle-même la méthode courante. Tous les appels actuels sont remplacés par un appel à la nouvelle méthode. Sélectionnez une méthode dans le code et utilisez l'option « Restructurer / Introduction de l'adressage indirect ... » Saisissez le nouveau de la méthode et cliquez sur le bouton « OK ». Cliquez sur le bouton « OK » pour exécuter le refactoring .

 

9.20. Extraire une super classe

Ce refactoring permet de créer une super classe à partir de plusieurs classes sous réserve que ces classes possèdent des membres communs. Les classes utilisées dans cette section sont les suivantes : Exemple : package fr.jmdoudoux.test; public class MaClasse1 extends MaClasseMere{ private int valeur = 100; public MaClasse1(int valeur) { this.valeur = valeur; } public void afficher() { System.out.println("valeur="+valeur); } public int additionner(int val) { return valeur+val; } } package fr.jmdoudoux.test; public class MaClasse2 extends MaClasseMere{ private int valeur = 200; public MaClasse2(int valeur) { this.valeur = valeur; } public void afficher() { System.out.println("valeur="+valeur); } public int Calculer() { return valeur + 10; } } Sélectionnez la première classe (MaClasse1 par exemple) et utilisez l'option « Restructurer / Extraire une super classe » du menu contextuel Saisissez le nom de la super classe à créer puis cliquez sur le bouton « Ajouter » Sélectionnez la ou les classes concernées par ce refactoring et cliquez sur le bouton « OK » Cochez les membres de la première classe à intégrer dans la classe mère. Cliquez sur le bouton « Suivant » Cette page de l'assistant permet de sélectionner les méthodes à supprimer dans les classes filles issues du refactoring . La partie source permet de voir le code source de la méthode et ainsi de sélectionner les méthodes concernées par le refactoring. Cliquez sur le bouton « Suivant » pour avoir un aperçu des modifications Cliquez sur le bouton « Terminer » La super classe est créée : Exemple : package fr.jmdoudoux.test; public class MaSousClasseMere extends MaClasseMere { protected int valeur = 100; public MaSousClasseMere() { super(); } public void afficher() { System.out.println("valeur="+valeur); } } et les classes filles sont modifiées Exemple : package fr.jmdoudoux.test; public class MaClasse1 extends MaSousClasseMere { public MaClasse1(int valeur) { this.valeur = valeur; } public int additionner(int val) { return valeur+val; } } package fr.jmdoudoux.test; public class MaClasse2 extends MaSousClasseMere { public MaClasse2(int valeur) { this.valeur = valeur; } public int Calculer( ) { return valeur + 10; } }

 

9.21. Annuler ou refaire une opération de refactoring

Le menu "Propager les modifications" possède deux options "Annuler" et "Rétablir" qui ont un rôle similaire aux deux options du même nom dans le menu "Edition". L'utilisation de ces deux options est cependant dédiées à l'annulation ou le rétablissement des modifications opérées par la dernière opération de refactoring.

Ces deux options ne sont plus disponibles dès que des modifications supplémentaires sont effectués et sauvegardées dans au moins un des fichiers modifiés par l'opération de refactoring.

Si un des fichiers modifiés par l'opération de refactoring est modifié sans être sauvegardé avant l'utilisation d'une de ces deux options, un message d'erreur est affiché.

 

9.22. L'historique de restructuration

L'option historique du menu principal « Restructurer » permet d'avoir accès à l'historique des restructurations effectuées dans l'espace de travail. Sélectionnez la restructuration et cliquez sur le bouton « Supprimer ». Cliquez sur le bouton « Oui »