Java final: come utilizzare questo modificatore per classi, metodi e variabili

La parola chiave final in Java serve a creare elementi che non possono più essere modificati in un secondo momento. Questo modificatore è utilizzabile su classi, metodi e variabili. In particolare è utile per impedire errori e usi scorretti e deliberati all’interno del codice.

Che cos’è Java final?

La maggior parte dei linguaggi di programmazione permette di modificare ed espandere a piacere il codice esistente. In linea di massima è possibile farlo anche in Java, ma talvolta può essere importante che un elemento sia definito come non modificabile. Il modificatore per questa operazione in Java è final. È possibile utilizzarlo 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 sospendere 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 espanderla. Questo approccio è molto diffuso, in quanto in molti casi può essere opportuno impedire la derivazione di una sottoclasse. Questo vale in particolare per i tipi di dati di base come java.lang.Math oppure java.lang.string che sono sempre dichiarati come finali. Java final è la soluzione migliore anche per impedire la derivazione di sottoclassi di una classe principale per altri motivi. Nell’esempio seguente creiamo una classe finale e una seconda classe che in teoria deve espanderla. 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 contrassegnato come finale non può essere sovrascritto. In questo modo si impedisce inoltre che un metodo possa ricevere un altro significato in una classe subordinata. Se desideri impedirlo, crea un metodo finale con il modificatore Java final. Per farlo, crea ad esempio una classe di nome “Imperatore” che contenga al suo interno un metodo finale di nome “ilmioTitolo”. La successiva classe “Re” espande “Imperatore” e tenta di sovrascrivere il metodo “ilmioTitolo”. Per il metodo main utilizziamo “Principe” e tentiamo di accedere ugualmente 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, applicando 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 è utilizzato anche per creare variabili in modo tale da non poterne più cambiare il valore successivamente. Questa possibilità è importante soprattutto se determinate variabili nel codice devono rimanere sempre costanti. Nell’esempio seguente creiamo una variabile x che contiene il valore 5. Successivamente tentiamo di integrare questa variabile e di assegnarle 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 utilizziamo il comando Java System.out.println per visualizzare 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 inizializzate. Se però scegli di dichiarare una variabile finale vuota, puoi inizializzarla con un costruttore 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.