streamalism.org

1. Overzicht

Op refactoring.com lezen we dat "refactoring een gedisciplineerde techniek is voor het herstructureren van een bestaande code, waarbij de interne structuur wordt gewijzigd zonder het externe gedrag te veranderen."

Meestal willen we variabelen of methoden hernoemen, of we willen onze code meer objectgeoriënteerd maken door ontwerppatronen te introduceren. Moderne IDE's hebben veel ingebouwde functies om ons te helpen dit soort refactoring-doelstellingen en vele andere te bereiken.

In deze tutorial zullen we ons concentreren op refactoring in Eclipse, een gratis populaire Java IDE.

Voordat we beginnen met refactoring, is het raadzaam om een ​​solide reeks tests te hebben om te controleren of we niets hebben gebroken tijdens het refactoren.

2. Hernoemen

2.1. Variabelen en methoden hernoemen

Wij kunnen hernoem variabelen en methoden door deze eenvoudige stappen te volgen:

• • Selecteer het element
  • Klik met de rechtermuisknop op het element
  • Klik op de Refactor> Hernoemen keuze

• Typ de nieuwe naam
• druk op Enter

We kunnen ook de tweede en derde stap uitvoeren door met de sneltoets, Alt + Shift + R.

Wanneer de bovenstaande actie wordt uitgevoerd, zal Eclipse elk gebruik van dat element in dat bestand vinden en ze allemaal op hun plaats vervangen.

We kunnen ook een geavanceerde functie gebruiken om update de referentie in andere klassen door over het item te bewegen wanneer de refactor is ingeschakeld en op te klikken Opties:

Dit opent een pop-up waarin we zowel de variabele of methode kunnen hernoemen als de optie hebben om de referentie in andere klassen bij te werken:

2.2. Pakketten hernoemen

We kunnen een pakket hernoemen door de pakketnaam te selecteren en dezelfde acties uit te voeren als in het vorige voorbeeld. Er verschijnt meteen een pop-up waarin we het pakket kunnen hernoemen, met opties zoals het bijwerken van referenties en het hernoemen van subpakketten.

We kunnen het pakket ook hernoemen vanuit de projectverkenner door op F2 te drukken:

2.3. Hernoemen van klassen en interfaces

We kunnen een klasse of interface hernoemen door dezelfde acties te gebruiken of door gewoon op te drukken F2 van Project Explorer. Dit opent een pop-up met opties om referenties bij te werken, samen met een paar geavanceerde opties:

3. Extractie

Laten we het nu hebben over extractie. Het extraheren van code betekent een stukje code nemen en het verplaatsen.

We kunnen bijvoorbeeld code extraheren in een andere klasse, superklasse of interface. We kunnen zelfs code extraheren naar een variabele of methode in dezelfde klasse.

Eclipse biedt een verscheidenheid aan manieren om extracties te bereiken, die we in de volgende secties zullen demonstreren.

3.1. Extract Klasse

Stel dat we het volgende hebben Auto klasse in onze codebase:

openbare klasse Car {private String licensePlate; private String driverName; privé String driverLicense; openbare String getDetails () {return "Car [licensePlate =" + licensePlate + ", driverName =" + driverName + ", driverLicense =" + driverLicense + "]"; } // getters en setters}

Stel nu dat we de details van de bestuurder naar een andere klasse willen extraheren. We kunnen dit doen door met de rechtermuisknop ergens in de klas klikken en het Refactor> Klasse extraheren keuze:

Dit opent een pop-up waarin we de klasse een naam kunnen geven en selecteren welke velden we willen verplaatsen, samen met enkele andere opties:

We kunnen ook een voorbeeld van de code bekijken voordat we verder gaan. Als we klikken OK, Zal Eclipse een nieuwe klasse aanmaken met de naam Bestuurder, en de vorige code zal worden geherstructureerd naar:

openbare klasse Car {private String licensePlate; private Driver driver = nieuwe Driver (); openbare String getDetails () {return "Car [licensePlate =" + licensePlate + ", driverName =" + driver.getDriverName () + ", driverLicense =" + driver.getDriverLicense () + "]"; } // getters en setters}

3.2. Extraheer de interface

We kunnen ook een interface op een vergelijkbare manier extraheren. Stel dat we het volgende hebben Medewerker Service klasse:

public class EmployeeService {public void save (Employee emp) {} public void delete (Employee emp) {} public void sendEmail (lijst-id's, String bericht) {}}

We kunnen een interface extraheren door met de rechtermuisknop ergens in de klas klikken en het Refactor> Interface extraheren keuze, of we kunnen de Alt + Shift + T sneltoetsopdracht om het menu direct te openen:

Dit opent een pop-up waarin we de interfacenaam kunnen invoeren en kunnen beslissen welke leden we in de interface willen declareren:

Als resultaat van deze herstructurering hebben we een interface IEmpService, en onze Medewerker Service klasse wordt ook gewijzigd:

public class EmployeeService implementeert IEmpService {@Override public void save (Employee emp) {} @Override public void delete (Employee emp) {} public void sendEmail (List id's, String message) {}}

3.3. Extract superklasse

Stel dat we een Werknemer klasse met verschillende eigenschappen die niet noodzakelijk over het dienstverband van de persoon gaan:

openbare klasse Werknemer {privé Stringnaam; privé int leeftijd; privé int experienceInMonths; public String getName () {retournaam; } public int getAge () {terugkeerleeftijd; } public int getExperienceInMonths () {return experienceInMonths; }}

Mogelijk willen we de niet-werkgerelateerde eigendommen extraheren naar een Persoon superklasse. Om items naar een superklasse te extraheren, kunnen we klik met de rechtermuisknop ergens in de klas en kies het Refactor> Superklasse extraheren optie, of gebruik Alt + Shift + T om het menu direct te openen:

Dit zal een nieuw Persoon klasse met onze geselecteerde variabelen en methode, en de Werknemer klasse zal worden geherstructureerd naar:

public class Medewerker verlengt Persoon {privé int experienceInMonths; public int getExperienceInMonths () {return experienceInMonths; }}

3.4. Extractiemethode

Soms willen we een bepaald stuk code in onze methode extraheren naar een andere methode om onze code schoon en gemakkelijk te onderhouden te houden.

Laten we bijvoorbeeld zeggen dat we een for-lus hebben ingebed in onze methode:

openbare klasse Test {openbare statische leegte hoofd (String [] args) {for (int i = 0; i <args.length; i ++) {System.out.println (args [i]); }}}

Om het Extractiemethode wizard, moeten we de volgende stappen uitvoeren:

• Selecteer de regels code die we willen extraheren
• Klik met de rechtermuisknop op het geselecteerde gebied
• Klik op de Refactor> Extractiemethode keuze

De laatste twee stappen kunnen ook worden bereikt met een sneltoets Alt + Shift + M. Laten we eens kijken naar de Extractiemethode dialoog:

Dit zal onze code refactoren naar:

openbare klasse Test {openbare statische leegte hoofd (String [] args) {printArgs (args); } private static void printArgs (String [] args) {for (int i = 0; i <args.length; i ++) {System.out.println (args [i]); }}}

3.5. Extraheer lokale variabelen

We kunnen bepaalde items extraheren als lokale variabelen om onze code leesbaarder te maken.

Dit is handig als we een Draad letterlijk:

public class Test {public static void main (String [] args) {System.out.println ("Number of Arguments passinglazy" src = "// www.baeldung.com/wp-content/uploads/2019/06/Eclipse- refactor-21.png ">
De laatste stap kan ook worden bereikt met de sneltoets Alt + Shift + L. Nu kunnen we onze lokale variabele extraheren:
En hier is het resultaat van deze herstructurering:
public class Test {public static void main (String [] args) {final String prefix = "Aantal argumenten passedextracting-constants"> 3.6. Extract Constant
Of we kunnen uitdrukkingen en letterlijke waarden extraheren naar statische finale class attributen.
We kunnen het 3.14 waarde in een lokale variabele, zoals we zojuist hebben gezien:
openbare klasse MathUtil {openbare dubbele omtrek (dubbele straal) {retour 2 * 3.14 * straal; }}
Maar het is misschien beter om het als een constante te extraheren, waarvoor we:
Selecteer het item
Klik met de rechtermuisknop en kies Refactor> Extract constante
Dit opent een dialoogvenster waarin we de constante een naam kunnen geven en de zichtbaarheid ervan kunnen instellen, samen met een aantal andere opties:
Nu ziet onze code er iets beter leesbaar uit:
openbare klasse MathUtil {privé statische laatste dubbele PI = 3.14; openbare dubbele omtrek (dubbele straal) {retour 2 * PI * straal; }}
4. Inlining
We kunnen ook de andere kant op gaan en inline code.
Overweeg een Util klasse met een lokale variabele die maar één keer wordt gebruikt:
public class Util {public void isNumberPrime (int num) {booleaans resultaat = isPrime (num); if (resultaat) {System.out.println ("Number is Prime"); } else {System.out.println ("Nummer is niet primair"); }} // isPrime-methode} 
We willen de resultaat lokale variabele en inline de isPrime methode oproep. Om dit te doen, volgen we deze stappen:
Selecteer het item dat we inline willen
Klik met de rechtermuisknop op en kies de Refactor> Inline keuze
De laatste stap kan ook worden bereikt door middel van een sneltoets Alt + Shift + I:
Daarna hebben we één variabele minder om bij te houden:
public class Util {public void isNumberPrime (int num) {if (isPrime (num)) {System.out.println ("Number is Prime"); } else {System.out.println ("Nummer is niet primair"); }} // isPrime-methode}
5. Omlaag duwen en omhoog trekken
Als we een ouder-kindrelatie hebben (zoals onze vorige Werknemer en Persoon voorbeeld) tussen onze klassen, en we willen bepaalde methoden of variabelen ertussen verplaatsen, kunnen we de push / pull-opties van Eclipse gebruiken.
Zoals de naam doet vermoeden, is de Neerduwen optie verplaatst methoden en velden van een bovenliggende klasse naar alle onderliggende klassen, while Optrekken verplaatst methoden en velden van een bepaalde child-klasse naar de parent, waardoor die methode beschikbaar wordt voor alle child-klassen.
Om methoden naar onderliggende klassen te verplaatsen, moeten we dat doen klik met de rechtermuisknop ergens in de klas en kies het Refactor> Omlaag duwen keuze:
Dit opent een wizard waarin we items kunnen selecteren om naar beneden te duwen:
Evenzo moeten we voor het verplaatsen van methoden van een kindklasse naar een bovenliggende klasse klik met de rechtermuisknop ergens in de klas en kies Refactor> Pull Up:
Dit opent een vergelijkbare wizard waarin we items kunnen selecteren om te openen:
6. Een methodehandtekening wijzigen
Om de methodehandtekening van een bestaande methode te wijzigen, kunnen we een paar eenvoudige stappen volgen:
Selecteer de methode of plaats de cursor ergens binnenin
Klik met de rechtermuisknop en kies Refactor> Handtekening methode wijzigen
De laatste stap kan ook worden bereikt door middel van een sneltoets Alt + Shift + C.
Hierdoor wordt een pop-up geopend waarin u de handtekening van de methode dienovereenkomstig kunt wijzigen:
7. Verhuizen
Soms willen we het gewoon verplaats methoden naar een andere bestaande klasse om onze code meer objectgeoriënteerd te maken.
Overweeg het scenario waarin we een Film klasse:
public class Movie {private String-titel; particuliere dubbele prijs; privé MovieType-type; // andere methodes }
En MovieType is een simpele opsomming:
openbare enum MovieType {NEW, REGULAR}
Stel ook dat we een vereiste hebben dat als a Klant huurt een film dat is NIEUW, zal er twee dollar meer in rekening worden gebracht, en dat onze Klant klasse heeft de volgende logica om de totale prijs():
openbare klasse Klant {privé Stringnaam; privé String-adres; privélijst films; openbare dubbele totalCost () {dubbel resultaat = 0; voor (Movie movie: movies) {result + = movieCost (movie); } resultaat teruggeven; } privé dubbele movieCost (filmfilm) {if (movie.getType () .equals (MovieType.NEW)) {return 2 + movie.getPrice (); } return movie.getPrice (); } // andere methodes }
Het is duidelijk dat de berekening van de filmkosten op basis van de MovieType zou beter in de Film klasse en niet de Klant klasse. We kunnen deze rekenlogica gemakkelijk verplaatsen in Eclipse:
Selecteer de lijnen die u wilt verplaatsen
Klik met de rechtermuisknop en kies het Refactor> Verplaatsen keuze
De laatste stap kan ook worden bereikt met een sneltoets Alt + Shift + V:
Eclipse is slim genoeg om te beseffen dat deze logica in ons zou moeten zitten Film klasse. We kunnen de naam van de methode wijzigen als we dat willen, samen met andere geavanceerde opties.
De laatste Klant klassecode zal worden geherstructureerd naar:
openbare klasse Klant {privé Stringnaam; privé String-adres; privélijst films; openbare dubbele totalCost () {dubbel resultaat = 0; voor (Movie movie: movies) {result + = movie.movieCost (); } resultaat teruggeven; } // andere methodes }
Zoals we kunnen zien, is de movieCost methode is verplaatst naar onze Film class en wordt gebruikt in de refactored Klant klasse.
8. Conclusie
In deze tutorial hebben we gekeken naar enkele van de belangrijkste refactoring-technieken die door Eclipse worden geleverd. We zijn begonnen met een aantal elementaire refactoring, zoals hernoemen en extraheren. Later zagen we bewegende methoden en velden rond verschillende klassen.
Voor meer informatie kunnen we altijd de officiële Eclipse-documentatie over refactoring raadplegen.