Java final : le mo­di­fi­ca­teur pour les classes, méthodes et variables

Le mot-clé final est utilisé en Java pour créer des éléments non mo­di­fiables ul­té­rieu­re­ment. Ce mo­di­fi­ca­teur peut être appliqué aux classes, aux méthodes et aux variables. Il sert notamment à prévenir les erreurs et à empêcher les abus vo­lon­taires dans le code.

Java final, c’est quoi au juste ?

La plupart des langages de pro­gram­ma­tion offrent la pos­si­bi­lité de modifier et d’étendre le code existant à volonté. Ceci est en principe également possible en langage Java, mais parfois, définir un élément comme in­va­riable peut être essentiel. Pour ce faire, en Java, le mo­di­fi­ca­teur cor­res­pon­dant est appelé final. Il peut servir à res­treindre l’accès à une classe, une méthode ou une variable. Ainsi, par la suite, il est im­pos­sible de modifier la valeur d’une variable finale, d’étendre une classe finale ou de suspendre une méthode finale. Cela permet d’interdire toute uti­li­sa­tion abusive de la section de code concernée.

Les classes finales

Si Java final est utilisé pour une classe, l’extension de celle-ci n’est plus possible. Cette méthode est très courante et très utile, dans de nombreux cas, pour empêcher la dé­ri­va­tion d’une sous-classe. Cela vaut en par­ti­cu­lier pour les types de données de base tels que java.lang.Math ou java.lang.String qui sont toujours définis comme final. Si, pour d’autres raisons, vous souhaitez empêcher les sous-classes d’une classe prin­ci­pale d’être dérivées, Java final est la meilleure solution. L’exemple suivant montre la création d’une classe avec le mot-clé final et la création d’une deuxième classe qui doit théo­ri­que­ment l’étendre. En troisième position suit la classe main avec la méthode main.

final class ClasseFinale {
	public void exemple_de_methode() {
		System.out.println("Il s’agit d‘une méthode au sein de la classe finale.");
	}
}
class AutreClasse extends ClasseFinale {
	public void exemple_de_methode() {
		System.out.println("La méthode est maintenant aussi dans l’autre classe.");
	}
}
public class Main {
	public static void main(String[] args) {
		AutreClasse notreAutreClasse = new AutreClasse();
		notreAutreClasse.exemple_de_methode();
	}
}

L’in­di­ca­tion obtenue devrait prendre la forme suivante :

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

Les méthodes finales

Si une méthode est définie comme finale, elle ne peut pas être écrasée. Cela empêche, entre autres, qu’une méthode dans une classe su­bor­don­née puisse avoir une autre sig­ni­fi­ca­tion. Pour éviter cela, il suffit de créer une méthode finale avec le mo­di­fi­ca­teur Java final. Dans notre exemple, nous créons une classe appelée « Empereur », qui contient une méthode finale appelée « mon_titre ». La classe « Roi » suivante étend la classe « Empereur » en essayant d’écraser la méthode « mon_titre ». Pour la méthode main, nous utilisons « Prince » et essayons également d’accéder à la méthode. Dans le code, cela ressemble à ceci :

public class Empereur {
	public final void mon_titre() {
		System.out.println("Je suis l’empereur.");
	}
}
public class Roi extends Empereur {
	public final void mon_titre() {
		System.out.println("Je suis le roi.");
	}
}
public class Prince {
	public static void main(String[] args) {
		Roi mon_titre = new Roi();
		Roi.mon_titre();
	}
}

En ap­pli­quant ce code, le message d’erreur suivant s’affichera :

Main.java:9: error mon_titre() in Roi cannot override mon_titre() in Empereur public final void mon_titre() {
		^
overriden method is final

Les variables finales

Java final permet également de créer des variables de manière que leur valeur ne puisse pas être modifiée ul­té­rieu­re­ment. Cela devient essentiel lorsque certaines variables du code doivent rester cons­tantes. Dans l’exemple suivant, la variable x est créée avec la valeur 5. Nous tentons ensuite d’intégrer cette variable en lui at­tri­buant une nouvelle valeur. Le code cor­res­pon­dant se présente comme suit :

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

En utilisant ensuite la commande Java System.out.println pour afficher le résultat, nous obtenons le message d’erreur suivant :

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

Créer des variables finales vides

En Java, les variables doivent être en principe ini­tia­li­sées en leur at­tri­buant une valeur. En principe, les variables doivent être ini­tia­li­sées en Java. Si vous déclarez une variable finale vide, vous pouvez néanmoins l’ini­tia­li­ser avec un cons­truc­teur de classe. Voici un exemple de la forme que cela peut prendre dans le code :

public class Exemple {
	final String texte_exemple;
	Exemple() {
		texte_exemple = "Votre message se trouve ici.";
	}
	public static void main(String[] args) {
		Exemple nouvel_objet = new Exemple();
		System.out.println(nouvel_objet.texte_exemple);
	}
}

L’exécution de ce code génère l’in­di­ca­tion suivante :

Votre message se trouve ici.