Il existe de nombreuses utilisations de la variable final. En voici quelques-uns
Constantes finales
public static class CircleToolsBetter {
public final static double PI = 3.141;
public double getCircleArea(final double radius) {
return (Math.pow(radius, 2) * PI);
}
}
Cela peut être utilisé pour d'autres parties de vos codes, ou accédé par d'autres classes, de cette façon si jamais vous changiez la valeur, vous n'auriez pas à les changer une par une.
Variables finales
public static String someMethod(final String environmentKey) {
final String key = "env." + environmentKey;
System.out.println("Key is: " + key);
return (System.getProperty(key));
}
}
Dans cette classe, vous créez une variable finale de portée qui ajoute un préfixe au paramètre environmentKey. Dans ce cas, la variable finale n'est finale que dans le périmètre d'exécution, qui est différent à chaque exécution de la méthode. Chaque fois que la méthode est entrée, la finale est reconstruite. Dès qu'il est construit, il ne peut pas être modifié pendant la portée de l'exécution de la méthode. Cela vous permet de fixer une variable dans une méthode pour la durée de la méthode. voir ci-dessous:
public class FinalVariables {
public final static void main(final String[] args) {
System.out.println("Note how the key variable is changed.");
someMethod("JAVA_HOME");
someMethod("ANT_HOME");
}
}
Constantes finales
public double equation2Better(final double inputValue) {
final double K = 1.414;
final double X = 45.0;
double result = (((Math.pow(inputValue, 3.0d) * K) + X) * M);
double powInputValue = 0;
if (result > 360) {
powInputValue = X * Math.sin(result);
} else {
inputValue = K * Math.sin(result); // <= Compiler error
}
Ceux-ci sont particulièrement utiles lorsque vous avez de très longues lignes de codes, et cela générera une erreur du compilateur afin que vous ne vous heurtiez pas à une erreur logique / commerciale lorsque quelqu'un change accidentellement des variables qui ne devraient pas être modifiées.
Collections finales
Cas différent lorsque nous parlons de collections, vous devez les définir comme non modifiables.
public final static Set VALID_COLORS;
static {
Set temp = new HashSet( );
temp.add(Color.red);
temp.add(Color.orange);
temp.add(Color.yellow);
temp.add(Color.green);
temp.add(Color.blue);
temp.add(Color.decode("#4B0082")); // indigo
temp.add(Color.decode("#8A2BE2")); // violet
VALID_COLORS = Collections.unmodifiableSet(temp);
}
sinon, si vous ne le définissez pas comme non modifiable:
Set colors = Rainbow.VALID_COLORS;
colors.add(Color.black); // <= logic error but allowed by compiler
Les classes finales et les méthodes finales ne peuvent pas être étendues ou écrasées respectivement.
MODIFIER: POUR RÉPONDRE AU PROBLÈME DE CLASSE FINALE CONCERNANT L'ENCAPSULATION:
Il y a deux façons de rendre une classe finale. La première consiste à utiliser le mot-clé final dans la déclaration de classe:
public final class SomeClass {
// . . . Class contents
}
La deuxième façon de rendre une classe finale est de déclarer tous ses constructeurs comme privés:
public class SomeClass {
public final static SOME_INSTANCE = new SomeClass(5);
private SomeClass(final int value) {
}
Le marquer comme final vous évite les ennuis si vous découvrez qu'il s'agit réellement d'une finale, pour démontrer regardez cette classe de test. regarde public à première vue.
public class Test{
private Test(Class beanClass, Class stopClass, int flags)
throws Exception{
// . . . snip . . .
}
}
Malheureusement, comme le seul constructeur de la classe est privé, il est impossible d'étendre cette classe. Dans le cas de la classe Test, il n'y a aucune raison que la classe soit définitive. La classe Test est un bon exemple de la façon dont les classes finales implicites peuvent causer des problèmes.
Vous devez donc le marquer comme final lorsque vous rendez implicitement une classe finale en rendant son constructeur privé.