streamalism.org

1. Oversigt

I denne tutorial tager vi et overblik over tre Java-nøgleord: endelig, endelig og færdiggør.

Mens disse nøgleord ligner hinanden, har hver en meget forskellig betydning i Java. Vi lærer formålet med hver af dem og ser nogle eksempler gennem en smule kode.

2. endelig Nøgleord

Lad os først se på endelig nøgleord, hvor det skal bruges, og hvorfor. Vi kan anvende endelig nøgleord til erklæringer om klasse, metode, felt, variabel og metode.

Det har dog ikke den samme effekt på hver af dem:

• At lave en klasse endelig betyder, at det ikke er muligt at udvide denne klasse
• Tilføjer endelig til en metode betyder, at det ikke vil være muligt at tilsidesætte den metode
• Endelig sætte endelig foran et felt betyder en variabel eller en parameter, at når først referencen er tildelt, kan den ikke ændres (hvis referencen er til et mutabelt objekt, kan den interne tilstand ændre sig på trods af at den er endelig)

En detaljeret artikel om endelig nøgleord kan findes her.

Lad os se, hvordan endelig nøgleord fungerer gennem nogle eksempler.

2.1. endelig Felter, parametre og variabler

Lad os oprette en Forælder klasse med to int felter, a endelig en og en regelmæssig ikke-endelig:

offentlig klasse Forælder {int felt1 = 1; sidste int felt2 = 2; Forælder () {felt1 = 2; // OK felt2 = 3; // Kompileringsfejl}}

Som vi kan se, forbyder compileren os at tildele en ny værdi til felt2.

Lad os nu tilføje en metode med et regelmæssigt og et sidste argument:

 ugyldig metode1 (int arg1, endelig int arg2) {arg1 = 2; // OK arg2 = 3; // Kompileringsfejl}

På samme måde som felter er det ikke muligt at tildele noget til arg2 som det er erklæret endelig.

Vi kan nu tilføje en anden metode til at illustrere, hvordan dette fungerer med lokale variabler:

 ugyldig metode2 () {final int localVar = 2; // OK localVar = 3; // Kompileringsfejl}

Der sker ikke noget overraskende, kompilatoren lader os ikke tildele en ny værdi localVar efter sin første opgave.

2.2. endelig Metode

Antag nu, at vi laver metode2 endelig og opret en underklasse af Forælder, Lad os sige Barn, hvor vi forsøger at tilsidesætte begge dens superklassemetoder:

offentlig klasse Barn udvider overordnet {@Override ugyldig metode1 (int arg1, int arg2) {// OK} @Override endelig ugyldig metode2 () {// Kompilationsfejl}}

Som vi kan se, er der ikke noget problem med at tilsidesætte metode1 (), men vi får en kompileringsfejl, når vi prøver at tilsidesætte metode2 ().

2.3. endelig Klasse

Og endelig, lad os lave Barn klasse final og prøv at oprette en underklasse af den, GrandChild:

offentlig endelig klasse Barn udvider forælder {// ...}

offentlig klasse GrandChild udvider Child {// Compilation error}

Igen klager compileren. Det Barn klassen er endelig og derfor umulig at udvide.

3. langt om længe Blok

Det langt om længe blok er en valgfri blok til brug med en prøv / fange udmelding. I denne blok inkluderer vi kode, der skal udføres efter prøv / fange struktur, uanset om en undtagelse kastes eller ej.

Det er endda muligt at bruge det med prøve blokere uden nogen fangst blok forudsat at vi inkluderer en langt om længe blok. Koden udføres derefter efter prøve eller efter en undtagelse er kastet.

Vi har en dybtgående artikel om håndtering af undtagelser i Java her.

Lad os nu demonstrere en langt om længe blok i et kort eksempel. Vi opretter en dummy hoved () metode med en prøv / fangst / endelig struktur:

public static void main (String args []) {try {System.out.println ("Execute try block"); smid ny undtagelse (); } fangst (Undtagelse e) {System.out.println ("Udfør fangstblok"); } endelig {System.out.println ("Udfør endelig blokering"); }}

Hvis vi kører denne kode, udsender den følgende:

Udfør forsøg blok Udfør fangst blok Udfør endelig blok

Lad os nu ændre metoden ved at fjerne fangstblokken (og tilføj kaster undtagelse til underskriften):

offentlig statisk ugyldig hoved (String args []) kaster Undtagelse {prøv {System.out.println ("Udfør forsøgsblok"); smid ny undtagelse (); } endelig {System.out.println ("Udfør endelig blokering"); }}

Outputtet er nu:

Udfør prøv blok Udfør endelig blok

Hvis vi nu fjerner smid ny undtagelse () instruktion, kan vi observere, at output forbliver den samme. Vores langt om længe blokudførelse sker hver gang.

4. færdiggør Metode

Og endelig, den færdiggør metoden er en beskyttet metode, defineret i objektklassen. Det kaldes af skraldemand på objekter, der ikke længere er henvist til og er valgt til affaldsindsamling.

Som enhver anden ikke-endelig metode kan vi tilsidesætte denne metode for at definere den adfærd et objekt skal have, når det indsamles af skraldemand.

Igen en detaljeret artikel, der dækker færdiggør metode kan findes her.

Lad os se et eksempel på, hvordan det fungerer. Vi bruger System.gc () at foreslå JVM at udløse dagrenovation:

 @ Override beskyttet tomrum finalize () kaster Throwable {System.out.println ("Execute finalize method"); super.finalize (); }

 offentlig statisk ugyldig hoved (String [] args) kaster Undtagelse {FinalizeObject-objekt = nyt FinalizeObject (); objekt = null; System.gc (); Tråd. Søvn (1000); }

I dette eksempel tilsidesætter vi færdiggør () metode i vores objekt og oprette en hoved () metode, der instantierer vores objekt og straks slipper henvisningen ved at indstille den oprettede variabel til nul.

Derefter ringer vi System.gc () at køre skraldemand (i det mindste forventer vi, at det kører) og venter et sekund (bare for at sikre, at JVM lukker ikke før skraldemand har chancen for at ringe færdiggør () metode).

Output af denne kodeudførelse skal være:

Udfør færdiggørelsesmetoden

Bemærk, at det betragtes som dårlig praksis at tilsidesætte færdiggør () metode, da dens udførelse afhænger af dagrenovation som er i hånden på JVM. Plus, denne metode har været forældet siden Java 9.

5. Konklusion

I denne artikel har vi kort diskuteret forskellene mellem de tre Java-nøgleord: endelig, endelig og færdiggør.

Den fulde kode for artiklen kan findes på GitHub.