Java final : le modificateur pour les classes, méthodes et variables

Le mot-clé final est utilisé en Java pour créer des éléments non modifiables ultérieurement. Ce modificateur peut être appliqué aux classes, aux méthodes et aux variables. Il sert notamment à prévenir les erreurs et à empêcher les abus volontaires dans le code.

Java final, c’est quoi au juste ?

La plupart des langages de programmation offrent la possibilité 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 invariable peut être essentiel. Pour ce faire, en Java, le modificateur correspondant est appelé final. Il peut servir à restreindre l’accès à une classe, une méthode ou une variable. Ainsi, par la suite, il est impossible 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 utilisation 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érivation d’une sous-classe. Cela vaut en particulier 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 principale 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éoriquement 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’indication 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 subordonnée puisse avoir une autre signification. Pour éviter cela, il suffit de créer une méthode finale avec le modificateur 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 appliquant 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 ultérieurement. Cela devient essentiel lorsque certaines variables du code doivent rester constantes. Dans l’exemple suivant, la variable x est créée avec la valeur 5. Nous tentons ensuite d’intégrer cette variable en lui attribuant une nouvelle valeur. Le code correspondant 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 initialisées en leur attribuant une valeur. En principe, les variables doivent être initialisées en Java. Si vous déclarez une variable finale vide, vous pouvez néanmoins l’initialiser avec un constructeur 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’indication suivante :

Votre message se trouve ici.