Java final: come uti­liz­za­re questo mo­di­fi­ca­to­re per classi, metodi e variabili

La parola chiave final in Java serve a creare elementi che non possono più essere mo­di­fi­ca­ti in un secondo momento. Questo mo­di­fi­ca­to­re è uti­liz­za­bi­le su classi, metodi e variabili. In par­ti­co­la­re è utile per impedire errori e usi scorretti e de­li­be­ra­ti all’interno del codice.

Che cos’è Java final?

La maggior parte dei linguaggi di pro­gram­ma­zio­ne permette di mo­di­fi­ca­re ed espandere a piacere il codice esistente. In linea di massima è possibile farlo anche in Java, ma talvolta può essere im­por­tan­te che un elemento sia definito come non mo­di­fi­ca­bi­le. Il mo­di­fi­ca­to­re per questa ope­ra­zio­ne in Java è final. È possibile uti­liz­zar­lo per limitare l’accesso a una classe, a un metodo o a una variabile. In questo modo, non è più possibile cambiare il valore di una variabile finale, espandere una classe finale e so­spen­de­re un metodo finale. Così facendo si impedisce un uso scorretto della sezione di codice in questione.

Classi finali

Se si utilizza Java final per una classe, non è più possibile espan­der­la. Questo approccio è molto diffuso, in quanto in molti casi può essere opportuno impedire la de­ri­va­zio­ne di una sot­to­clas­se. Questo vale in par­ti­co­la­re per i tipi di dati di base come java.lang.Math oppure java.lang.string che sono sempre di­chia­ra­ti come finali. Java final è la soluzione migliore anche per impedire la de­ri­va­zio­ne di sot­to­clas­si di una classe prin­ci­pa­le per altri motivi. Nell’esempio seguente creiamo una classe finale e una seconda classe che in teoria deve espan­der­la. Al terzo posto si trova la classe main con il metodo main.

final class ClasseFinale {
	public void metodoesempio() {
		System.out.println("Questo è un metodo all'interno della classe finale.");
	}
}
class ClasseUlteriore extends ClasseFinale {
	public void metodoesempio() {
		System.out.println("Ora il metodo è anche nella classe ulteriore.");
	}
}
public class Main {
	public static void main(String[] args) {
		ClasseUlteriore nostraClasseUlteriore = new ClasseUlteriore();
		nostraClasseUlteriore.metodoesempio();
	}
}

Il risultato che otteniamo dovrebbe essere il seguente:

Main.java:6: error: cannot inherit from final ClasseFinale
class ClasseUlteriore extends ClasseFinale
       ^
1 error

Metodi finali

Un metodo con­tras­se­gna­to come finale non può essere so­vra­scrit­to. In questo modo si impedisce inoltre che un metodo possa ricevere un altro si­gni­fi­ca­to in una classe su­bor­di­na­ta. Se desideri impedirlo, crea un metodo finale con il mo­di­fi­ca­to­re Java final. Per farlo, crea ad esempio una classe di nome “Im­pe­ra­to­re” che contenga al suo interno un metodo finale di nome “il­mio­Ti­to­lo”. La suc­ces­si­va classe “Re” espande “Im­pe­ra­to­re” e tenta di so­vra­scri­ve­re il metodo “il­mio­Ti­to­lo”. Per il metodo main uti­liz­zia­mo “Principe” e tentiamo di accedere ugual­men­te al metodo. Il codice si presenta nel modo seguente:

public class Imperatore {
	public final void ilmioTitolo() {
		System.out.println("Io sono l'Imperatore.");
	}
}
public class Re extends Imperatore {
	public final void ilmioTitolo() {
		System.out.println("Io sono il Re.");
	}
}
public class Principe {
	public static void main(String[] args) {
		Re ilmioTitolo = new Re();
		Re.ilmioTitolo();
	}
}

Ora, ap­pli­can­do questo codice, otteniamo un messaggio di errore:

Main.java:9: error ilmioTitolo() in Re cannot override ilmioTitolo() in Imperatore public final void ilmioTitolo() {
		^
overriden method is final

Variabili finali

Java final è uti­liz­za­to anche per creare variabili in modo tale da non poterne più cambiare il valore suc­ces­si­va­men­te. Questa pos­si­bi­li­tà è im­por­tan­te so­prat­tut­to se de­ter­mi­na­te variabili nel codice devono rimanere sempre costanti. Nell’esempio seguente creiamo una variabile x che contiene il valore 5. Suc­ces­si­va­men­te tentiamo di integrare questa variabile e di as­se­gnar­le un nuovo valore. Il relativo codice si presenta così:

public class Main {
	final int x = 5;
public static void main(String[] args) {
	Main nuovoValore = new Main();
	nuovoValore.x = 10;
	System.out.println(nuovoValore.x);
	}
}

Se ora uti­liz­zia­mo il comando Java System.out.println per vi­sua­liz­za­re il risultato, otteniamo il seguente messaggio di errore:

Main.java:6: error: cannt assign a value to final variable x
	nuovoValore.x = 10;
		     ^
1 error

Creazione di variabili finali vuote

In linea di massima le variabili in Java devono essere ini­zia­liz­za­te. Se però scegli di di­chia­ra­re una variabile finale vuota, puoi ini­zia­liz­zar­la con un co­strut­to­re di classe. Nel codice, questa soluzione si presenta così:

public class Esempio {
	final String testoesempio;
	Esempio() {
		testoesempio = "Questo è il tuo messaggio.";
	}
	public static void main(String[] args) {
		Esempio nuovoOggetto = new Esempio();
		System.out.println(nuovoOggetto.testoesempio);
	}
}

Eseguendo questo codice, ottieni come risultato la seguente frase:

Questo è il tuo messaggio.