streamalism.org

1. Áttekintés

Ebben az oktatóanyagban áttekintünk három Java kulcsszót: végül és véglegesíteni.

Míg ezek a kulcsszavak hasonlítanak egymásra, a Java-ban nagyon különböző jelentése van. Megtanuljuk mindegyik célját, és meglátunk néhány példát egy kis kóddal.

2. végső Kulcsszó

Először vessünk egy pillantást a végső kulcsszó, hol és miért használható. Alkalmazhatjuk a végső kulcsszó osztály, módszer, mező, változó és metódus paraméter deklarációk.

Ez azonban nem mindegyikre gyakorolja ugyanazt a hatást:

• Osztály készítése végső azt jelenti, hogy nem lehet kibővíteni ezt az osztályt
• Hozzáadás végső egy módszer azt jelenti, hogy nem lehet felülírni ezt a módszert
• Végül rakás végső egy mező előtt egy változó vagy egy paraméter azt jelenti, hogy ha a referencia hozzárendelésre került, akkor azt nem lehet megváltoztatni (ha azonban a hivatkozás egy módosítható objektumra vonatkozik, akkor a belső állapota a végleges ellenére is megváltozhat)

Részletes cikk a végső kulcsszó itt található.

Lássuk, hogyan végső kulcsszó néhány példán keresztül működik.

2.1. végső Mezők, paraméterek és változók

Hozzunk létre egy Szülő osztály kettővel int mezők, a végső egy és egy szokásos, nem végleges:

public class Szülő {int mező1 = 1; végső int mező2 = 2; Szülő () {mező1 = 2; // OK mező2 = 3; // fordítási hiba}}

Mint láthatjuk, a fordító megtiltja, hogy új értéket rendeljünk hozzá mező2.

Adjunk hozzá egy metódust egy szabályos és egy utolsó argumentummal:

 void 1. módszer (int arg1, végső int arg2) {arg1 = 2; OK arg2 = 3; // fordítási hiba}

A mezőkhöz hasonlóan nem lehet hozzárendelni valamit arg2 mivel véglegesnek nyilvánítják.

Most hozzáadhatunk egy második módszert annak szemléltetésére, hogy ez hogyan működik a helyi változókkal:

 void method2 () {final int localVar = 2; // OK localVar = 3; // fordítási hiba}

Semmi meglepő nem történik, a fordító nem engedi, hogy új értéket rendeljünk hozzá localVar első kiosztása után.

2.2. végső Módszer

Most tegyük fel, hogy elkészítjük módszer2 végleges és hozzon létre egy alosztályt a Szülő, mondjuk Gyermek, amelyben mindkét szuperosztályos módszert megpróbáljuk felülbírálni:

public class A gyermek kiterjeszti a szülőt {@Orride void method1 (int arg1, int arg2) {// OK} @Orride final void method2 () {// Fordítási hiba}}

Mint láthatjuk, az átírással nincs probléma method1 (), de fordítási hibát kapunk, amikor megpróbáljuk felülírni method2 ().

2.3. végső Osztály

És végül készítsük el a Gyermek osztály döntőjét, és próbálja létrehozni annak egy alosztályát, Unoka:

nyilvános döntő osztály A gyermek meghosszabbítja a szülőt {// ...}

nyilvános osztály A GrandChild kiterjeszti a gyermeket {// fordítási hiba}

Még egyszer a fordító panaszkodik. A Gyermek osztály végleges, ezért lehetetlen meghosszabbítani.

3. végül Blokk

A végül A block egy opcionális blokk, amelyet az a-val lehet használni próbáld / fogd nyilatkozat. Ebben a blokkban kódot is tartalmazunk, amelyet a. Után kell végrehajtani próbáld / fogd szerkezet, függetlenül attól, hogy kivételt dobtak-e vagy sem.

Még az is használható próbáld ki blokkolja anélkül fogás blokk, feltéve, hogy a végül Blokk. Ezután a kód végrehajtásra kerül a próbáld ki vagy miután kivételt dobtak.

Van egy részletes cikkünk a Java-ban végzett kivételkezelésről.

Most mutassuk be a végül blokk egy rövid példában. Készítünk egy próbabábut fő() módszer a próbáld / fogd / végül szerkezet:

public static void main (String args []) {try {System.out.println ("Próbáld ki a blokkot"); dobja az új Kivételt (); } catch (e kivétel) {System.out.println ("Fogási blokk végrehajtása"); } végül {System.out.println ("Végül végrehajtja a blokkot"); }}

Ha futtatjuk ezt a kódot, akkor a következőket adja ki:

Végezze el a próbablokkot Fogási blokk végrehajtása Végrehajtja a blokkot

Módosítsuk most a módszert a fogási blokk eltávolításával (és adjuk hozzá dob Kivételt az aláíráshoz):

public static void main (String args []) dobja a Kivételt {try {System.out.println ("Try block végrehajtása"); dobja az új Kivételt (); } végül {System.out.println ("Végül végrehajtja a blokkot"); }}

A kimenet most:

Végezze el a próba blokkot Végrehajtja a blokkot

Ha most eltávolítjuk a dobj új Kivételt () utasítás, megfigyelhetjük, hogy a kimenet ugyanaz marad. A mi végül a blokk végrehajtása minden alkalommal előfordul.

4. véglegesíteni Módszer

És végül a véglegesíteni A metódus az Object osztályban definiált védett módszer. A szemetes olyan objektumokon, amelyekre már nincs hivatkozás, és amelyeket szemétszállításra választottak ki.

Bármely más, nem végleges módszerhez hasonlóan, ezt a módszert is felülírhatjuk, hogy meghatározzuk azt a viselkedést, amelyet az objektumnak kell tapasztalnia, amikor a szemetes.

Ismét egy részletes cikk, amely a véglegesíteni módszer itt található.

Lássunk egy példát a működésére. Majd használjuk System.gc () javasolni a JVM kiváltani szemétgyüjtés:

 @Orride védett void finalize () dobja Throwable {System.out.println ("Véglegesítési módszer végrehajtása"); super.finalize (); }

 public static void main (String [] args) dobja a Kivételt {FinalizeObject objektum = új FinalizeObject (); object = null; System.gc (); Szál.alszik (1000); }

Ebben a példában felülírjuk véglegesítés () módszer az objektumunkban, és hozzon létre egy fő() metódus, amely példányosítja objektumunkat, és a létrehozott változót a nulla.

Utána hívunk System.gc () futtatni a szemetes (legalábbis arra számítunk, hogy fut), és várjunk egy másodpercet (csak annak biztosítására, hogy a JVM nem zár le korábban szemetes van esélye felhívni véglegesítés () módszer).

A kódfuttatás kimenetének a következőknek kell lennie:

Végezze el a véglegesítés módszert

Ne feledje, hogy rossz gyakorlatnak számít felülírni véglegesítés () módszer, mivel a végrehajtása függ szemétgyüjtés ami a kezében van JVM. Ráadásul ez a módszer már volt elavult a Java 9 óta.

5. Következtetés

Ebben a cikkben röviden megvitattuk a különbségeket a három hasonló Java kulcsszó között: végül, végül és véglegesíteni.

A cikk teljes kódja megtalálható a GitHub oldalon.