streamalism.org

1. Overzicht

Hoewel overerving ons in staat stelt om bestaande code te hergebruiken, is dat soms nodig beperkingen stellen aan uitbreidbaarheid om verschillende redenen; de laatste trefwoord stelt ons in staat om precies dat te doen.

In deze zelfstudie bekijken we wat de laatste trefwoord betekent voor klassen, methoden en variabelen.

2. Laatste Klassen

Klassen gemarkeerd als laatste kan niet worden verlengd. Als we naar de code van Java-kernbibliotheken kijken, zullen we er veel vinden laatste lessen daar. Een voorbeeld is de Draad klasse.

Overweeg de situatie als we het Draad class, overschrijft een van zijn methoden en vervangt alle Draad gevallen met de voorbeelden van onze specifieke Draad subklasse.

Het resultaat van de operaties voorbij Draad objecten worden dan onvoorspelbaar. En gezien het feit dat de Draad klasse wordt overal gebruikt, het is onaanvaardbaar. Dat is waarom de Draad klasse is gemarkeerd als laatste.

Elke poging om te erven van een laatste class zal een compilatiefout veroorzaken. Laten we, om dit te demonstreren, de laatste klasse Kat:

openbare finale klasse Cat {privé int gewicht; // standaard getter en setter}

En laten we proberen het uit te breiden:

openbare klasse BlackCat breidt Cat uit {}

We zien de compilatiefout:

Het type BlackCat kan de laatste klasse Cat

Let daar op de laatste trefwoord in een klassendeclaratie betekent niet dat de objecten van deze klasse onveranderlijk zijn. We kunnen de velden van wijzigen Kat object vrij:

Cat cat = nieuwe Cat (); cat.setWeight (1); assertEquals (1, cat.getWeight ()); 

We kunnen het gewoon niet verlengen.

Als we de regels van goed ontwerp strikt volgen, moeten we een klasse zorgvuldig maken en documenteren of deze aangeven laatste voor veiligheidsredenen. We moeten echter voorzichtig zijn bij het maken van laatste klassen.

Merk op dat het maken van een les laatste betekent dat geen enkele andere programmeur het kan verbeteren. Stel je voor dat we een klasse gebruiken en er niet de broncode voor hebben, en dat er een probleem is met één methode.

Als de klas is laatste, we kunnen het niet uitbreiden om de methode te negeren en het probleem op te lossen. Met andere woorden, we verliezen uitbreidbaarheid, een van de voordelen van objectgeoriënteerd programmeren.

3. Laatste Methoden

Methoden gemarkeerd als laatste kan niet worden overschreven. Als we een klasse ontwerpen en vinden dat een methode niet mag worden overschreven, kunnen we deze methode maken laatste. We kunnen er ook veel vinden laatste methoden in Java-kernbibliotheken.

Soms hoeven we een klasse-extensie niet helemaal te verbieden, maar voorkomen we alleen dat sommige methoden worden overschreven. Een goed voorbeeld hiervan is de Draad klasse. Het is legaal om het uit te breiden en zo een aangepaste threadklasse te maken. Maar het is is levend() methoden is laatste.

Deze methode controleert of een thread leeft. Het is onmogelijk om het is levend() methode correct om vele redenen. Een daarvan is dat deze methode native is. Native code is geïmplementeerd in een andere programmeertaal en is vaak specifiek voor het besturingssysteem en de hardware waarop het draait.

Laten we een Hond klasse en maak zijn geluid() methode laatste:

public class Dog {public final void sound () {// ...}}

Laten we nu het Hond class en probeer zijn geluid() methode:

openbare klasse BlackDog breidt Dog {public void sound () {}} uit

We zien de compilatiefout:

- overschrijft com.baeldung.finalkeyword.Dog.sound - Kan de laatste methode niet overschrijven van de methode Dog sound () is definitief en kan niet worden overschreven

Als sommige methoden van onze klasse door andere methoden worden aangeroepen, moeten we overwegen om de aangeroepen methoden te maken laatste. Anders kan het negeren ervan het werk van bellers beïnvloeden en verrassende resultaten opleveren.

Als onze constructor andere methoden aanroept, moeten we deze methoden in het algemeen declareren laatste om de bovenstaande reden.

Wat is het verschil tussen het maken van alle methoden van de klas laatste en het markeren van de klasse zelf laatste? In het eerste geval kunnen we de klasse uitbreiden en er nieuwe methoden aan toevoegen.

In het tweede geval kunnen we dit niet doen.

4. Laatste Variabelen

Variabelen gemarkeerd als laatste kan niet opnieuw worden toegewezen. Eens een laatste variabele is geïnitialiseerd, kan niet worden gewijzigd.

4.1. Laatste Primitieve variabelen

Laten we een primitief verklaren laatste variabele ik, wijs er dan 1 aan toe.

En laten we proberen er een waarde van 2 aan toe te kennen:

openbare leegte whenFinalVariableAssign_thenOnlyOnce () {final int i = 1; // ... ik = 2; }

De compiler zegt:

De laatste lokale variabele i is mogelijk al toegewezen

4.2. Laatste Verwijzingsvariabelen

Als we een laatste referentievariabele, kunnen we deze ook niet opnieuw toewijzen. Maar dit betekent niet dat het object waarnaar het verwijst onveranderlijk is. We kunnen de eigenschappen van dit object vrijelijk wijzigen.

Laten we, om dit aan te tonen, het laatste referentievariabele kat en initialiseer het:

laatste Cat cat = nieuwe Cat ();

Als we het opnieuw proberen toe te wijzen, zien we een compilatiefout:

De laatste lokale variabele cat kan niet worden toegewezen. Het moet leeg zijn en mag geen samengestelde toewijzing bevatten

Maar we kunnen de eigenschappen van veranderen Kat voorbeeld:

cat.setWeight (5); assertEquals (5, cat.getWeight ());

4.3. Laatste Velden

Laatste velden kunnen constanten zijn of velden die één keer kunnen worden geschreven. Om ze te onderscheiden, moeten we een vraag stellen: zouden we dit veld opnemen als we het object zouden serialiseren? Zo nee, dan maakt het geen deel uit van het object, maar een constante.

Merk op dat volgens de naamgevingsconventies klasseconstanten hoofdletters moeten zijn, met componenten gescheiden door onderstrepingstekens ("_"):

statische laatste int MAX_WIDTH = 999;

Let daar op ieder laatste veld moet worden geïnitialiseerd voordat de constructor is voltooid.

Voor statische finale velden, dit betekent dat we ze kunnen initialiseren:

• op aangifte zoals getoond in het bovenstaande voorbeeld
• in het statische initialisatieblok

Bijvoorbeeld laatste velden, dit betekent dat we ze kunnen initialiseren:

• bij aangifte
• in het instantie-initialisatieblok
• in de constructor

Anders geeft de compiler ons een foutmelding.

4.4. Laatste Argumenten

De laatste trefwoord is ook legaal om voor methode-argumenten te plaatsen. EEN laatste argument kan niet binnen een methode worden gewijzigd:

public void methodWithFinalArguments (final int x) {x = 1; }

De bovenstaande toewijzing veroorzaakt de compilatiefout:

De laatste lokale variabele x kan niet worden toegewezen. Het moet leeg zijn en mag geen samengestelde toewijzing bevatten

5. Conclusie

In dit artikel hebben we geleerd wat de laatste trefwoord betekent voor klassen, methoden en variabelen. Hoewel we de laatste trefwoord vaak in onze interne code, kan het een goede ontwerpoplossing zijn.

Zoals altijd is de volledige code voor dit artikel te vinden in het GitHub-project.