De slutlig metod i Java används som en icke-åtkomstmodifierare gäller endast för a variabel , a metod , eller a klass. Den är van vid begränsa en användare i Java .

Följande är olika sammanhang där finalen används:

1. Variabel
2. Metod
3. Klass

Egenskaper för det slutliga nyckelordet i Java:

I Java används det sista nyckelordet för att indikera att en variabel, metod eller klass inte kan modifieras eller utökas. Här är några av dess egenskaper:

• Slutliga variabler: När en variabel deklareras som final kan dess värde inte ändras när den väl har initierats. Detta är användbart för att deklarera konstanter eller andra värden som inte bör ändras.
• Slutliga metoder : När en metod deklareras som final kan den inte åsidosättas av en underklass. Detta är användbart för metoder som är en del av en klasss publika API och bör inte modifieras av underklasser.
• Avslutande klasser: När en klass förklaras som slutgiltig kan den inte utökas med en underklass. Detta är användbart för klasser som är avsedda att användas som de är och som inte bör modifieras eller utökas.
• Initiering: Slutliga variabler måste initieras antingen vid tidpunkten för deklarationen eller i klassens konstruktor. Detta säkerställer att värdet på variabeln är inställt och inte kan ändras.
• Prestanda: Användningen av en final kan ibland förbättra prestandan, eftersom kompilatorn kan optimera koden mer effektivt när den vet att en variabel eller metod inte kan ändras.
• Säkerhet: Finalen kan hjälpa till att förbättra säkerheten genom att förhindra skadlig kod från att ändra känslig data eller beteende.

Sammantaget är det sista nyckelordet ett användbart verktyg för att förbättra kodkvaliteten och säkerställa att vissa aspekter av ett program inte kan modifieras eller utökas. Genom att förklara variabler, metoder och klasser som slutgiltiga kan utvecklare skriva säkrare, robustare och underhållbar kod.

Java Final Variable

När en variabel deklareras med sista sökordet , dess värdet kan inte ändras i huvudsak en konstant . Det betyder också att du måste initiera en slutlig variabel .

Om den slutliga variabeln är a referens , betyder det att variabeln inte kan vara återbinds till referens ett annat objekt, men det interna tillståndet för objektet som pekas av den referensvariabeln kan ändras, dvs du kan lägga till eller ta bort element från slutlig array eller slutlig samling.

Det är god praxis att representera slutvariabler med stora bokstäver och använda understreck för att separera ord.

Exempel:

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>

Produktion:

  Value of PI: 3.14159>

Olika metoder för att använda slutlig variabel

Låt oss se olika metoder som vi kan använda slutvariabeln i Java.

1. slutlig variabel

Exempel:

// Final variable final int THRESHOLD = 5;>

2. Tom slutlig variabel

Exempel:

// Blank final variable final int THRESHOLD;>

3. Statisk slutvariabel

Exempel:

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

4. Statisk Blank final variabel

Exempel:

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

Initiering av en slutlig variabel

Vi måste initiera en slutlig variabel, annars kommer kompilatorn att skapa ett kompileringsfel. En slutlig variabel kan bara initieras en gång, antingen via en initialiserare eller en uppdragsbeskrivning. Det finns tre sätt att initiera en slutlig variabel:

abstrakt klass

1. Du kan initiera en slutlig variabel när den deklareras. Detta tillvägagångssätt är det vanligaste. En slutlig variabel kallas a tom slutvariabel om den är inte initieras under deklarationen. Nedan finns två sätt att initiera en tom slutvariabel.
2. En tom slutvariabel kan initieras inuti en instansinitieringsblock eller konstruktören. Om du har mer än en konstruktor i din klass måste den initieras i alla, annars kommer ett kompileringsfel att skapas.
3. En tom slutlig statisk variabel kan initieras inuti a statiskt block .

Låt oss se dessa två olika sätt att initiera en slutlig variabel

Exempel:

// 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;  }   }>

Det fanns ingen huvudmetod i ovanstående kod eftersom det bara var i illustrationssyfte för att få en bättre förståelse för att dra slutsatser:

Observation 1: När ska man använda en slutlig variabel?

Den enda skillnaden mellan en normalvariabel och en slutlig variabel är att vi kan återtilldela värdet till en normalvariabel men vi kan inte ändra värdet på en slutlig variabel när den väl tilldelats. Därför måste slutvariabler endast användas för de värden som vi vill ska förbli konstanta under hela programmets körning.

Observation 2: Referens till slutvariabel.

När en slutlig variabel är en referens till ett objekt, kallas denna slutvariabel för referens slutlig variabel . Till exempel en final StringBuffer variabel utseende definieras nedan enligt följande:

final StringBuffer sb;>

Som vi alla vet kan en slutlig variabel inte tilldelas om. Men i fallet med en slutlig referensvariabel kan det interna tillståndet för objektet som pekas av den referensvariabeln ändras. Observera att detta inte är omtilldelning.

Denna egenskap hos slutlig kallas icke-transitivitet . För att förstå vad som menas med objektets interna tillstånd som visas i exemplet nedan så här:

Exempel 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 icke-transitivitet egenskapen gäller även för arrayer, eftersom matriser är objekt i Java. Arrayer med sista sökordet kallas också slutliga arrayer .

Notera: Som diskuterats ovan kan en slutlig variabel inte tilldelas om, eftersom det kommer att leda till kompileringsfel.

Exempel 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;  } }>

Produktion:

Kom ihåg: När en slutlig variabel skapas inuti en metod/konstruktor/block kallas den lokal slutvariabel, och den måste initialiseras en gång där den skapas. Se nedan program för lokal slutvariabel.

Exempel:

// 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>

Kom ihåg dessa nyckelpunkter som de uppfattas innan du går vidare enligt nedan enligt följande:

1. Notera skillnaden mellan C++ konst variabler och Java slutlig variabler. const-variabler i C++ måste vara tilldelas ett värde när de deklareras . För slutvariabler i Java är det inte nödvändigt som vi ser i exemplen ovan. En slutlig variabel kan tilldelas värde senare, men bara en gång.
2. slutlig med varje slinga : final med för varje påstående är ett juridiskt uttalande.

Exempel:

// 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>

Utgångsförklaring: Sedan i variabeln går utanför omfånget med varje iteration av loopen, den deklareras om varje iteration, vilket gör att samma token (i) kan användas för att representera flera variabler.

Exempel:

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 sista klasser

När en klass deklareras med slutlig nyckelord i Java kallas det för a sista klass . En sista klass kan inte vara förlängd (ärvd) .

abstrakt klass i java

Det finns två användningsområden för en sista klass:

Användning 1: En är definitivt att förebygga arv , eftersom slutklasserna inte kan förlängas. Till exempel alla Omslagsklasser tycka om Heltal , Flyta , etc. är slutklasser. Vi kan inte förlänga dem.

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

Användning 2: Den andra användningen av final med klasser är att skapa en oföränderlig klass som den fördefinierade Sträng klass. Man kan inte göra en klass oföränderlig utan att göra den final.

Java slutlig metod

När en metod deklareras med slutlig nyckelord kallas det a slutlig metod i Java. En slutlig metod kan inte vara åsidosatt .

De Objekt klass gör detta – ett antal av dess metoder är slutgiltiga. Vi måste deklarera metoder med det sista nyckelordet för vilka vi måste följa samma implementering genom alla härledda klasser.

Illustration: Sista nyckelordet med en metod

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!');  } }>

Fördelar med slutligt sökord i Java:

Det sista nyckelordet i Java ger flera fördelar, inklusive:

• Säkerställ oföränderlighet: När en variabel eller referens markeras som slutgiltig kan dess värde inte ändras när den väl har tilldelats. Detta hjälper till att säkerställa att data är oföränderlig och inte kan ändras av misstag eller med uppsåt.
• Förbättra prestanda : Användningen av finalen kan ibland bidra till att förbättra prestandan, eftersom Java Virtual Machine (JVM) kan optimera koden mer effektivt när den vet att vissa värden eller referenser inte kan ändras.
• Gör koden lättare att förstå: Genom att förklara variabler, metoder eller klasser som slutgiltiga kan utvecklare göra sin kod lättare att förstå och resonera kring. När ett värde eller referens markeras som slutgiltigt är det tydligt att det inte kommer att förändras, vilket kan förenkla kodanalys och felsökning.
• Marknadsför återanvändning av kod: Genom att förklara metoder som slutgiltiga kan utvecklare förhindra att underklasser åsidosätter dem. Detta kan hjälpa till att främja återanvändning av kod och minska duplicering, eftersom underklasser måste använda förälderklassens implementering av metoden.
• Förbättra säkerheten: Användningen av final kan bidra till att förbättra säkerheten genom att förhindra skadlig kod från att ändra känslig data eller beteende.

Sammantaget är det sista nyckelordet ett användbart verktyg för att förbättra kodkvaliteten och säkerställa att vissa aspekter av ett program inte kan modifieras. Genom att förklara variabler, metoder och klasser som slutgiltiga kan utvecklare skriva säkrare, robustare och underhållbar kod.

För fler exempel och beteende av slutmetoder och slutklasser , snälla se Använder final med arv. Vänligen se abstrakt i java artikel för skillnader mellan slutlig och den abstrakt .

Relaterad intervjufråga (viktigt): Skillnaden mellan final, finally och finalize i Java

Slutsats

Det sista nyckelordet i Java är en metod för att skapa användarbegränsade variabler, metoder eller klasser. I den här handledningen täcker vi Javas sista nyckelord i detalj och förstår alla dess sammanhang.

Sammanhangen förklaras med Java-program i exempel, vilket ger en fullständig förståelse av ämnet.

Java Final Keyword – Vanliga frågor

Vad är en sista metod i Java?

En sista metod i Java är en metod som deklareras med sista sökordet , vilket betyder att dess implementering inte kan åsidosättas av underklasser.

Ärvs den slutliga metoden?

Nej, i Java kan en slutlig metod inte ärvas av en underklass. Detta innebär att en underklass kan inte åsidosätta en slutlig metod .

Vad är det sista nyckelordet och det statiska nyckelordet i Java?

Sista sökord: Den används för att deklarera variabler, metoder eller klasser som oföränderliga.

Statiskt nyckelord: Det används för att deklarera klassmedlemmar (variabler och metoder) som tillhör själva klassen, inte enskilda objekt.

Kan vi skriva det sista nyckelordet med en sträng i Java?

Ja, du kan deklarera en variabel med det sista nyckelordet och tilldela den en bokstavlig sträng.