Introduzione alla parola chiave finale in Java
In questo post, esamineremo la diversa parola chiave finale per java. È una parola chiave utilizzata nel linguaggio Java per applicare restrizioni sul suo utilizzo o modifica da parte di altre classi o variabili. Usando questa parola chiave si dice all'interprete di non permettere alcuna modifica futura a quella variabile o metodo e di trattarla come costante. Può essere utilizzato con 3 scenari seguenti: -
- Variabile: dichiarare una variabile come finale limita la sua modifica per fare riferimento a qualsiasi altro valore o riferimento.
- Metodi: la dichiarazione di un metodo come finale limita la sostituzione del metodo di quel metodo nelle classi figlio.
- Classi: la dichiarazione di una classe come finale impedisce l'eredità di quella classe.
Si raccomanda sempre che queste parole chiave siano dichiarate in maiuscolo secondo le buone pratiche di codifica.
Sintassi della parola chiave finale in Java
Questa parola chiave può essere utilizzata in 3 modi seguenti: -
1. Variabile
Le variabili in Java possono essere dichiarate come variabili per limitare qualsiasi modifica ai suoi valori. Può essere dichiarato in uno dei tre modi seguenti:
Sintassi:
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. Metodi
Si dice che il metodo dichiarato con la parola chiave finale sia il metodo finale. Il metodo finale non può essere ignorato dalla sua classe figlio, il che significa che il metodo della classe figlio non può cambiare la definizione del metodo finale presente nella classe genitore. Quando vogliamo che l'implementazione di un metodo definito nella classe genitore debba essere seguita in tutte le sue classi figlie allora dobbiamo dichiarare quel metodo come finale.
Sintassi:
final int my1()(
//method defination
)
3. Classi
Le parole chiave finali possono anche essere utilizzate con le classi per renderla una classe finale, il che significa che la classe particolare non può essere estesa o ereditata da altre classi.
Sintassi:
final class myClass(
/member variables and member functions.
)
Come funziona la parola chiave finale in Java?
La parola chiave finale aiuta a limitare la sostituzione di classi, membri o variabili durante l'ereditarietà.
1. Variabili finali
Dichiarare una variabile come finale significa limitare qualsiasi modifica al valore della variabile nelle classi ereditate. Una variabile finale può essere inizializzata una sola volta e deve essere utilizzata così com'è, quindi è necessario inizializzare una variabile finale. Viene utilizzato principalmente con static per creare una variabile di classe costante.
Per esempio:
final int a =0;
Possiamo anche dichiarare le variabili di riferimento definitive anche, in questo caso, una variabile di riferimento non può riferirsi a oggetti diversi. Ma in Java, è possibile modificare lo stato interno di un oggetto a cui fa riferimento la variabile di riferimento finale. In questo modo possiamo apportare modifiche al valore della variabile di riferimento. Questo è uguale all'utilizzo di array finali come mostrato di seguito: -
Codice:
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));
)
)
)
Produzione:
Spiegazione
Qui l'array a1 si riferisce allo stesso oggetto solo il valore di quell'oggetto sta cambiando perché sappiamo tutti che la variabile dell'array contiene solo l'indirizzo iniziale della posizione di memoria in cui sono memorizzati quegli elementi dell'array.
E allo stesso modo, se proviamo a fare riferimento a un array diverso utilizzando la stessa variabile di array a1, il compilatore genererà un errore. Pertanto, usando l'array final-word qui significa che è possibile apportare qualsiasi modifica al membro dell'array ma alla variabile non è consentito fare riferimento a nessun altro oggetto.
Cose da ricordare
L'inizializzazione di una variabile finale è necessaria per evitare errori durante la compilazione. Esiste una differenza tra le variabili const C ++ e queste variabili finali non è necessario inizializzare le variabili const. Esistono tre modi per inizializzare una variabile finale:
- Inizializza al momento della dichiarazione stessa : possiamo facilmente dichiarare una variabile finale al momento della dichiarazione. Nel caso in cui non sia inizializzato, quella variabile viene considerata come una variabile finale vuota e uno dei 2 modi seguenti può aiutarci a inizializzare una variabile finale vuota.
- Utilizzo del blocco inizializzatore istanza : all'interno di questo blocco o del costruttore, è possibile inizializzare facilmente una variabile finale vuota. Durante l'utilizzo di un costruttore per l'inizializzazione, ricordarsi sempre di inizializzare la variabile particolare in tutti i costruttori disponibili.
- Blocco statico: è anche possibile utilizzare un blocco statico per inizializzare la variabile finale vuota. Il blocco statico viene sempre attivato una volta per ogni classe, pertanto il valore della variabile i cui valori non devono essere modificati può essere facilmente inizializzato utilizzando questo blocco.
Pertanto la parola chiave finale viene utilizzata solo per quelle variabili che non devono modificare il loro valore durante l'esecuzione del programma. Tutte le variabili finali create all'interno di un metodo o blocco devono essere inizializzate lì stesso. Tali variabili di tipo sono note come variabili finali locali.
Spiegazione
Nell'esempio seguente, una variabile i è stata dichiarata all'interno della funzione principale e anche inizializzata è quindi considerata una variabile locale finale.
Codice:
class myClass
(
public static void main(String args())
(
// local final variable
final int i;
i = 20;
System.out.println(i);
)
)
Produzione:
2. Metodi finali
Un metodo dichiarato come finale non può essere ignorato in nessuna delle sottoclassi, quindi chiamato come metodo finale. Il metodo deve essere dichiarato come definitivo se si richiede che la stessa implementazione della classe sia seguita dalle classi figlio.
Nota : non è necessario che i metodi finali vengano dichiarati nella fase iniziale dell'ereditarietà (classe base). Il metodo può essere dichiarato definitivo in qualsiasi sottoclasse che desidera che ulteriori sottoclassi seguano la stessa definizione.Codice:
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. Classi finali
Le classi dichiarate come finali non possono essere ereditate da altre classi. Menzionare una parola chiave finale prima del nome della classe indica al compilatore che la definizione di questa classe può essere utilizzata solo così come sono. Nessun'altra classe può aggiungere le proprie specifiche a questa definizione o riutilizzarne il codice. Nel caso in cui si tenta di estendere la classe finale, viene generato un errore dal compilatore che indica che questa classe non è pensata per essere estesa. Si possono usare le parole chiave finali in Java in qualsiasi per scopi inferiori a 2: -
- Il primo è impedire l'eredità di quella classe. Ad esempio, tutte le classi Wrapper presenti nel pacchetto java.lang sono classi finali per cui non possiamo estenderle nelle nostre classi ma possiamo usarle dichiarando i loro oggetti. Qualsiasi tentativo di accedere a tali classi comporterà un errore da parte del compilatore.
final class myParentClass
(
// member variables and member functions
)
// illegal extend.
class myChildClass extends parentClass
(
// Can't subclass A
)
- Il secondo uso di final con le classi è quando è necessario creare una classe immutabile, cioè una volta creato l'oggetto della classe non possiamo cambiarne il contenuto come la classe String predefinita. La classe deve essere dichiarata come definitiva per renderla immutabile.
Nota :
- Se una classe viene dichiarata come definitiva, anche le variabili membro e le funzioni membro vengono considerate come finali dal compilatore.
- Una classe non può essere dichiarata astratta laddove dipende dalle classi figlio per completare la sua definizione e finale che impedisce l'eredità stessa.
Esempi di parole chiave finali in Java
Di seguito è riportato il diverso esempio di parola chiave finale in Java:
1. Utilizzo della variabile finale
Nell'esempio seguente variabili diverse vengono inizializzate utilizzando vari metodi. Ad esempio, la seconda variabile viene inizializzata utilizzando il costruttore mentre THIRD viene inizializzata utilizzando un inizializzatore.
Codice:
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
)
)
Produzione:
2. Utilizzo dei metodi finali
Nell'esempio seguente, la classe astratta myShape dichiara i metodi finali getWidth e ne ottiene otto che non devono essere sovrascritti dalle classi ereditate. Dichiara inoltre una funzione astratta la cui implementazione è obbligatoria nelle classi successive. Pertanto, l'unica definizione di una funzione astratta è implementata in una prima classe figlio e in una seconda classe figlio.
Codice:
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());
)
)
Produzione:
3. Utilizzo delle classi finali
Nel programma seguente, stiamo usando un solido di classe finale che definisce un metodo per calcolare il volume di una forma usando le sue dimensioni, ma la visualizzazione del volume di una scatola viene effettuata usando la funzione printVol nella classe ereditata. Shape As Solid è una classe finale, pertanto la classe Shape non potrà estenderla (o ereditarla). Quindi usa l'oggetto Shape per calcolare il volume di qualunque Shape semplicemente passando gli argomenti alle funzioni.
Codice:
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);
)
)
Produzione:
Conclusione
La parola chiave finale viene utilizzata per impedire che classi, variabili e metodi vengano sovrascritti dalle sue classi figlio. Può anche essere usato per rendere immutabili le classi che limitano la variazione del valore dei suoi oggetti. Il controllo finale delle parole chiave viene sempre verificato solo al momento della compilazione. È una grande utilità per impedire il riutilizzo delle variabili, della logica e delle classi definite.
Articoli consigliati
Questa è una guida all'esempio di Final Keyword in Java. Qui discutiamo di come funziona la parola chiave finale in Java? che include variabili finali, metodi finali, classi finali e sintassi. Puoi anche consultare i seguenti articoli per saperne di più -
- Tipi e modificatori utilizzati per JComponent in Java
- Nuove funzionalità di Java 8
- Come creare un oggetto in JavaScript?
- Che cos'è l'istruzione case in JavaScript?
- Lancio contro Lancio | Le 5 differenze principali che dovresti conoscere
- Dichiarazione della classe astratta in C # con l'esempio
- Usi ed esempi di questa parola chiave
