De uiteindelijke methode in Java wordt gebruikt als een niet-toegangsmodificator alleen van toepassing op a variabel , A methode , of een klas. Het is gewend een gebruiker beperken op Java .

De volgende zijn verschillende contexten waar de finale wordt gebruikt:

1. Variabel
2. Methode
3. Klas

Kenmerken van het uiteindelijke zoekwoord in Java:

In Java wordt het laatste trefwoord gebruikt om aan te geven dat een variabele, methode of klasse niet kan worden gewijzigd of uitgebreid. Hier zijn enkele kenmerken:

• Laatste variabelen: Wanneer een variabele als definitief wordt gedeclareerd, kan de waarde ervan niet meer worden gewijzigd nadat deze is geïnitialiseerd. Dit is handig voor het declareren van constanten of andere waarden die niet mogen worden gewijzigd.
• Laatste methoden : Wanneer een methode als definitief wordt gedeclareerd, kan deze niet worden overschreven door een subklasse. Dit is handig voor methoden die deel uitmaken van de openbare API van een klasse en niet door subklassen mogen worden gewijzigd.
• Laatste lessen: Wanneer een klasse als definitief wordt verklaard, kan deze niet worden uitgebreid met een subklasse. Dit is handig voor klassen die bedoeld zijn om te worden gebruikt zoals ze zijn en die niet mogen worden gewijzigd of uitgebreid.
• Initialisatie: De uiteindelijke variabelen moeten worden geïnitialiseerd op het moment van declaratie of in de constructor van de klasse. Dit zorgt ervoor dat de waarde van de variabele wordt ingesteld en niet kan worden gewijzigd.
• Prestatie: Het gebruik van een finale kan soms de prestaties verbeteren, omdat de compiler de code effectiever kan optimaliseren als hij weet dat een variabele of methode niet kan worden gewijzigd.
• Beveiliging: De laatste kan de beveiliging helpen verbeteren door te voorkomen dat kwaadaardige code gevoelige gegevens of gedrag wijzigt.

Over het geheel genomen is het laatste trefwoord een nuttig hulpmiddel om de codekwaliteit te verbeteren en ervoor te zorgen dat bepaalde aspecten van een programma niet kunnen worden gewijzigd of uitgebreid. Door variabelen, methoden en klassen als definitief te declareren, kunnen ontwikkelaars veiligere, robuustere en onderhoudbare code schrijven.

Java-eindvariabele

Wanneer een variabele wordt gedeclareerd met de laatste trefwoord , zijn waarde kan niet worden gewijzigd , in wezen, een constante . Dit betekent ook dat jij moet een laatste variabele initialiseren .

Als de laatste variabele a is referentie , betekent dit dat de variabele niet kan zijn opnieuw gebonden aan referentie een ander object, maar de interne status van het object waarnaar door die referentievariabele wordt verwezen, kan worden gewijzigd, d.w.z. u kunt elementen toevoegen aan of verwijderen uit de laatste reeks of definitieve incasso.

Het is een goede gewoonte om de eindvariabelen geheel in hoofdletters weer te geven en een onderstrepingsteken te gebruiken om woorden te scheiden.

Voorbeeld:

public class ConstantExample {  public static void main(String[] args) {  // Define a constant variable PI  final double PI = 3.14159;  // Print the value of PI  System.out.println('Value of PI: ' + PI);  } }>

Value of PI: 3.14159>

Uitgang:

  Value of PI: 3.14159>

Verschillende methoden voor het gebruik van de eindvariabele

Laten we verschillende methoden bekijken waarmee we de laatste variabele in Java kunnen gebruiken.

1. laatste variabele

Voorbeeld:

// Final variable final int THRESHOLD = 5;>

2. Lege eindvariabele

Voorbeeld:

// Blank final variable final int THRESHOLD;>

3. Statische eindvariabele

Voorbeeld:

// Final static variable PI static final double PI = 3.141592653589793;>

4. Statische blanco eindvariabele

Voorbeeld:

// Blank final static variable static final double PI;>

Initialiseren van een laatste variabele

We moeten een laatste variabele initialiseren, anders genereert de compiler een compileerfout. Een laatste variabele kan slechts één keer worden geïnitialiseerd, hetzij via een initialisator of een opdrachtverklaring. Er zijn drie manieren om een ​​eindvariabele te initialiseren:

wachtrij en prioriteitswachtrij in Java

1. U kunt een laatste variabele initialiseren wanneer deze wordt gedeclareerd. Deze aanpak is de meest voorkomende. Een laatste variabele heet a lege eindvariabele als het is niet geïnitialiseerd tijdens declaratie. Hieronder staan ​​de twee manieren om een ​​lege eindvariabele te initialiseren.
2. Een lege eindvariabele kan worden geïnitialiseerd in een instance-initializer-blok of de constructeur. Als u meer dan één constructor in uw klasse heeft, moet deze in alle constructors worden geïnitialiseerd, anders wordt er tijdens het compileren een fout gegenereerd.
3. Een lege laatste statische variabele kan worden geïnitialiseerd binnen a statisch blok .

Laten we deze twee verschillende manieren bekijken om een ​​eindvariabele te initialiseren

Voorbeeld:

// Java Program to demonstrate Different // Ways of Initializing a final Variable // Main class  class GFG {    // a final variable  // direct initialize  final int THRESHOLD = 5;    // a blank final variable  final int CAPACITY;    // another blank final variable  final int MINIMUM;    // a final static variable PI  // direct initialize  static final double PI = 3.141592653589793;    // a blank final static variable  static final double EULERCONSTANT;    // instance initializer block for   // initializing CAPACITY  {  CAPACITY = 25;  }    // static initializer block for   // initializing EULERCONSTANT  static{  EULERCONSTANT = 2.3;  }    // constructor for initializing MINIMUM  // Note that if there are more than one  // constructor, you must initialize MINIMUM  // in them also  public GFG()   {  MINIMUM = -1;  }   }>

Er was geen hoofdmethode in de bovenstaande code, omdat deze eenvoudigweg ter illustratie was bedoeld om een ​​beter begrip te krijgen en conclusies te trekken:

Observatie 1: Wanneer gebruik je een laatste variabele?

Het enige verschil tussen een normale variabele en een eindvariabele is dat we de waarde opnieuw kunnen toewijzen aan een normale variabele, maar dat we de waarde van een eenmaal toegewezen eindvariabele niet kunnen wijzigen. Daarom moeten eindvariabelen alleen worden gebruikt voor de waarden die we tijdens de uitvoering van het programma constant willen houden.

Observatie 2: Referentie-eindvariabele.

Wanneer een laatste variabele een verwijzing naar een object is, wordt deze laatste variabele de genoemd referentie-eindvariabele . Een finale bijvoorbeeld StringBuffer variabele looks worden hieronder als volgt gedefinieerd:

final StringBuffer sb;>

Zoals we allemaal weten, kan een eindvariabele niet opnieuw worden toegewezen. Maar in het geval van een referentie-eindvariabele kan de interne toestand van het object waarnaar die referentievariabele verwijst, worden gewijzigd. Let op: dit is geen hertoewijzing.

Dit eigendom van de laatste wordt genoemd niet-transitiviteit . Om te begrijpen wat er wordt bedoeld met de interne toestand van het object, zoals weergegeven in het onderstaande voorbeeld, gaat het als volgt:

Voorbeeld 1:

// Java Program to demonstrate // Reference of Final Variable // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating an object of StringBuilder class  // Final reference variable  final StringBuilder sb = new StringBuilder('Geeks');  // Printing the element in StringBuilder object  System.out.println(sb);  // changing internal state of object reference by  // final reference variable sb  sb.append('ForGeeks');  // Again printing the element in StringBuilder  // object after appending above element in it  System.out.println(sb);  } }>

Geeks GeeksForGeeks>

De niet-transitiviteit eigenschap is ook van toepassing op arrays, omdat arrays zijn objecten op Java. Arrays met de laatste trefwoord worden ook wel genoemd laatste arrays .

Opmerking: Zoals hierboven besproken, kan een laatste variabele niet opnieuw worden toegewezen. Als u dit wel doet, ontstaat er een compileerfout.

Voorbeeld 2:

// Java Program to Demonstrate Re-assigning // Final Variable will throw Compile-time Error // Main class class GFG {  // Declaring and customly initializing  // static final variable  static final int CAPACITY = 4;  // Main driver method  public static void main(String args[])  {  // Re-assigning final variable  // will throw compile-time error  CAPACITY = 5;  } }>

Uitgang:

Herinneren: Wanneer een eindvariabele wordt aangemaakt binnen een methode/constructor/blok, wordt deze de lokale eindvariabele genoemd en moet deze eenmaal worden geïnitialiseerd op de plek waar deze wordt gemaakt. Zie onderstaand programma voor de lokale eindvariabele.

Voorbeeld:

// Java program to demonstrate // local final variable // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Declaring local final variable  final int i;  // Now initializing it with integer value  i = 20;  // Printing the value on console  System.out.println(i);  } }>

20>

Onthoud deze sleutelpunten zoals waargenomen voordat u verder gaat, zoals hieronder vermeld:

1. Let op het verschil tussen C++ const variabelen en Java laatste variabelen. const-variabelen in C++ moeten zijn een waarde toegewezen bij declaratie . Voor eindvariabelen in Java is dit het geval niet nodig zoals we zien in de bovenstaande voorbeelden. Aan een laatste variabele kan later een waarde worden toegekend, maar slechts één keer.
2. laatste met foreach lus : definitief bij elke verklaring is een juridische verklaring.

Voorbeeld:

// Java Program to demonstrate Final // with for-each Statement // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Declaring and initializing  // custom integer array  int arr[] = { 1, 2, 3 };  // final with for-each statement  // legal statement  for (final int i : arr)  System.out.print(i + ' ');  } }>

1 2 3>

Uitvoer uitleg: Sinds de i Wanneer de variabele buiten het bereik valt bij elke iteratie van de lus, wordt deze bij elke iteratie opnieuw gedeclareerd, waardoor hetzelfde token (i) kan worden gebruikt om meerdere variabelen weer te geven.

Voorbeeld:

public class Example {  public static void main(String[] args) {  final int VALUE = 10; // declaring a final variable    System.out.println('The value is: ' + VALUE);  // VALUE = 20; // uncommenting this line will cause a compiler error  // System.out.println('The new value is: ' + VALUE);    final String MESSAGE = 'Hello, world!'; // declaring a final variable  System.out.println(MESSAGE);    MyClass myObj = new MyClass();  myObj.printMessage();  myObj.printFinalMessage();    // MyOtherClass extends MyClass {} // uncommenting this line will cause a compiler error  } } class MyClass {  final String message = 'Hello!'; // declaring a final instance variable    void printMessage() {  System.out.println(message);  }    void printFinalMessage() {  final String finalMessage = 'Hello, final!';  System.out.println(finalMessage);  } } final class MyOtherClass { // declaring a final class  // ... }>

The value is: 10 Hello, world! Hello! Hello, final!>

Java-eindklassen

Wanneer een klasse wordt gedeclareerd met de laatste trefwoord in Java heet het a laatste les . Een laatste les kan niet verlengd (geërfd) .

Er zijn twee toepassingen van een laatste klasse:

Gebruik 1: Eén daarvan is zeker voorkomen erfenis , aangezien de laatste lessen niet kunnen worden verlengd. Bijvoorbeeld allemaal Wrapper-klassen leuk vinden Geheel getal , Vlot , etc. zijn laatste lessen. We kunnen ze niet verlengen.

final class A {  // methods and fields }   // The following class is illegal  class B extends A  {   // COMPILE-ERROR! Can't subclass A }>

Gebruik 2: Het andere gebruik van Final met klassen is om creëer een onveranderlijke klasse zoals het vooraf gedefinieerde Snaar klas. Je kunt een klasse niet onveranderlijk maken zonder deze definitief te maken.

Java-eindmethode

Wanneer een methode wordt gedeclareerd met laatste trefwoord, het heet a uiteindelijke methode op Java. Een definitieve methode kan dat niet zijn overridden .

De Voorwerp class doet dit: een aantal van zijn methoden zijn definitief. We moeten methoden declareren met het laatste trefwoord waarvoor we dezelfde implementatie moeten volgen in alle afgeleide klassen.

Illustratie: Laatste trefwoord met een methode

class A  {  final void m1()   {  System.out.println('This is a final method.');  } } class B extends A  {  void m1()  {     // Compile-error! We can not override   System.out.println('Illegal!');  } }>

Voordelen van het uiteindelijke zoekwoord in Java:

Het laatste trefwoord in Java biedt verschillende voordelen, waaronder:

JavaScript-waarschuwingsvenster

• Zorgen voor onveranderlijkheid: Wanneer een variabele of referentie als definitief is gemarkeerd, kan de waarde ervan niet meer worden gewijzigd zodra deze is toegewezen. Dit zorgt ervoor dat gegevens onveranderlijk zijn en niet per ongeluk of kwaadwillig kunnen worden gewijzigd.
• Prestaties verbeteren : Het gebruik van de finale kan soms de prestaties helpen verbeteren, omdat de Java Virtual Machine (JVM) code effectiever kan optimaliseren als hij weet dat bepaalde waarden of verwijzingen niet kunnen worden gewijzigd.
• Code begrijpelijker maken: Door variabelen, methoden of klassen als definitief te declareren, kunnen ontwikkelaars hun code begrijpelijker maken en erover redeneren. Wanneer een waarde of verwijzing als definitief wordt gemarkeerd, is het duidelijk dat deze niet zal veranderen, wat codeanalyse en foutopsporing kan vereenvoudigen.
• Hergebruik van code bevorderen: Door methoden als definitief te declareren, kunnen ontwikkelaars voorkomen dat subklassen deze overschrijven. Dit kan helpen het hergebruik van code te bevorderen en duplicatie te verminderen, omdat subklassen de implementatie van de methode door de bovenliggende klasse moeten gebruiken.
• Beveiliging verbeteren: Het gebruik van final kan de veiligheid helpen verbeteren door te voorkomen dat kwaadaardige code gevoelige gegevens of gedrag wijzigt.

Over het geheel genomen is het laatste trefwoord een nuttig hulpmiddel om de codekwaliteit te verbeteren en ervoor te zorgen dat bepaalde aspecten van een programma niet kunnen worden gewijzigd. Door variabelen, methoden en klassen als definitief te declareren, kunnen ontwikkelaars veiligere, robuustere en onderhoudbare code schrijven.

Voor meer voorbeelden en gedrag van eindmethoden en eindklassen , alsjeblieft zie Finale gebruiken met overerving. Zie de abstract in Java artikel voor verschillen tussen de laatste en de abstract .

Gerelateerde interviewvraag (belangrijk): Verschil tussen definitief, definitief en finaliseren in Java

Conclusie

Het laatste trefwoord in Java is een methode om door de gebruiker beperkte variabelen, methoden of klassen te maken. In deze tutorial behandelen we het laatste trefwoord van Java in detail en begrijpen we alle contexten ervan.

De contexten worden met Java-programma's in voorbeelden uitgelegd, waardoor een volledig begrip van het onderwerp ontstaat.

Java-eindzoekwoord – Veelgestelde vragen

Wat is een laatste methode in Java?

Een laatste methode in Java is een methode die is gedeclareerd met de laatste trefwoord , wat betekent dat de implementatie ervan niet kan worden overschreven door subklassen.

Wordt de uiteindelijke methode geërfd?

Nee, in Java kan een definitieve methode niet worden overgenomen door een subklasse. Dit betekent dat een subklasse kan een definitieve methode niet overschrijven .

Wat is het laatste trefwoord en het statische trefwoord in Java?

Uiteindelijk zoekwoord: Het wordt gebruikt om variabelen, methoden of klassen als niet-wijzigbaar te declareren.

Statisch trefwoord: Het wordt gebruikt om klasseleden (variabelen en methoden) te declareren die tot de klasse zelf behoren, niet tot individuele objecten.

Kunnen we het uiteindelijke trefwoord met een string in Java schrijven?

Ja, u kunt een variabele declareren met het laatste trefwoord en er een letterlijke tekenreeks aan toewijzen.