streamalism.org

1. Áttekintés

A kód rendben tartása nem mindig egyszerű. Szerencsénkre az IDE-k manapság elég okosak és segíthetnek ebben. Ebben az oktatóanyagban az IntelliJ IDEA-ra, a JetBrains Java kódszerkesztőre koncentrálunk.

Látni fogunk néhány funkciót, amelyet a szerkesztő kínál a refaktorkódhoz, a változók átnevezésétől a metódus aláírás megváltoztatásáig.

2. Átnevezés

2.1. Alapvető átnevezés

Először is kezdjük az alapokkal: az átnevezéssel. Az IntelliJ lehetőséget kínál arra, hogy átnevezzük kódunk különböző elemeit: típusokat, változókat, módszereket és akár csomagokat is.

Egy elem átnevezéséhez kövesse az alábbi lépéseket:

• Kattintson a jobb gombbal az elemre
• Indítsa el a Refaktor> Átnevezés választási lehetőség
• Írja be az új elem nevét
• nyomja meg Belép

Mellesleg, az első két lépést az elem kiválasztásával és megnyomásával pótolhatjuk Shift + F6.

Kiváltásakor az átnevezési művelet megtörténik keressen a kódban az elem minden használatához, majd változtassa meg őket a megadott értékkel.

Képzeljük el a SimpleClass osztály rosszul megnevezett összeadási módszerrel, someAdditionMethod, hívta a fő- módszer:

public class SimpleClass {public static void main (String [] args) {new SimpleClass (). someAdditionMethod (1, 2); } public int someAdditionMethod (int a, int b) {return a + b; }}

Így ha ezt a módszert átnevezzük hozzá, Az IntelliJ a következő kódot állítja elő:

public class SimpleClass () {public static void main (String [] args) {new SimpleClass (). add (1, 2); } public int add (int a, int b) {return a + b; }}

2.2. Haladó átnevezés

Az IntelliJ azonban többet tesz, mint elemeink kódhasználatait keresni és átnevezni. Ami azt illeti, még néhány lehetőség áll rendelkezésre. IntelliJ kereshet eseményeket a megjegyzésekben és a karakterláncokban, sőt olyan fájlokban is, amelyek nem tartalmaznak forráskódot. Ami a paramétereket illeti, az osztályhierarchiában átnevezheti őket felülbírált módszerek esetén.

Ezek a lehetőségek ütéssel érhetők el Shift + F6 még egyszer, mielőtt átneveznénk elemünket, és megjelenik egy felugró ablak:

A Keresés megjegyzésekben és karakterláncokban opció minden átnevezéshez elérhető. Ami a Szöveges előfordulások keresése opcióval, ez nem érhető el a módszer paraméterei és a helyi változók számára. Végül a Paraméterek átnevezése a hierarchiában opció csak a módszer paramétereihez érhető el.

Így, ha talál egyezést a két lehetőség egyikével, az IntelliJ megmutatja nekik, és felajánlja számunkra, hogy kiválasszon néhány változtatást (mondjuk abban az esetben, ha valami megfelel az átnevezésünkkel).

Adjunk hozzá néhány Javadoc-ot a módszerünkhöz, majd nevezzük át az első paraméterét, a:

/ ** * Összeadja a és b * @param a az első számot * @param b a második számot * / public int add (int a, int b) {...}

A megerősítő előugró ablakban az első opció bejelölésével az IntelliJ megegyezik a módszer Javadoc megjegyzésében szereplő paraméterek megemlítésével, és felajánlja azok átnevezését is:

/ ** * Összeadja az első számot és b * @param elsőszámot az első számhoz * @param b a második számot * / public int add (int első szám, int b) {...}

Végül meg kell jegyeznünk Az IntelliJ okos és többnyire felhasználásokat keres az átnevezett elem hatókörében. Esetünkben ez azt jelentené, hogy egy olyan megjegyzés, amely a módszeren kívül helyezkedik el (a dzsádók kivételével), és amely megemlítést tartalmaz a nem gondolták volna átnevezésre.

3. Kivonás

Most beszéljünk a kitermelésről. A kibontás lehetővé teszi számunkra, hogy megragadjunk egy darab kódot, és egy változóba, egy módszerbe vagy akár egy osztályba tegyük. Az IntelliJ ezt elég okosan kezeli, mivel hasonló kóddarabokat keres és felajánlja ugyanúgy kibontani őket.

Tehát ebben a szakaszban megtanuljuk, hogyan lehet kihasználni az IntelliJ által kínált extrakciós funkciót.

3.1. Változók

Először kezdjük a változók kinyerésével. Ez helyi változókat, paramétereket, mezőket és konstansokat jelent. A változó kibontásához ezeket a lépéseket kell követnünk:

• Válasszon egy kifejezést, amely elfér egy változóban
• Kattintson a jobb gombbal a kijelölt területre
• Indítsa el a Refaktor> Kivonat> Változó / Paraméter / Mező / Állandó választási lehetőség
• Válasszon a Csak ezt az esetet cserélje le vagy Cserélje le az összes x előfordulást lehetőségek, ha javasolják
• Írja be a kivont kifejezés nevét (ha a kiválasztott nem felel meg nekünk)
• nyomja meg Belép

Ami az átnevezést illeti, a menü használata helyett billentyűparancsok is használhatók. Az alapértelmezett parancsikonok: Ctrl + Alt + V, Ctrl + Alt + P, Ctrl + Alt + F és Ctrl + Alt + C.

Az IntelliJ megpróbálja kitalálni a kibontott kifejezés nevét annak alapján, hogy a kifejezés mit ad vissza. Ha nem felel meg az igényeinknek, akkor szabadon módosíthatjuk, mielőtt megerősítenénk az extrakciót.

Szemléltessünk egy példával. El tudnánk képzelni, hogy hozzáadunk egy módszert a sajátunkhoz SimpleClass osztály megmondja, hogy az aktuális dátum két megadott dátum között van-e:

public static boolean isNowBetween (LocalDate kezdőDátum, LocalDate befejezőDátum) {visszatérés LocalDate.now (). isAfter (kezdőDátum) && LocalDate.now (). isBefore (befejezőDátum); }

Tegyük fel, hogy változtatni akarunk a megvalósításunkon, mert használjuk LocalDate.now () kétszer, és szeretnénk megbizonyosodni arról, hogy mindkét értékelésnél pontosan ugyanaz az értéke. Csak válasszuk ki a kifejezést és vonjuk ki egy helyi változóba, Most:

Akkor, a mi LocalDate.now () a hívást egy helyi változó rögzíti:

public static boolean isNowBetween (LocalDate kezdőDátum, LocalDate befejezőDátum) {LocalDate most = LocalDate.now (); return now.isAfter (kezdőDátum) && now.isBefore (befejezőDátum); }

A Cserélje ki az összeset opciónál, megbizonyosodtunk arról, hogy mindkét kifejezést egyszerre cseréltük.

3.2. Mód

Most ellenőrizzük, hogyan lehet kibontani a módszereket az IntelliJ használatával:

• Válassza ki a létrehozni kívánt módszerhez illeszkedő kifejezés kifejezést vagy sorokat
• Kattintson a jobb gombbal a kijelölt területre
• Indítsa el a Refaktor> Kivonat> Módszer választási lehetőség
• Írja be a módszer adatait: annak nevét, láthatóságát és paramétereit
• nyomja meg Belép

Ütés Ctrl + Alt + M a módszer kiválasztása után a test is működik.

Használjuk újra az előző példánkat, és mondjuk azt, hogy szeretnénk egy módszert, amellyel ellenőrizhetjük, hogy van-e dátum a többi dátum között. Ezután csak ki kellene választanunk az utolsó sort a isNowBetween metódus és indítsa el a metódus kinyerési funkciót.

A megnyílt párbeszédpanelen láthatjuk, hogy az IntelliJ már észrevette a három szükséges paramétert: kezdő dátum, befejezőDátum és Most. Mivel azt akarjuk, hogy ez a módszer a lehető legáltalánosabb legyen, átnevezzük a metódust Most paraméter be dátum. A kohézió érdekében pedig az első paraméterként tesszük.

Végül nevet adunk a módszerünknek, isDateBetween, és fejezze be a kivonási folyamatot:

Ezután megkapjuk a következő kódot:

public static boolean isNowBetween (LocalDate kezdőDátum, LocalDate befejezőDátum) {LocalDate most = LocalDate.now (); return isDateBetween (most, kezdőDátum, befejezőDátum); } privát statikus logikai érték isDateBetween (LocalDate date, LocalDate startDate, LocalDate endDate) {return date.isBefore (endDate) && date.isAfter (startDate); }

Mint láthatjuk, a cselekvés váltotta ki az új létrehozását isDateBetween módszer, amelyet a isNowBetween módszer. A módszer alapértelmezés szerint privát. Természetesen ezen változtatni lehetett a láthatósági opcióval.

3.3. Osztályok

Mindezek után érdemes lehet megszerezni a dátummal kapcsolatos módszereinket egy adott osztályban, a dátumkezelésre összpontosítva, mondjuk: DateUtils. Ez megint nagyon egyszerű:

• Kattintson a jobb gombbal azon az osztályon, amelynek elemei vannak, amelyeket át akarunk helyezni
• Indítsa el a Refactor> Extract> Delegate választási lehetőség
• Írja be az osztály adatait: a nevét, a csomagját, a delegálandó elemeket, az elemek láthatóságát
• nyomja meg Belép

Alapértelmezés szerint nem érhető el gyorsbillentyű ehhez a funkcióhoz.

Tegyük fel, hogy a szolgáltatás aktiválása előtt hívjuk meg a dátumhoz kapcsolódó metódusokat a fő- módszer:

isNowBetween (LocalDate.MIN, LocalDate.MAX); isDateBetween (LocalDate.of (2019, 1, 1), LocalDate.MIN, LocalDate.MAX);

Ezután ezt a két módszert delegáljuk a DateUtils osztály a küldött opció használatával:

A szolgáltatás kiváltása a következő kódot eredményezi:

public class DateUtils {public static logikai isNowBetween (LocalDate kezdőDátum, LocalDate befejezőDátum) {LocalDate most = LocalDate.now (); return isDateBetween (most, kezdőDátum, befejezőDátum); } public static boolean isDateBetween (LocalDate date, LocalDate kezdőDátum, LocalDate befejezőDátum) {return date.isBefore (befejezőDátum) && date.isAfter (kezdőDátum); }}

Láthatjuk, hogy a isDateBetween módszer készült nyilvános. Ez annak a láthatósági opciónak az eredménye, amelynek értéke: eszkalálódnak alapértelmezés szerint. Eszkalálódjon azt jelenti, hogy a láthatóság megváltozik annak érdekében, hogygyőződjön meg arról, hogy a delegált elemek felé irányuló jelenlegi hívások még mindig összeállnak.

A mi esetünkben, isDateBetween a fő- a metódusa SimpleClass:

DateUtils.isNowBetween (LocalDate.MIN, LocalDate.MAX); DateUtils.isDateBetween (LocalDate.of (2019, 1, 1), LocalDate.MIN, LocalDate.MAX);

Így a módszer áthelyezésekor nem szükséges priváttá tenni.

A többi opció kiválasztásával azonban konkrét láthatóságot biztosíthatunk elemeinknek.

4. Bélés

Most, hogy kitértünk a kitermelésre, beszéljünk a megfelelőjéről: az inline-ról. A beillesztés arról szól, hogy vegyen egy kód elemet, és cserélje le azt, amiből áll. Egy változó esetében ez lenne a kijelölt kifejezés. Egy módszer esetében ez lenne a teste. Korábban láttuk, hogyan hozhatunk létre új osztályt, és delegálhatunk hozzá néhány kódelemet. De vannak idők érdemes egy módszert delegálni egy meglévő osztályba. Erről szól ez a szakasz.

Egy elem beillesztéséhez jobb egérgombbal kell kattintanunk erre az elemre - vagy annak definíciójára, vagy hivatkozására -, és be kell váltanunk az elemet Refaktor>Sorban választási lehetőség. Ezt úgy is elérhetjük, hogy kiválasztjuk az elemet és megütjük a Ctrl + Alt + N kulcsok.

Ezen a ponton az IntelliJ több lehetőséget kínál nekünk, függetlenül attól, hogy be akarunk-e vonni egy változót vagy egy módszert, függetlenül attól, hogy meghatározást vagy referenciát választottunk-e. Ezek a lehetőségek:

• Sorolja be az összes hivatkozást, és távolítsa el az elemet
• Sorolja be az összes hivatkozást, de őrizze meg az elemet
• Csak vonja be a kijelölt referenciát, és tartsa meg az elemet

Vegyük a mi isNowBetween módszer és megszabadulni a Most változó, ami most kissé túlzottnak tűnik:

A változó beillesztésével a következő eredményt kapnánk:

public static boolean isNowBetween (LocalDate kezdőDátum, LocalDate befejezőDátum) {return isDateBetween (LocalDate.now (), kezdőDátum, befejezőDátum); }

Esetünkben az egyetlen lehetőség az összes hivatkozás eltávolítása és az elem eltávolítása volt. De képzeljük el, hogy mi is szeretnénk megszabadulni a isDateBetween hívjon, és válassza a beillesztést. Ezután az IntelliJ felajánlja nekünk azt a három lehetőséget, amelyekről korábban beszéltünk:

Az első kiválasztása minden hívást felvált a metódus törzsére, és törli a metódust. Ami a másodikat illeti, minden hívást felváltana a method törzsre, de megtartaná a metódust. És végül az utolsó csak az aktuális hívást cserélné le a method törzsre:

public class DateUtils {public static Boolean isNowBetween (LocalDate startDate, LocalDate endDate) {LocalDate date = LocalDate.now (); visszatérési dátum.isBefore (befejező dátum) && date.isAfter (kezdő dátum); } public static boolean isDateBetween (LocalDate date, LocalDate kezdőDátum, LocalDate befejezőDátum) {return date.isBefore (befejezőDátum) && date.isAfter (kezdőDátum); }}

A mi fő- módszer a SimpleClass érintetlen marad is.

5. Mozgás

Korábban láttuk, hogyan hozhatunk létre új osztályt, és delegálhatunk hozzá néhány kódelemet. De vannak idők érdemes egy módszert delegálni egy meglévő osztályba. Erről szól ez a szakasz.

Egy elem áthelyezéséhez kövesse az alábbi lépéseket:

• Válassza ki az áthelyezni kívánt elemet
• Kattintson a jobb gombbal az elemre
• Indítsa el a Refaktor> Mozgás választási lehetőség
• Válassza ki a címzett osztályt és a módszer láthatóságát
• nyomja meg Belép

Ezt megnyomásával is elérhetjük F6 az elem kiválasztása után.

Tegyük fel, hogy egy új módszert adunk a sajátunkhoz SimpleClass, isDateOutstide (), amely megmondja nekünk, ha egy dátum a dátumintervallumon kívül esik:

public static boolean isDateOutside (LocalDate date, LocalDate startDate, LocalDate endDate) {return! DateUtils.isDateBetween (dátum, kezdőDátum, befejezőDátum); }

Ezután rájövünk, hogy a helyének a miénkben kell lennie DateUtils osztály. Tehát úgy döntünk, hogy áthelyezzük:

Módszerünk most a DateUtils osztály. Láthatjuk, hogy a hivatkozás DateUtils a módszer belsejében eltűnt, mivel már nincs rá szükség:

public static boolean isDateOutside (LocalDate date, LocalDate startDate, LocalDate endDate) {return! isDateBetween (dátum, kezdőDátum, befejezőDátum); }

Az imént tett példa jól működik, mivel statikus módszerre vonatkozik. Például egy példamódszer esetében a dolgok nem olyan egyszerűek.

Ha egy példány metódust akarunk áthelyezni, Az IntelliJ megkeresi az aktuális osztály mezőiben hivatkozott osztályokat, és felajánlja a módszer áthelyezését ezen osztályok egyikébe (feltéve, hogy módosítanunk kell őket).

Ha a mezőkben nincs hivatkozva módosítható osztályra, akkor az IntelliJ javasolja a módszer elkészítését statikus mielőtt elmozdítaná.

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

Végül beszélünk egy olyan funkcióról, amely lehetővé teszi számunkra a módszer aláírásának megváltoztatását. Ennek a szolgáltatásnak a célja a metódus aláírás minden aspektusának manipulálása.

Szokás szerint néhány lépést meg kell tennünk a szolgáltatás elindításához:

• Válassza ki a módosítani kívánt módszert
• Kattintson a jobb gombbal a módszerre
• Indítsa el a Refaktor> Aláírás módosítása választási lehetőség
• Vigye be a metódus aláírását
• nyomja meg Belép

Ha inkább a billentyűzet parancsikont használjuk, lehetséges használni Ctrl + F6 is.

Ez a szolgáltatás egy párbeszédablakot nyit meg, amely nagyon hasonlít a módszer kibontási funkciójához. És aztán ugyanazok a lehetőségeink vannak, mint amikor kivonunk egy módszert: nevének, láthatóságának megváltoztatása, paraméterek hozzáadása / eltávolítása és finomhangolása.

Képzeljük el, hogy változtatni akarunk a megvalósításunkon isDateBetween vagy a dátumhatárokat befogadónak vagy kizárólagosnak tekinti. Ehhez hozzá szeretnénk adni a logikai paraméter a módszerünkhöz:

A metódus aláírásának megváltoztatásával hozzáadhatjuk ezt a paramétert, elnevezhetjük és alapértelmezett értéket adhatunk neki:

public static boolean isDateBetween (HelyiDátum dátuma, HelyiDátum kezdőDátuma, HelyiDátum befejezőDátuma, logikai értékekkel együtt) {return date.isBefore (befejezőDátum) && date.isAfter (kezdőDátum); }

Ezt követően csak a módszer testét kell az igényeinkhez igazítanunk.

Ha akartuk, ellenőrizhettük volna a Delegálás túlterhelési módszerrel opcióval egy másik módszer létrehozása a paraméterrel a jelenlegi módosítása helyett.

7. Húzza fel és nyomja le

Java kódunk általában osztályhierarchiával rendelkezik - származtatott osztályok kiterjesztik az alaposztályt.

Néha tagokat (metódusokat, mezőket és konstansokat) szeretnénk áthelyezni ezen osztályok közé. Itt jön jól az utolsó refaktorálás: ez lehetővé teszi számunkra húzza fel a tagokat egy származtatott osztályból az alaposztályba, vagy tolja le őket egy alaposztályból az egyes származtatott osztályokba.

7.1. Felhúz

Először húzzunk ki egy módszert az alaposztályba:

• Válassza ki a származtatott osztály egyik tagját a felemelkedéshez
• Kattintson a jobb gombbal a tagra
• Indítsa el a Refaktor> Felhúzni a tagokat ... választási lehetőség
• Nyomja meg a Refaktor gomb

Alapértelmezés szerint nem érhető el gyorsbillentyű ehhez a funkcióhoz.

Tegyük fel, hogy van egy származtatott osztályunk Származtatott. Privátot használ doubleValue () módszer:

nyilvános osztály Derived kiterjeszti Base {public static void main (String [] args) {Derived subject = new Derived (); System.out.println ("Megduplázás 21. Eredmény:" + subject.doubleValue (21)); } private int doubleValue (int szám) {visszatérési szám + szám; }}

Az alaposztály Bázis üres.

Tehát mi történik, amikor felhúzunk doubleValue () -ba Bázis?

Két dolog történik doubleValue () amikor megnyomjuk a „Refactor” elemet a fenti párbeszédpanelen:

• átköltözik a Bázis osztály
• láthatósága változik magán nak nek védett hogy a Származtatott osztály továbbra is használhatja

A Bázis osztály utána már megvan a módszer:

public class Base {védett int doubleValue (int szám) {return szám + szám; }}

A tagok felhúzásának párbeszédpanel (a fenti képen) további lehetőségeket kínál:

• kiválaszthatunk más tagokat és egyszerre felhúzhatjuk őket
• az „Előnézet” gombbal megtekinthetjük a változtatásokat
• csak a metódusoknál van jelölőnégyzet a „Kivonat készítése” oszlopban. Ha be van jelölve, ez az opció absztrakt metódus definíciót ad az alaposztálynak a felhúzás során. A tényleges módszer a származtatott osztályban marad, de egy @ Felülírás annotáció. Következésképpen más származtatott osztályok már nem állnak össze akkor mivel hiányzik az új, elvont alapmódszer megvalósítása

7.2. Nyomja le

Végül tegyünk le egy tagot a levezetett osztályba. Ez ellentétes az imént végrehajtott felhúzással:

• Válassza ki az alaposztály egyik tagját, hogy lenyomja
• Kattintson a jobb gombbal a tagra
• Indítsa el a Refaktor> A tagok lenyomása… választási lehetőség
• Nyomja meg a Refaktor gomb

Csakúgy, mint a tagok felhúzásakor, a funkcióhoz alapértelmezés szerint sem használható billentyűparancs.

Nyomjuk meg újra azt a módszert, amelyet éppen felhúztunk. A Bázis osztály így nézett ki az előző szakasz végén:

public class Base {védett int doubleValue (int szám) {return szám + szám; }}

Most nyomjuk doubleValue () le a Származtatott osztály:

Ez a Származtatott osztály, miután megnyomta a „Refactor” elemet a fenti párbeszédpanelen.A doubleValue () a módszer visszatért:

nyilvános osztály Derived kiterjeszti a Base {private int theField = 5; public static void main (String [] args) {Származtatott tárgy = új Származtatott (); System.out.println ("Megduplázás 21. Eredmény:" + subject.doubleValue (21)); } védett int doubleValue (int szám) {visszatérési szám + szám; }}

Most mind a Bázis osztály és a Származtatott osztály visszatért oda, ahol az előző „Felhúzás” részben elkezdték. Közel, vagyis - doubleValue () megtartotta a védett láthatósága volt Bázis (ez volt magán eredetileg).

Az IntelliJ 2019.3.4 valójában figyelmeztetést hoz fel amikor lenyomja doubleValue (): „A leküldött tagok nem lesznek láthatók bizonyos hívóhelyekről”. De mint láthatjuk a Származtatott osztály felett, doubleValue () valóban látható a fő() módszer.

A tagok lenyomására szolgáló párbeszédpanel (a fenti képen) további lehetőségeket is kínál:

• ha több származtatott osztályunk van, akkor az IntelliJ minden egyes származtatott osztályba beletolja a tagokat
• több tagot lenyomhatunk
• az „Előnézet” gombbal megtekinthetjük a változtatásokat
• csak a metódusoknál van jelölőnégyzet az „Absztrakt megőrzése” oszlopban - Ez hasonló a tagok felhúzásához: Ha be van jelölve, ez az opció absztrakt módszert hagy az alaposztályban. A tagok felhúzásával ellentétben ez az opció a metódus implementációit az összes származtatott osztályba sorolja. Ezek a módszerek egy @ Felülírás annotáció

8. Következtetés

Ebben a cikkben alkalmunk nyílt elmélyülni az IntelliJ által kínált refaktor funkciókban. Természetesen nem fedtük le az összes lehetőséget, mivel az IntelliJ nagyon hatékony eszköz. Ha többet szeretne megtudni erről a szerkesztőről, mindig hivatkozhatunk a dokumentációjára.

Láttunk néhány dolgot, például hogyan nevezhetjük át a kódelemeinket, és hogyan vonhatunk ki egyes viselkedéseket változókká, módszerekké vagy osztályokká. Megtanultuk azt is, hogyan lehet beilleszteni néhány elemet, ha nincs szükségük arra, hogy egyedül álljanak, más kódot helyezzünk máshova, vagy akár teljesen megváltoztassunk egy meglévő metódus aláírást.