"Rebonjour."
"Salut!"
"Aujourd'hui, je vais vous parler du refactoring. Le refactoring consiste à modifier le code d'un projet sans en modifier les fonctionnalités."
« Mais comment est-ce possible ?
"Eh bien, dans les cas les plus simples, nous pourrions renommer des variables et/ou des méthodes. Après tout, changer le nom d'une variable ne fera pas fonctionner le programme différemment, n'est-ce pas ?"
"Bien sûr que non."
"Vous pouvez également diviser les grandes méthodes en plusieurs plus petites. "
"Vous pouvez extraire des extraits de code répétés dans une méthode distincte. "
"Certaines fonctions peuvent être déclarées statiques puis déplacées dans des classes utilitaires."
"Mais c'est une interprétation étroite de la refactorisation."
"Le refactoring, c'est parfois réécrire (améliorer) l'architecture d'un projet sans ajouter de nouvelles fonctionnalités. C'est du refactoring au sens large du terme."
"IntelliJ IDEA est devenu l'environnement de développement intégré (IDE) le plus populaire, notamment parce qu'il a été le premier à introduire des outils de refactorisation très puissants."
« Quels sont ces outils magiques ? »
Tour de magie #1 : Changer le nom d'une méthode.
"Imaginez que votre code ait une méthode qui est appelée de 100 à 500 endroits différents. Vous avez décidé de changer son nom en quelque chose de plus compréhensible. Disons qu'il s'agit de run() et que vous voulez qu'il soit runDownloadTaskAsync(). À quelle vitesse peux-tu faire ça?"
"Eh bien, vous devez d'abord changer le nom de la méthode, puis trouver tous les endroits du programme où cette méthode est appelée, et changer le nom là aussi."
« Et comment trouveriez-vous ces endroits ?
"J'exécuterais simplement le programme et IntelliJ IDEA me montrerait tous les endroits où une méthode inexistante est appelée."
"D'accord. Mais supposons maintenant que chaque méthode ait un commentaire explicatif (JavaDoc) qui explique ce que fait la méthode - et que l'ancien nom de la méthode y soit écrit."
"Je changerais aussi les commentaires."
"Mais il peut aussi y avoir des variables dont les noms sont associés au nom de la méthode. Ce serait bien de les changer aussi :"
| Avant | Après |
|---|---|
|
|
« Ouais, ce serait bien de changer aussi les noms de ces variables. Ça ne ferait pas de mal.
"Eh bien, tout cela peut être fait en quelques secondes avec IntelliJ IDEA !"
"Vous placez le curseur sur le nom de la méthode (ou cliquez dessus avec la souris), puis appuyez sur Maj + F6 et commencez simplement à taper le nom de la méthode souhaitée."
"Voici un exemple de modification d'un nom de méthode."
"Démarrer l'édition :"
"Spécifier un nouveau nom :"
"Entrez simplement un nouveau nom, appuyez sur Entrée, et c'est tout. Cette méthode sera renommée partout où elle sera appelée dans le projet."
"IntelliJ IDEA vous demande aussi généralement si vous souhaitez renommer les noms de variables et les noms de méthodes dans les commentaires. Cliquez simplement sur "Oui" et tout changera."
"De plus, si le projet a été compilé avant cette opération de refactoring, il est garanti qu'il sera compilé après le refactoring."
"Cela semble très prometteur."
"Au fait, vous pouvez modifier les noms de variables de la même manière. Après avoir cliqué sur un nom, appuyez simplement sur Maj + F6 - Vous pouvez alors entrer un nouveau nom, et IntelliJ changera le nom de la variable partout où il est utilisé. "
"Si la variable est un champ dans une classe et a un getter et un setter, alors les noms du getter et du setter seront également modifiés pour correspondre au nouveau nom de la variable."
"J'ai essayé en utilisant des variables. Tout fonctionne exactement comme tu l'as dit, Ellie. La refactorisation est géniale !"
"Pensez-vous que c'est tout ce qu'il y a à refactoriser ? La réfraction est un sujet tellement vaste - nous n'avons même pas effleuré la surface."
« Wow. Qu'est-ce qu'il y a d'autre ?
Tour de magie #2 : Extrayez une variable.
"Parfois, certaines expressions sont répétées si souvent dans le code que vous souhaiterez les déplacer dans une variable distincte. Par exemple :"
public void printInfo(User user)
{
System.out.println(user.getProfile().getName());
System.out.println(user.getProfile().getAddress().getState());
System.out.println(user.getProfile().getAddress().getCity());
System.out.println(user.getProfile().getAddress().getStreet());
System.out.println(user.getProfile().getAddress().getHomeNumber());
}public void printInfo(User user)
{
Address address = user.getProfile().getAddress();
System.out.println(user.getProfile().getName());
System.out.println(address.getState());
System.out.println(address.getCity());
System.out.println(address.getStreet());
System.out.println(address.getHomeNumber());
}"Ah."
"Et le code peut être beaucoup plus compliqué, avec beaucoup de parties répétées."
"Les programmeurs ne l'écrivent pas de cette façon intentionnellement. Mais vous devrez souvent ajouter quelque chose à une méthode, puis autre chose - et avec le temps, le nombre de répétitions explose."
"En créant une variable distincte, nous pouvons lui donner un nom propre et améliorer la lisibilité du code."
"Par exemple, dans l'exemple ci-dessus, nous ne parlons peut-être pas d'une adresse personnelle. Peut-être parlons-nous de l'adresse d'un contact d'urgence. Vous pouvez alors appeler cette variable emergencyContactAddress, au lieu de simplement l'adresse. Ensuite, un programmeur voir ce code pour la première fois comprendra ce qui se passe ici."
"Oui, je suis d'accord. L'ajout de telles variables est logique."
« Alors, comment fais-tu ?
"Déplacer une expression dans une variable distincte est très simple."
Étape 1 : Utilisez la souris pour sélectionner l'expression.
Étape 2 : Appuyez sur Ctrl+Alt+V
"Une fenêtre s'ouvre où IntelliJ IDEA nous demande si nous voulons remplacer uniquement l'expression sélectionnée ou toutes les instances de l'expression (4 occurrences) ?"
"Sélectionnez la deuxième option pour remplacer toutes les occurrences (Remplacer les 4 occurrences)"
Étape 3 : Appuyez sur Entrée.
"IntelliJ IDEA vous demandera d'entrer un nom de variable. Il fera également sa propre suggestion pour le nom. Pas mal, hein ?"
"Uh-huh. Tout à fait. Nous avions également prévu de nommer la variable 'adresse'. Comment a-t-il su ?"
"En utilisant le nom de la dernière méthode dans l'expression, qui renvoie une adresse. Ainsi, il est probable que la variable sera utilisée pour stocker une adresse."
"Ça a très bien marché. C'est super, Ellie."
Astuce magique n°3 : Extrayez le code dans une méthode distincte.
"Mais nous aurions pu faire autre chose. Nous aurions pu déclarer une nouvelle méthode, par exemple printAddress (), et y déplacer tout ce code."
"Essayons de faire ça."
Étape 1 : Sélectionnez les 4 lignes de code qui utilisent la variable d'adresse :
Étape 2 : appuyez sur Ctrl+Alt+M
"IntelliJ IDEA détermine les variables dont la méthode aura besoin et suggère à quoi elle devrait ressembler. "Il ne reste plus qu'à entrer un nom pour la méthode."
Étape 3 : Entrez printAddress comme nom de méthode et appuyez sur Entrée.
« Comment est-ce que tu aimes ça ? »
"C'est génial. Non seulement IntelliJ IDEA a extrait le code dans une méthode distincte, mais il a également ajouté toutes les variables requises. De plus, il a deviné correctement tous les noms."
GO TO FULL VERSION