Refaktorálás az Eclipse-ben

1. Áttekintés

A refactoring.com oldalon azt olvashattuk, hogy „a refaktorozás fegyelmezett technika egy meglévő kódrész szerkezetének átalakítására, annak belső szerkezetének megváltoztatására a külső viselkedés megváltoztatása nélkül”.

Jellemzően átnevezhetjük a változókat vagy módszereket, vagy a tervezési minták bevezetésével objektum-orientáltabbá tehetjük a kódunkat. A modern IDE-k számos beépített funkcióval rendelkeznek, amelyek segítenek elérni az ilyen típusú és sok más refactoring célt.

Ebben az oktatóanyagban az Eclipse, egy ingyenes, népszerű Java IDE javítására fogunk összpontosítani.

Mielőtt hozzákezdenénk a refaktoráláshoz, tanácsos egy szilárd tesztcsomagot készíteni annak ellenőrzésére, hogy az újrafaktorozás során nem törtünk-e meg semmit.

2. Átnevezés

2.1. A változók és módszerek átnevezése

Tudunk nevezze át a változókat és módszereket az alábbi egyszerű lépések végrehajtásával:

    • Válassza ki az elemet
    • Kattintson a jobb gombbal az elemre
    • Kattints a Refaktor> Átnevezés választási lehetőség
  • Írja be az új nevet
  • nyomja meg Belép

A második és a harmadik lépést is elvégezhetjük a gyorsbillentyűt használva, Alt + Shift + R.

A fenti művelet végrehajtása után az Eclipse megtalálja az adott elem minden használatát a fájlban, és mindet a helyére cseréli.

Használhatunk egy speciális funkciót is a frissítse a referenciát más osztályokban az egérrel az elem fölé viszi, amikor a refaktor be van kapcsolva, és rákattint Opciók:

Ez megnyit egy felugró ablakot, ahol átnevezhetjük a változót vagy a metódust, és lehetőségünk van frissíteni a referenciát más osztályokban:

2.2. Csomagok átnevezése

Átnevezhetünk egy csomagot úgy, hogy kiválasztjuk a csomag nevét, és ugyanazokat a műveleteket hajtjuk végre, mint az előző példában. Rögtön megjelenik egy előugró ablak, ahol átnevezhetjük a csomagot, olyan lehetőségekkel, mint a hivatkozások frissítése és az alcsomagok átnevezése.

Átnevezhetjük a csomagot is a Project Explorer nézetből az F2 megnyomásával:

2.3. Osztályok és interfészek átnevezése

Átnevezhetünk egy osztályt vagy felületet ugyanazokkal a műveletekkel, vagy csak a megnyomásával F2 a Project Explorer alkalmazásból. Ez egy előugró ablakot nyit meg a referenciák frissítésének lehetőségeivel, valamint néhány speciális beállítással:

3. Kivonás

Most beszéljünk a kitermelésről. A kód kibontása azt jelenti vesz egy darab kódot és áthelyezi.

Például kibonthatunk egy kódot egy másik osztályba, szuperosztályba vagy interfészbe. Akár kódot is kivonhatunk ugyanabba az osztályba tartozó változóhoz vagy módszerhez.

Az Eclipse különféle módszereket kínál az extrakciók elérésére, amelyet a következő szakaszokban bemutatunk.

3.1. Kivonat osztály

Tegyük fel, hogy a következők vannak Autó osztály kódbázisunkban:

public class Car {private String licensePlate; private String driverName; privát String driverLicense; public String getDetails () {return "Autó [licensePlate =" + licensePlate + ", driverName =" + driverName + ", driverLicense =" + driverLicense + "]"; } // szerelők és beállítók}

Tegyük fel, hogy az illesztőprogram részleteit egy másik osztályba akarjuk vonni. Ezt megtehetjük Kattintson a jobb gombbal az osztályon belül bárhová, és válassza a Refaktor> Kivonat osztály választási lehetőség:

Ez megnyit egy előugró ablakot, ahol megnevezhetjük az osztályt, és kiválaszthatjuk az áthelyezendő mezőket néhány további lehetőség mellett:

A továbblépés előtt megtekinthetjük a kódot is. Amikor rákattintunk rendben, Az Eclipse új osztályt hoz létre Sofőr, és az előző kódot a következőkre fogjuk átalakítani:

public class Car {private String licensePlate; private Driver driver = új illesztőprogram (); public String getDetails () {return "Autó [licensePlate =" + licensePlate + ", driverName =" + driver.getDriverName () + ", driverLicense =" + driver.getDriverLicense () + "]"; } // szerelők és beállítók}

3.2. Extract Interface

Az interfészt is hasonló módon tudjuk kibontani. Tegyük fel, hogy a következők állnak rendelkezésünkre EmployeeService osztály:

public class EmployeeService {public void save (Employee emp) {} public void delete (Employee emp) {} public void sendEmail (List ids, String message) {}}

Egy interfészt kibonthatunk Kattintson a jobb gombbal az osztályon belül bárhová, és válassza a Refactor> Extract Interface választási lehetőség, vagy használhatjuk a Alt + Shift + T parancsikon a menü közvetlen megjelenítéséhez:

Ez egy előugró ablakot nyit, ahol megadhatjuk a felület nevét, és eldönthetjük, mely tagokat deklaráljuk a felületen:

A visszafejlesztés eredményeként lesz egy felületünk IEmpService, és a mi EmployeeService osztály is változik:

public class EmployeeService megvalósítja az IEmpService szolgáltatást {@Orride public void save (Employee emp) {} @Orride public void delete (Employee emp) {} public void sendEmail (List ids, String message) {}}

3.3. Kivonat szuperosztály

Tegyük fel, hogy van egy Munkavállaló osztály, amely számos tulajdonságot tartalmaz, amelyek nem feltétlenül szólnak az adott személy foglalkoztatásáról:

public class Alkalmazott {private String név; privát int kor; privát int tapasztalatokHónapok; public String getName () {return név; } public int getAge () {visszatérési kor; } public int getExperienceInMonths () {return experienceInMonths; }}

Érdemes kivonni a nem foglalkoztatással kapcsolatos tulajdonságokat a Személy szuperosztály. Az elemek szuperosztályba történő kibontásához megtehetjük Kattintson a jobb gombbal az osztály bármely pontjára, és válassza a ikont Refaktor> Kivonat szuperosztály opciót, vagy használja az Alt + Shift + T billentyűkombinációt a menü közvetlen megjelenítéséhez:

Ez létrehoz egy újat Személy osztály a kiválasztott változókkal és módszerrel, valamint a Munkavállaló osztály átalakításra kerül:

public class Alkalmazott kiterjeszti Person {private int experienceInMonths; public int getExperienceInMonths () {return experienceInMonths; }}

3.4. Kivonási módszer

Előfordulhat, hogy a módszerünkben egy bizonyos kódrészletet egy másik módszerre szeretnénk kinyerni, hogy a kódunk tiszta és könnyen karbantartható legyen.

Tegyük fel például, hogy van egy for ciklus beágyazva a módszerünkbe:

public class Test {public static void main (String [] args) {for (int i = 0; i <args.hossz; i ++) {System.out.println (args [i]); }}}

A Kivonási módszer varázsló, a következő lépéseket kell végrehajtanunk:

  • Válassza ki a kivonni kívánt kódsorokat
  • Kattintson a jobb gombbal a kijelölt területre
  • Kattints a Refaktor> Kivonási módszer választási lehetőség

Az utolsó két lépést billentyűparancs segítségével is el lehet érni Alt + Shift + M. Lássuk a Kivonási módszer párbeszéd:

Ez átalakítja kódunkat:

public class Test {public static void main (String [] args) {printArgs (args); } private static void printArgs (String [] args) {for (int i = 0; i <args.hossz; i ++) {System.out.println (args [i]); }}}

3.5. Kivonat helyi változók

Bizonyos elemeket helyi változóként vonhatunk ki, hogy kódunk olvashatóbbá váljon.

Ez hasznos, ha van egy Húr szó szerinti:

public class Test {public static void main (String [] args) {System.out.println ("Passlazy argumentumok száma" src = "// www.baeldung.com/wp-content/uploads/2019/06/Eclipse- refactor-21.png ">

Az utolsó lépést a billentyűparancs segítségével is el lehet érni Alt + Shift + L. Most kibonthatjuk a helyi változónkat:

És íme ennek az átalakításnak az eredménye:

public class Test {public static void main (String [] args) {final String prefix = "Argumentumok száma passextracting-constants"> 3.6. Kivonat állandó

Vagy kinyerhetjük a kifejezéseket és a szó szerinti értékeket statikus döntő osztály attribútumai.

Kitermelhetnénk a 3.14 értéket egy helyi változóba, amint éppen láttuk:

nyilvános osztály MathUtil {nyilvános kettős kerület (dupla sugár) {visszatér 2 * 3,14 * sugár; }}

De lehet, hogy jobb, ha konstansként vonjuk ki, amihez meg kell:

  • Válassza ki az elemet
  • Kattintson a jobb gombbal, és válassza a lehetőséget Refactor> Extract Constant

Ez megnyit egy párbeszédablakot, ahol megadhatjuk az állandó nevét és beállíthatjuk annak láthatóságát, valamint néhány további lehetőséget:

A kódunk kissé olvashatóbbnak tűnik:

nyilvános osztály MathUtil {privát statikus végső kettős PI = 3,14; nyilvános kettős kerület (dupla sugár) {visszatér 2 * PI * sugár; }}

4. Bélés

A másik irányba is mehetünk, és beágyazhatjuk a kódot.

Fontolja meg a Util osztály, amelynek csak egyszer használatos helyi változója van:

public class Util {public void isNumberPrime (int num) {logikai eredmény = isPrime (num); if (eredmény) {System.out.println ("A szám elsődleges"); } else {System.out.println ("A szám nem elsődleges"); }} // isPrime módszer} 

El akarjuk távolítani a eredmény helyi változó, és illessze be a isPrime módszer hívása. Ehhez kövesse az alábbi lépéseket:

  • Válassza ki a beilleszteni kívánt elemet
  • Kattintson a jobb gombbal és válaszd a Refactor> Inline választási lehetőség

Az utolsó lépést billentyűparancs segítségével is el lehet érni Alt + Shift + I:

Utána van még egy változónk, hogy nyomon kövessük:

public class Util {public void isNumberPrime (int num) {if (isPrime (num)) {System.out.println ("A szám elsődleges"); } else {System.out.println ("A szám nem elsődleges"); }} // isPrime módszer}

5. Nyomja le és húzza fel

Ha van egy szülő-gyermek kapcsolatunk (hasonlóan az előzőhöz Munkavállaló és Személy példa) az osztályaink között, és bizonyos módszereket vagy változókat szeretnénk mozgatni közöttük, használhatjuk az Eclipse által biztosított push / pull opciókat.

Ahogy a neve is mutatja, a Nyomja le opció metódusokat és mezőket áthelyez egy szülő osztályból az összes gyermek osztályba, míg a Felhúz A módszereket és mezőket egy adott gyermekosztályról szülővé teszi, ezáltal a módszer elérhetővé válik az összes gyermekosztály számára.

Ahhoz, hogy a módszereket a gyermekosztályokba lehozzuk, meg kell tennünk Kattintson a jobb gombbal az osztály bármely pontjára, és válassza a ikont Refaktor> Nyomja le választási lehetőség:

Ez megnyit egy varázslót, ahol kiválaszthatjuk a lenyomandó elemeket:

Hasonlóképpen, a módszerek gyermekosztályból szülő osztályba való áthelyezéséhez meg kell Kattintson a jobb gombbal az osztály bármely pontjára, és válassza a lehetőséget Refaktor> Húzza fel:

Ez megnyit egy hasonló varázslót, ahol kiválaszthatjuk a felhúzandó elemeket:

6. Módszer aláírásának módosítása

Meglévő módszer metódus-aláírásának megváltoztatásához néhány egyszerű lépést követhetünk:

  • Válassza ki a módszert, vagy helyezze a kurzort valahova belül
  • Kattintson a jobb gombbal, és válassza a lehetőséget Refactor> Módszer aláírásának módosítása

Az utolsó lépést billentyűparancs segítségével is el lehet érni Alt + Shift + C.

Ez megnyit egy felugró ablakot, ahol ennek megfelelően módosíthatja a metódus aláírását:

7. Mozgás

Néha egyszerűen csak szeretnénk helyezze át a metódusokat egy másik létező osztályba a kódunk objektum-orientáltabbá tétele érdekében.

Vizsgáljuk meg azt a forgatókönyvet, ahol a Film osztály:

public class Film {private String title; magán dupla ár; privát MovieType típus; // egyéb módszerek}

És MovieType egyszerű leírás:

public enum MovieType {ÚJ, SZABÁLYOS}

Tegyük fel azt is, hogy követelményünk van arra, hogy ha a Vevő filmet bérel, ami ÚJ, két dollárral többet kell fizetni, és hogy a mi Vevő osztálynak a következő logikája van a összköltsége():

public class Ügyfél {private String name; privát String cím; privát listás filmek; public double totalCost () {kettős eredmény = 0; for (Film film: filmek) {eredmény + = filmKöltség (film); } visszatérési eredmény; } privát dupla filmKöltség (Film film) {if (film.getType () .egyenlő (MovieType.NEW)) {return 2 + movie.getPrice (); } return movie.getPrice (); } // egyéb módszerek}

Nyilvánvaló, hogy a film költségének kiszámítása a MovieType megfelelőbben kerülne a Film osztály és nem a Vevő osztály. Ezt a számítási logikát könnyen mozgathatjuk az Eclipse programban:

  • Válassza ki az áthelyezni kívánt vonalakat
  • Kattintson a jobb gombbal, és válassza a ikont Refaktor> Mozgás választási lehetőség

Az utolsó lépést billentyűparancs segítségével is el lehet érni Alt + Shift + V:

Az Eclipse elég okos ahhoz, hogy rájöjjön, ennek a logikának a miénkben kell lennie Film osztály. Megváltoztathatjuk a metódus nevét, ha akarjuk, más speciális opciókkal együtt.

A végső Vevő osztálykódot átalakítják a következőkre:

public class Ügyfél {private String name; privát String cím; privát listás filmek; public double totalCost () {kettős eredmény = 0; for (Film film: filmek) {eredmény + = film.movieCost (); } visszatérési eredmény; } // egyéb módszerek}

Mint láthatjuk, a filmKöltség módszer a mi Film osztályban, és a refraktorban használják Vevő osztály.

8. Következtetés

Ebben az oktatóanyagban megvizsgáltuk az Eclipse által biztosított főbb refaktorálási technikákat. Néhány alapvető refaktúrával kezdtük, például átnevezéssel és kivonással. Később mozgó módszereket és mezőket láttunk különböző osztályok körül.

Ha többet szeretne megtudni, mindig hivatkozhatunk az Eclipse hivatalos dokumentációjára a refaktorálásról.


$config[zx-auto] not found$config[zx-overlay] not found