Inleiding tot het laatste trefwoord in Java
In dit bericht gaan we kijken naar het verschillende laatste trefwoord voor Java. Het is een sleutelwoord dat in de Java-taal wordt gebruikt om beperkingen op te leggen aan het gebruik of de wijziging door andere klassen of variabelen. Met behulp van dit sleutelwoord vertelt men de interpreter om geen toekomstige wijzigingen aan die variabele of methode toe te staan en deze als constant te behandelen. Het kan worden gebruikt met onderstaande 3 scenario's: -
- Variabele: het declareren van een variabele als definitief beperkt de wijziging ervan om te verwijzen naar een andere waarde of verwijzing.
- Methoden: Een methode als definitief verklaren, beperkt de methode die die methode overschrijft in de kindklassen.
- Klassen: een klasse als definitief verklaren, voorkomt de overerving van die klasse.
Deze sleutelwoorden worden altijd aanbevolen om te worden aangegeven in hoofdletters volgens goede coderingsmethoden.
Syntaxis van het laatste trefwoord in Java
Dit trefwoord kan op drie manieren worden gebruikt: -
1. Variabel
Variabelen in Java kunnen als variabel worden gedeclareerd om elke wijziging in de waarden te beperken. Het kan op een van de volgende drie manieren worden verklaard:
Syntaxis:
final int VAR1=21;//final variable
final int VAR2; //blank final variable
static final double DUMMY= 45.504;//final static variable
static final double PK;//blank final static variable
final String builder sb = new StringBuilder (“LetsLearn”);
2. Methoden
De methode die met het laatste trefwoord wordt aangegeven, wordt de laatste methode genoemd. De definitieve methode kan niet worden overschreven door de onderliggende klasse, wat betekent dat de methode van de onderliggende klasse de definitie van de definitieve methode in de bovenliggende klasse niet kan wijzigen. Als we willen dat de implementatie van een methode die in de bovenliggende klasse is gedefinieerd, in alle onderliggende klassen moet worden gevolgd, moeten we die methode als definitief verklaren.
Syntaxis:
final int my1()(
//method defination
)
3. Klassen
Laatste trefwoorden kunnen ook worden gebruikt met klassen om er een laatste klasse van te maken, wat betekent dat de specifieke klasse niet kan worden uitgebreid of overgenomen door andere klassen.
Syntaxis:
final class myClass(
/member variables and member functions.
)
Hoe werkt het laatste trefwoord in Java?
Het laatste sleutelwoord helpt om het overschrijven van de klassen, leden of variabelen tijdens overerving te beperken.
1. Laatste variabelen
Een variabele als definitief declareren betekent het beperken van elke wijziging van de waarde van de variabele in de overgenomen klassen. Een laatste variabele kan slechts eenmaal worden geïnitialiseerd en moet worden gebruikt zoals deze is, dus moet een definitieve variabele worden geïnitialiseerd. Het wordt meestal gebruikt met statische om een constante klassenvariabele te maken.
Bijvoorbeeld:
final int a =0;
We kunnen ook referentievariabelen definitief verklaren, in dit geval kan één referentievariabele niet naar verschillende objecten verwijzen. Maar in Java kan de interne status van een object worden gewijzigd waarnaar wordt verwezen door de uiteindelijke referentievariabele. We kunnen dus de waarde van de referentievariabele wijzigen. Dit is hetzelfde als het gebruik van definitieve arrays zoals hieronder weergegeven: -
Code:
class MyClass
(
public static void main(String args())
(
final int myarr() = (1, 2, 3, 4, 5);
for (int q = 0; q < myarr.length; q++)
(
myarr (q) = myarr (q)*10;
System.out.println(myarr (q));
)
)
)
Output:
Uitleg
Hier verwijst array a1 naar hetzelfde object, alleen de waarde van dat object verandert omdat we allemaal weten dat de variabele van de array alleen het startadres bevat van de geheugenlocatie waar die elementen van de array zijn opgeslagen.
En in hetzelfde, als we proberen naar een andere array te verwijzen met dezelfde arrayvariabele a1, wordt er een fout gegenereerd door de compiler. Dus door de word-final array hier te gebruiken, kan elke wijziging in het lid van de array worden aangebracht, maar de variabele mag niet naar een ander object verwijzen.
Dingen om te onthouden
Het initialiseren van een laatste variabele is noodzakelijk om compilatiefouten te voorkomen. Er is een verschil tussen C ++ const-variabelen en deze laatste variabelen dat const-variabelen niet hoeven te worden geïnitialiseerd. Er zijn drie manieren om een laatste variabele te initialiseren-
- Initialiseer op het moment van declaratie zelf : we kunnen gemakkelijk een laatste variabele declareren op het moment van declareren. In het geval dat het niet wordt geïnitialiseerd, wordt die variabele beschouwd als een lege laatste variabele, en een van de volgende twee manieren kan ons helpen een lege definitieve variabele te initialiseren.
- Instantie-initialisatieblok gebruiken : binnen dit blok of de constructor kan een lege laatste variabele eenvoudig worden geïnitialiseerd. Denk eraan om tijdens het initialiseren altijd de specifieke variabele in alle beschikbare constructors te initialiseren.
- Statisch blok: men kan ook een statisch blok gebruiken om de lege laatste variabele te initialiseren. Statisch blok wordt altijd eenmaal voor elke klasse geactiveerd, dus de variabele waarde waarvan de waarden niet moeten worden gewijzigd, kan eenvoudig met dit blok worden geïnitialiseerd.
Het laatste sleutelwoord wordt dus alleen gebruikt voor die variabele die hun waarde niet hoeft te wijzigen tijdens de uitvoering van het programma. Alle definitieve variabelen die in een methode of blok zijn gemaakt, moeten daar zelf worden geïnitialiseerd. Dergelijke typevariabelen staan bekend als lokale eindvariabelen.
Uitleg
In het onderstaande voorbeeld is een variabele i binnen de hoofdfunctie gedeclareerd en dus ook als een laatste lokale variabele beschouwd.
Code:
class myClass
(
public static void main(String args())
(
// local final variable
final int i;
i = 20;
System.out.println(i);
)
)
Output:
2. Laatste methoden
Een als definitief verklaarde methode kan in geen van de subklassen worden opgeheven, dus als definitieve methode genoemd. De methode moet als definitief worden verklaard als we vereisen dat dezelfde implementatie van de klas wordt gevolgd door de kindklassen.
Opmerking: het is niet nodig dat definitieve methoden worden aangegeven in de beginfase van de overerving (basisklasse). De methode kan in elke subklasse definitief worden verklaard waarvan we willen dat verdere subklassen dezelfde definitie volgen.Code:
class A(
void myMethod()(
//method definition
)
)
class B extends A(
final void myMethod()(
//overrides the method in parent class
//runs successfully
)
)
class C extends B(
void myMethod()(
//will throw error
)
)
3. Eindklassen
Klassen die als definitief worden verklaard, kunnen niet door andere klassen worden geërfd. Het vermelden van een laatste trefwoord vóór de klassennaam vertelt de compiler dat de definitie van deze klasse alleen kan worden gebruikt zoals ze zijn. Geen enkele andere klasse kan zijn specificaties aan deze definitie toevoegen of de code ervan hergebruiken. In het geval dat iemand de laatste klasse probeert uit te breiden, wordt door de compiler een fout gegenereerd die aangeeft dat deze klasse niet bedoeld is om te worden uitgebreid. Je kunt de laatste trefwoorden in Java gebruiken voor elk van de onderstaande 2 doeleinden: -
- De eerste is om de erfenis van die klasse te voorkomen. Voor bijvoorbeeld alle Wrapper-klassen die aanwezig zijn java.lang pakket zijn definitieve klassen daarvoor kunnen we ze niet uitbreiden in onze klassen, maar kunnen het gebruiken door hun objecten aan te geven. Elke poging om toegang te krijgen tot die klassen zal resulteren in een fout van de compiler.
final class myParentClass
(
// member variables and member functions
)
// illegal extend.
class myChildClass extends parentClass
(
// Can't subclass A
)
- Het tweede gebruik van finale met klassen is wanneer iemand een onveranderlijke klasse moet maken, dat wil zeggen dat als het object van de klasse eenmaal is gemaakt, we de inhoud ervan niet kunnen wijzigen zoals de vooraf gedefinieerde String-klasse. De klasse moet definitief worden verklaard om deze onveranderlijk te maken.
Notitie :
- Als een klasse als definitief wordt verklaard, worden de lidvariabelen en lidfuncties door de compiler ook als definitief beschouwd.
- Een klasse kan niet abstract worden verklaard als het afhankelijk is van de kindklassen om de definitie te voltooien, evenals de finale die de erfenis zelf verhindert.
Voorbeelden van het laatste trefwoord in Java
Hieronder ziet u het andere voorbeeld van het eindwoord in Java:
1. Laatste variabele gebruiken
In het onderstaande voorbeeld worden verschillende variabelen geïnitialiseerd met behulp van verschillende methoden. De SECOND-variabele wordt bijvoorbeeld geïnitialiseerd met behulp van de constructor, terwijl DERDE wordt geïnitialiseerd met een initialisator.
Code:
class myClass
(
final int FIRST = 5;
// a blank final variable
final int SECOND;
// another blank final variable
final int THIRD;
FIRST =10; //illegal attempt to change the value of final variable
// a final static variable PI
// direct initialize
static final double MINVALUE = 3.141592653589793;
// a blank final static variable
static final double MAXRANGE;
(
THIRD = 25; // initializer block
)
static(
MAXRANGE = 200.3;
)
public myClass()
(
SECOND = -1;//needs to be initialised in every constructor
)
)
Output:
2. Gebruik definitieve methoden
In het onderstaande voorbeeld verklaart abstracte klasse myShape de laatste methoden getWidth en krijgt acht die niet hoeven te worden vervangen door de overgenomen klassen. Het verklaart ook een abstracte functie waarvan de implementatie verplicht is in de volgende klassen. De enige definitie van een abstracte functie is dus zowel in een eerste kindklasse als in een tweede kindklasse geïmplementeerd.
Code:
abstract class myShape
(
private double width;
private double height;
public myShape(double width, double height)
(
this.width = width;
this.height = height;
)
public final double getWidth() //override not allowed
(
return width;
)
public final double getHeight() //override not allowed
(
return height;
)
abstract double getArea(); //needs to be defined in the child class
)
class firstChildClass extends myShape
(
public firstChildClass(double width, double height)
(
super(width, height);
)
final double getArea()
(
return this.getHeight() * this.getWidth();
)
)
class secondChildClass extends myShape
(
public secondChildClass(double side)
(
super(side, side);
)
final double getArea()
(
return this.getHeight() * this.getWidth();
)
)
public class myClass
(
public static void main(String() args)
(
myShape s1 = new firstChildClass(10, 20);
myShape s2 = new secondChildClass(10);
System.out.println("width of s1 : "+ s1.getWidth());
System.out.println("height of s1 : "+ s1.getHeight());
System.out.println("width of s2 : "+ s2.getWidth());
System.out.println("height of s2 : "+ s2.getHeight());
System.out.println("area of s1 : "+ s1.getArea());
System.out.println("area of s2 : "+ s2.getArea());
)
)
Output:
3. Gebruik van eindklassen
In het onderstaande programma gebruiken we een laatste klasse Solid die een methode definieert om het volume van een vorm te berekenen met behulp van de afmetingen, maar het weergeven van het volume van een vak gebeurt met de printVol-functie in de overgenomen klasse. Shape As Solid is een laatste klasse en daarom mag klasse Shape deze niet uitbreiden (of erven). Het gebruikt dus het object Shape om het volume van Shape te berekenen door de argumenten gewoon door te geven aan de functies.
Code:
final class Solid (
public double getVol(double length, double width, double height) (
return length * width * height;
)
)
class Shape (
private float length;
private float width;
private float height;
Shape(float length, float width, float height) (
this.length = length;
this.width = width;
this.height = height;
)
public void printVol(Solid bObj) (
double volume = bObj.getVol(this.length, this.width, this.height);
System.out.println("Volume of the Shape: " + volume);
)
)
public class myClass (
public static void main(String() args) (
Solid bObj = new Solid();
Shape obj = new Shape(5, 4, 3);
obj.printVol(bObj);
)
)
Output:
Conclusie
Het laatste trefwoord wordt gebruikt om te voorkomen dat de klassen, variabelen en methoden worden overschreven door de onderliggende klassen. Het kan ook worden gebruikt om klassen onveranderlijk te maken die de verandering in de waarde van zijn objecten beperkt. De laatste trefwoordcontrole wordt altijd alleen tijdens het compileren gecontroleerd. Het is een geweldig hulpprogramma om hergebruik van de gedefinieerde variabelen, logica en klassen te voorkomen.
Aanbevolen artikelen
Dit is een gids voor een voorbeeld van Final Keyword in Java. Hier bespreken we hoe het laatste trefwoord werkt in Java? die definitieve variabelen, definitieve methoden, definitieve klassen samen met syntaxis omvat. U kunt ook de volgende artikelen bekijken voor meer informatie -
- Typen en modificaties die worden gebruikt voor JComponent in Java
- Nieuwe functies van Java 8
- Hoe maak je een object in JavaScript?
- Wat is Case Statement in JavaScript?
- Gooien versus Gooien | Top 5 verschillen die u moet weten
- Verklaar Abstracte Klasse in C # met Voorbeeld
- Gebruik en voorbeelden van dit trefwoord