"Welkom terug."
"Hoi!"
"Vandaag ga ik je vertellen over refactoring. Refactoring is het veranderen van de code in een project zonder de functionaliteit ervan te veranderen."
"Maar hoe is dat mogelijk?"
"Nou, in de eenvoudigste gevallen zouden we variabelen en/of methoden een andere naam kunnen geven. Het veranderen van de naam van een variabele zorgt er toch niet voor dat het programma anders gaat werken?"
"Natuurlijk niet."
"Je kunt grote methoden ook opsplitsen in meerdere kleinere. "
"Je kunt herhaalde codefragmenten naar een aparte methode halen. "
"Sommige functies kunnen statisch worden verklaard en vervolgens worden verplaatst naar hulpprogramma's."
"Maar dit is een enge interpretatie van refactoring."
"Refactoring betekent soms het herschrijven (verbeteren) van de architectuur van een project zonder nieuwe functionaliteit toe te voegen. Dit is refactoring in de brede zin van het woord."
"IntelliJ IDEA werd de meest populaire geïntegreerde ontwikkelomgeving (IDE), vooral omdat het de eerste was die zeer krachtige refactoring-tools introduceerde."
"Wat zijn deze magische gereedschappen?"
Goocheltruc #1: verander de naam van een methode.
"Stel je voor dat je code een methode heeft die wordt aangeroepen vanuit 100-500 verschillende plaatsen. Je hebt besloten om de naam ervan te veranderen in iets begrijpelijker. Laten we zeggen dat het run() is, en je wilt dat het runDownloadTaskAsync() wordt. Hoe snel kan je dat doen?"
"Nou, eerst moet je de naam van de methode veranderen, dan alle plaatsen in het programma zoeken waar die methode wordt aangeroepen, en daar ook de naam veranderen."
'En hoe zou je die plekken vinden?'
"Ik zou gewoon het programma draaien en IntelliJ IDEA zou me alle plaatsen laten zien waar een niet-bestaande methode wordt aangeroepen."
"Oké. Maar stel nu dat elke methode een verklarend commentaar (JavaDoc) heeft dat uitlegt wat de methode doet - en dat de oude naam van de methode daar is geschreven."
"Ik zou de opmerkingen ook veranderen."
"Maar er kunnen ook variabelen zijn waarvan de naam is gekoppeld aan de naam van de methode. Het zou goed zijn om die ook te veranderen:"
| Voor | Na |
|---|---|
|
|
"Ja, het zou goed zijn om ook de namen van die variabelen te veranderen. Het zou geen kwaad kunnen."
"Nou, dit kan allemaal in slechts een paar seconden worden gedaan met behulp van IntelliJ IDEA!"
"U plaatst de cursor op de naam van de methode (of klikt erop met de muis), en drukt dan op Shift+F6 en begint gewoon de gewenste methodenaam te typen."
"Hier is een voorbeeld van het bewerken van een methodenaam."
"Beginnen met bewerken:"
"Geef een nieuwe naam op:"
"Voer gewoon een nieuwe naam in, druk op enter, en dat is alles. Deze methode zal overal in het project worden hernoemd."
"IntelliJ IDEA vraagt meestal ook of je variabelenamen en methodenamen in opmerkingen wilt hernoemen. Klik gewoon op 'Ja' en alles zal veranderen."
"Bovendien, als het project vóór deze refactoring-operatie is gecompileerd, is het gegarandeerd dat het na de refactoring wordt gecompileerd."
"Klinkt veelbelovend."
"Trouwens, je kunt variabelenamen op dezelfde manier wijzigen. Nadat je op een naam hebt geklikt, druk je gewoon op Shift+F6 - je kunt dan een nieuwe naam invoeren en IntelliJ verandert de naam van de variabele waar deze ook wordt gebruikt. "
"Als de variabele een veld in een klasse is en een getter en een setter heeft, dan zullen de namen van de getter en setter ook worden gewijzigd om overeen te komen met de nieuwe naam van de variabele."
"Ik heb het geprobeerd met variabelen. Alles werkt precies zoals je zei, Ellie. Refactoring is geweldig!"
"Denk je dat dat alles is wat refactoring te bieden heeft? Refractoring is zo'n breed onderwerp - we zijn nog niet eens aan de oppervlakte gekomen."
"Wauw. Wat is er nog meer?"
Goocheltruc #2: Extraheer een variabele.
"Soms worden bepaalde uitdrukkingen zo vaak herhaald in code dat je ze naar een aparte variabele wilt verplaatsen. Bijvoorbeeld:"
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."
"En code kan veel gecompliceerder zijn, met veel herhaalde delen."
"Programmeurs schrijven het niet met opzet op die manier. Maar je zult vaak iets aan een methode moeten toevoegen, en dan iets anders - en na verloop van tijd stijgt het aantal herhalingen enorm."
"Door een aparte variabele te maken, kunnen we deze een goede naam geven en de leesbaarheid van de code verbeteren."
"In het bovenstaande voorbeeld hebben we het bijvoorbeeld misschien niet over een huisadres. Misschien hebben we het over het adres van een contactpersoon voor noodgevallen. Dan zou je deze variabele emergencyContactAddress kunnen noemen in plaats van alleen adres. Dan zou een programmeur als je deze code voor het eerst ziet, begrijp je wat hier aan de hand is."
"Ja, daar ben ik het mee eens. Het is logisch om zulke variabelen toe te voegen."
"Dus, hoe doe je dat?"
"Het verplaatsen van een uitdrukking naar een afzonderlijke variabele is heel eenvoudig."
Stap 1: Gebruik de muis om de uitdrukking te selecteren.
Stap 2: Druk op Ctrl+Alt+V
"Er wordt een venster geopend waarin IntelliJ IDEA ons vraagt of we alleen de geselecteerde uitdrukking of alle instanties van de uitdrukking (4 keer) willen vervangen?"
"Selecteer de tweede optie om alle exemplaren te vervangen (Vervang alle 4 exemplaren)"
Stap 3: druk op Enter.
"IntelliJ IDEA zal je vragen een variabelenaam in te voeren. Het zal ook zijn eigen suggestie voor de naam doen. Niet slecht, hè?"
"Uh-huh. Precies. We waren ook van plan om de variabele 'adres' een naam te geven. Hoe wist het dat?"
"Door de naam van de laatste methode in de uitdrukking te gebruiken, die een adres retourneert. Het is dus waarschijnlijk dat de variabele zal worden gebruikt om een adres op te slaan."
'Dat is heel goed gelukt. Geweldig spul, Ellie.'
Goocheltruc #3: extraheer code in een aparte methode.
"Maar we hadden iets anders kunnen doen. We hadden een nieuwe methode kunnen declareren, bijvoorbeeld printAddress (), en al deze code erin kunnen verplaatsen."
"Laten we dat proberen."
Stap 1: Selecteer de 4 regels code die de adresvariabele gebruiken:
Stap 2: druk op Ctrl+Alt+M
"IntelliJ IDEA bepaalt welke variabelen de methode nodig heeft en stelt voor hoe deze eruit moet zien. "Het enige dat overblijft is een naam voor de methode in te voeren."
Stap 3: Voer printAddress in als de naam van de methode en druk op Enter.
"Wat vind je daarvan?"
"Het is geweldig. Niet alleen heeft IntelliJ IDEA de code in een aparte methode geëxtraheerd, het heeft ook alle vereiste variabelen toegevoegd. Bovendien raadde het alle namen correct."
GO TO FULL VERSION