IL metodo finale in Java è usato come a modificatore di non accesso applicabile solo ad a variabile , UN metodo , o a classe. È abituato limitare un utente a Giava .

I seguenti sono contesti diversi dove viene utilizzata la finale:

1. Variabile
2. Metodo
3. Classe

Caratteristiche della parola chiave finale in Java:

In Java, la parola chiave final viene utilizzata per indicare che una variabile, un metodo o una classe non può essere modificata o estesa. Ecco alcune delle sue caratteristiche:

• Variabili finali: Quando una variabile viene dichiarata come finale, il suo valore non può essere modificato una volta inizializzata. Ciò è utile per dichiarare costanti o altri valori che non devono essere modificati.
• Metodi finali : Quando un metodo viene dichiarato finale, non può essere sovrascritto da una sottoclasse. Ciò è utile per i metodi che fanno parte dell'API pubblica di una classe e non devono essere modificati dalle sottoclassi.
• Lezioni finali: Quando una classe viene dichiarata finale, non può essere estesa da una sottoclasse. Ciò è utile per le classi destinate ad essere utilizzate così come sono e che non devono essere modificate o estese.
• Inizializzazione: Le variabili finali devono essere inizializzate al momento della dichiarazione o nel costruttore della classe. Ciò garantisce che il valore della variabile sia impostato e non possa essere modificato.
• Prestazione: L'uso di un final a volte può migliorare le prestazioni, poiché il compilatore può ottimizzare il codice in modo più efficace quando sa che una variabile o un metodo non può essere modificato.
• Sicurezza: Il finale può aiutare a migliorare la sicurezza impedendo a codice dannoso di modificare dati o comportamenti sensibili.

Nel complesso, la parola chiave finale è uno strumento utile per migliorare la qualità del codice e garantire che alcuni aspetti di un programma non possano essere modificati o estesi. Dichiarando variabili, metodi e classi come finali, gli sviluppatori possono scrivere codice più sicuro, robusto e gestibile.

Variabile finale Java

Quando una variabile viene dichiarata con il file parola chiave finale , suo il valore non può essere modificato , in sostanza, a costante . Questo significa anche che tu deve inizializzare una variabile finale .

Se la variabile finale è a riferimento , ciò significa che la variabile non può essere rilegato al riferimento un altro oggetto, ma lo stato interno dell'oggetto puntato da quella variabile di riferimento può essere modificato, ovvero puoi aggiungere o rimuovere elementi dal schiera finale o ritiro finale.

È buona norma rappresentare le variabili finali in maiuscolo, utilizzando il carattere di sottolineatura per separare le parole.

Esempio:

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>

Produzione:

  Value of PI: 3.14159>

Diversi metodi di utilizzo della variabile finale

Vediamo diversi metodi che possiamo utilizzare la variabile finale in Java.

1. Variabile finale

Esempio:

// Final variable final int THRESHOLD = 5;>

2. Variabile finale vuota

Esempio:

// Blank final variable final int THRESHOLD;>

3. Variabile finale statica

Esempio:

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

4. Variabile finale statica vuota

Esempio:

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

Inizializzazione di una variabile finale

Dobbiamo inizializzare una variabile finale, altrimenti il ​​compilatore genererà un errore in fase di compilazione. Una variabile finale può essere inizializzata solo una volta, tramite an inizializzatore o una dichiarazione di incarico. Esistono tre modi per inizializzare una variabile finale:

topologia a stella

1. È possibile inizializzare una variabile finale quando viene dichiarata. Questo approccio è il più comune. Una variabile finale è chiamata a variabile finale vuota se è non inizializzato durante la dichiarazione. Di seguito sono riportati i due modi per inizializzare una variabile finale vuota.
2. Una variabile finale vuota può essere inizializzata all'interno di un file blocco inizializzatore di istanza o il costruttore. Se hai più di un costruttore nella tua classe, deve essere inizializzato in tutti, altrimenti verrà generato un errore in fase di compilazione.
3. Una variabile statica finale vuota può essere inizializzata all'interno di a blocco statico .

Vediamo questi due diversi modi di inizializzare una variabile finale

Esempio:

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

Non esisteva un metodo principale nel codice sopra poiché era semplicemente a scopo illustrativo per ottenere una migliore comprensione e trarre conclusioni:

Osservazione 1: Quando utilizzare una variabile finale?

L'unica differenza tra una variabile normale e una variabile finale è che possiamo riassegnare il valore a una variabile normale ma non possiamo modificare il valore di una variabile finale una volta assegnata. Pertanto le variabili finali devono essere utilizzate solo per i valori che vogliamo rimangano costanti durante l'esecuzione del programma.

Osservazione 2: Variabile finale di riferimento.

Quando una variabile finale è un riferimento a un oggetto, allora questa variabile finale è chiamata the variabile finale di riferimento . Ad esempio, una finale StringBuffer la variabile appare definita di seguito come segue:

final StringBuffer sb;>

Come tutti sappiamo, una variabile finale non può essere riassegnata. Ma nel caso di una variabile finale di riferimento, lo stato interno dell'oggetto puntato da quella variabile di riferimento può essere modificato. Tieni presente che questa non è una riassegnazione.

Questa proprietà del finale è chiamato non transitività . Per capire cosa si intende per stato interno dell'oggetto come mostrato nell'esempio seguente, come segue:

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

IL non transitività La proprietà si applica anche agli array, perché matrici sono oggetti in Java. Array con il parola chiave finale sono anche chiamati matrici finali .

Nota: Come discusso in precedenza, una variabile finale non può essere riassegnata, poiché ciò genererebbe un errore in fase di compilazione.

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

Produzione:

Ricordare: Quando una variabile finale viene creata all'interno di un metodo/costruttore/blocco, viene chiamata variabile finale locale e deve essere inizializzata una volta nel punto in cui è stata creata. Vedi il programma sotto per la variabile finale locale.

Esempio:

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

Ricorda questi punti chiave come percepiti prima di andare avanti come elencato di seguito come segue:

1. Nota la differenza tra C++ cost variabili e Java finale variabili. const in C++ devono essere assegnato un valore quando dichiarato . Per le variabili finali in Java, lo è non necessario come vediamo negli esempi precedenti. A una variabile finale può essere assegnato un valore in seguito, ma solo una volta.
2. finale con per ciascun ciclo : finale con for-each è una dichiarazione legale.

Esempio:

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

Spiegazione dell'output: Dal momento che io La variabile esce dall'ambito con ogni iterazione del ciclo, viene dichiarata nuovamente a ogni iterazione, consentendo l'utilizzo dello stesso token (i) per rappresentare più variabili.

Esempio:

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

Lezioni finali Java

Quando una classe viene dichiarata con il file finale parola chiave in Java, si chiama a lezione finale . Una lezione finale non può esserlo esteso (ereditato) .

Ci sono due usi di una classe finale:

Utilizzo 1: Uno è sicuramente quello di prevenire eredità , poiché le lezioni finali non possono essere prolungate. Ad esempio, tutti Classi wrapper Piace Numero intero , Galleggiante , ecc. sono lezioni finali. Non possiamo estenderli.

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

Utilizzo 2: L'altro uso del finale con le classi è quello creare una classe immutabile come quello predefinito Corda classe. Non è possibile rendere immutabile una classe senza renderla definitiva.

Metodo finale Java

Quando un metodo viene dichiarato con finale parola chiave, si chiama a metodo finale a Giava. Un metodo finale non può esserlo sovrascritto .

IL Oggetto fa questo: molti dei suoi metodi sono definitivi. Dobbiamo dichiarare i metodi con la parola chiave finale per la quale dobbiamo seguire la stessa implementazione in tutte le classi derivate.

Illustrazione: Parola chiave finale con un metodo

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

Vantaggi della parola chiave finale in Java:

La parola chiave finale in Java offre numerosi vantaggi, tra cui:

• Garantire l'immutabilità: Quando una variabile o un riferimento è contrassegnato come finale, il suo valore non può essere modificato una volta assegnato. Ciò aiuta a garantire che i dati siano immutabili e non possano essere modificati accidentalmente o in modo dannoso.
• Miglioramento delle prestazioni : L'uso del finale a volte può aiutare a migliorare le prestazioni, poiché la Java Virtual Machine (JVM) può ottimizzare il codice in modo più efficace quando sa che determinati valori o riferimenti non possono essere modificati.
• Rendere il codice più facile da capire: Dichiarando variabili, metodi o classi come finali, gli sviluppatori possono rendere il loro codice più facile da comprendere e su cui ragionare. Quando un valore o un riferimento è contrassegnato come finale, è chiaro che non cambierà, il che può semplificare l'analisi del codice e il debug.
• Promozione del riutilizzo del codice: Dichiarando i metodi come final, gli sviluppatori possono impedire alle sottoclassi di sovrascriverli. Ciò può aiutare a promuovere il riutilizzo del codice e a ridurre la duplicazione, poiché le sottoclassi devono utilizzare l’implementazione del metodo della classe genitore.
• Migliorare la sicurezza: L'uso di final può contribuire a migliorare la sicurezza impedendo a codice dannoso di modificare dati o comportamenti sensibili.

Nel complesso, la parola chiave finale è uno strumento utile per migliorare la qualità del codice e garantire che alcuni aspetti di un programma non possano essere modificati. Dichiarando variabili, metodi e classi come finali, gli sviluppatori possono scrivere codice più sicuro, robusto e gestibile.

Per ulteriori esempi e comportamento dei metodi finali e delle classi finali , perfavore guarda Utilizzo di final con ereditarietà. Si prega di consultare il astratto in Java articolo per le differenze tra il finale e il astratto .

Domanda correlata all'intervista (importante): Differenza tra final,finalmente e finalize in Java

Conclusione

La parola chiave finale in Java è un metodo per creare variabili, metodi o classi limitate dall'utente. In questo tutorial, trattiamo in dettaglio la parola chiave finale di Java e ne comprendiamo tutti i contesti.

intero Java

I contesti vengono spiegati con programmi Java in esempi, fornendo una completa comprensione della materia.

Parola chiave finale Java: domande frequenti

Cos'è un metodo finale in Java?

Un metodo finale in Java è un metodo dichiarato con il file parola chiave finale , il che significa che la sua implementazione non può essere sovrascritta dalle sottoclassi.

Il metodo finale è ereditato?

No, in Java un metodo finale non può essere ereditato da una sottoclasse. Ciò significa che una sottoclasse non è possibile sovrascrivere un metodo finale .

Qual è la parola chiave finale e la parola chiave statica in Java?

Parola chiave finale: Viene utilizzato per dichiarare variabili, metodi o classi come immodificabili.

Parola chiave statica: viene utilizzata per dichiarare i membri della classe (variabili e metodi) che appartengono alla classe stessa, non ai singoli oggetti.

Possiamo scrivere la parola chiave finale con una stringa in Java?

Sì, puoi dichiarare una variabile con la parola chiave final e assegnarle una stringa letterale.