Le mot clé JAVA final est utilisé pour modifier des données, des méthodes ou des classes, ce qui signifie généralement « immuable », c'est-à-dire que les données ne peuvent pas être modifiées, les méthodes ne peuvent pas être remplacées et les classes ne peuvent pas être héritées. Il y a généralement deux raisons d’utiliser final : le design et l’efficacité. À mesure que la version JAVA est mise à jour, certains problèmes d'efficacité peuvent être résolus par le compilateur et la JVM. Par conséquent, utiliser final pour résoudre des problèmes d’efficacité n’est pas si important.
Le modificateur Final est principalement utilisé dans les champs de types de données primitifs ou de classes immuables (si toutes les méthodes de la classe ne changent pas son objet, cette classe est une classe immuable. String est une classe immuable).
【données finales】
Il existe deux situations principales dans lesquelles le mot-clé Final est utilisé pour modifier des données :
1. Constantes de temps de compilation
2. Valeurs initialisées au moment de l'exécution
Pour les constantes de compilation, il fait référence à un champ à la fois final et statique (selon la convention, les constantes de compilation sont nommées avec des lettres majuscules et chaque mot est séparé par un trait de soulignement. Il n'occupe qu'un espace de stockage). ne peut pas être modifié. Le compilateur peut substituer des constantes de compilation dans n'importe quelle formule de calcul susceptible de l'utiliser. Autrement dit, la formule de calcul peut être exécutée au moment de la compilation, ce qui réduit relativement la charge d'exécution. Une constante de compilation doit avoir une valeur qui lui est attribuée lors de sa définition (pas nécessairement un type de base).
Pour les valeurs initialisées au moment de l'exécution, pour les types de base, final rend la valeur immuable ; pour les références d'objet, final rend la référence immuable, c'est-à-dire qu'elle ne peut pas être modifiée pour pointer vers un autre objet. Cependant, l'objet lui-même peut être modifié (. applicable aux tableaux, les tableaux sont aussi des objets).
chaîne finale statique privée TESTD = "test";
public static final String TESTE = "test";
public static final String[] TESTF = {"1", "2"} ; //Type non basique
chaîne finale statique privée[] TESTG = new String[2];
public static void main(String args[]){
final int testA = 1 ;
chaîne finale testB = "test" ;
final int[] testC = {1,1,2,} ;
System.out.println(testC[1]);
testC[1] = 123 ;
System.out.println(testC[1]);
}
}
JAVA permet la génération de champs finaux non attribués, mais le champ final doit être attribué lors de la définition du champ ou dans chaque constructeur (autant de constructeurs qu'il y en a) pour garantir qu'il soit initialisé avant utilisation. De cette manière, final peut être utilisé de manière plus flexible. Dans une même classe, différentes valeurs peuvent être attribuées à différents objets tout en conservant des caractéristiques immuables.
public javaBlankFinal(){
vide = 2011 ;
}
public javaBlankFinal(int temp){
vide = 2012 ;
}
public javaBlankFinal(String temp){
vide = 2014 ;
}
public static void main(String args[]){
new javaBlankFinal();
}
}
Il y a deux raisons d'utiliser la méthode finale : l'une est de verrouiller la méthode pour empêcher son écrasement et garantir que le comportement de la méthode reste inchangé pendant l'héritage ; l'autre est de convertir les appels de méthode en appels en ligne pour réduire le coût de la méthode ; appels. Cependant, dans les versions récentes, la JVM peut s'optimiser elle-même, il n'est donc pas nécessaire d'utiliser des méthodes finales pour résoudre les problèmes d'efficacité.
Concernant la méthode finale, il y a autre chose à noter. Toutes les méthodes privées de la classe sont implicitement désignées comme méthodes finales (vous pouvez également leur ajouter une modification finale, mais cela n'a aucun sens). Lorsque vous essayez de remplacer une méthode privée, le compilateur ne signale pas d'erreur, mais en fait, vous n'écrasez pas la méthode, vous générez simplement une nouvelle méthode. Étant donné que les classes externes ne peuvent pas accéder à la méthode privée, elle ne peut bien sûr pas être remplacée.
L'utilisation de l'annotation @Override peut éviter les problèmes ci-dessus. Comme indiqué dans le programme :
privé final void finalFunctionB(){
System.out.println("finalFunctionB");
}
final void finalFunctionC(){
System.out.println("finalFunctionC");
}
fonction videD(){}
}
la classe overrideFinalFunction étend finalFunction{
//@Override Ajoutez l'annotation @Override pour identifier s'il s'agit d'un remplacement
public void finalFunctionA(){
System.out.println("override finalFunctionA");
}
public final void finalFunctionB(){
System.out.println("remplacer finalFunctionB");
}
//final void finalFunctionC(){} //Impossible de remplacer la méthode finale de finalFunction
@Outrepasser
void functionD(){} //Méthode de remplacement réelle
}
la classe publique javaFinalFunction étend finalFunction{
public static void main(String args[]){
finalFunction ff = new finalFunction();
//ff.finalFunctionA(); //Impossible d'appeler une méthode privée
//ff.finalFunctionB();
overrideFinalFunction off = new overrideFinalFunction();
off.finalFunctionA(); //méthode publique
off.finalFunctionB();
}
}
L'utilisation des classes finales est généralement motivée par des raisons de conception, qui ne permettent pas d'hériter de la classe. Cela garantit que le comportement de la classe ne changera pas et peut également éviter certains risques de sécurité. Toutes les méthodes de la classe Final sont implicitement désignées comme méthodes finales et ne peuvent donc pas être remplacées (la classe finale interdisant l'héritage, les méthodes de sa classe ne peuvent pas être remplacées). Dans l'API principale Java, il existe de nombreux exemples d'application de final, tels que java.lang.String. Spécifiez final pour la classe String afin d'éviter l'écrasement de méthodes telles que length().
Pour les champs finaux, même si une classe est déclarée finale, les champs de la classe ne deviendront pas automatiquement des champs finaux.
classe publique javaFinalClass{
public static void main(String args[]){
finalClass fc = new finalClass();
System.out.println(fc.testA);
fc.testA = 2012 ;
System.out.println(fc.testA);
}
}