Analyse finale approfondie et globale

Java a un mot-clé final, une variable peut être déclarée comme type final et une variable de type final ne peut être attribuée qu'une seule fois. Si une variable finale reçoit une valeur à plusieurs reprises, une erreur de compilation se produira.

Quelle est la signification du mot-clé final ?

final est un mot-clé réservé en Java qui peut déclarer des variables membres, des méthodes, des classes et des variables locales. Une fois que vous avez déclaré une référence finale, vous ne pouvez pas modifier la référence. Le compilateur vérifiera le code et signalera une erreur de compilation si vous essayez d'initialiser à nouveau la variable.

Qu'est-ce qu'une variable finale ?

Toutes les variables membres ou variables locales (les variables dans les méthodes ou les blocs de code sont appelées variables locales) qui sont déclarées finales sont appelées variables finales. Les variables finales sont souvent utilisées avec le mot-clé static comme constantes. Voici un exemple de variable finale :

public static final String LOAN = "loan";

LOAN = new String("loan") //erreur de compilation invalide

les variables finales sont en lecture seule.

Qu'est-ce qu'une méthode finale ?

Final peut également déclarer des méthodes. Ajouter le mot-clé final devant une méthode signifie que cette méthode ne peut pas être remplacée par les méthodes des sous-classes. Si vous pensez que la fonction d'une méthode est suffisamment complète et n'a pas besoin d'être modifiée dans les sous-classes, vous pouvez déclarer la méthode comme finale. Les méthodes finales sont plus rapides que les méthodes non finales car elles sont liées statiquement au moment de la compilation et n'ont pas besoin d'être liées dynamiquement au moment de l'exécution. Voici un exemple de méthode finale :

class PersonalLoan{
    public final String getName(){
        return "personal loan";
    }
}
 
class CheapPersonalLoan extends PersonalLoan{
    @Override
    public final String getName(){
        return "cheap personal loan"; //compilation error: overridden method is final
    }
}

Qu'est-ce qu'un cours final ?

Une classe modifiée avec final est appelée une classe finale. Les classes finales sont généralement fonctionnellement complètes et ne peuvent pas être héritées. Il existe de nombreuses classes en Java qui sont finales, telles que String, Interger et d'autres classes wrapper. Voici un exemple de la classe finale :

final class PersonalLoan{
 
    }
 
    class CheapPersonalLoan extends PersonalLoan{  //compilation error: cannot inherit from final class
 
}

Avantages du mot-clé final

Ce qui suit résume quelques utilisations Avantages du mot-clé final

Le mot-clé final améliore les performances. Les applications JVM et Java mettent en cache les variables finales.

Les variables finales peuvent être partagées en toute sécurité dans un environnement multithread sans surcharge de synchronisation supplémentaire.

En utilisant le mot-clé final, la JVM optimisera les méthodes, les variables et les classes.

Effectivement Final

Une variable sera considérée comme effectivement finale si et seulement si :

Non déclarée comme finale

2 .La valeur. n'est attribué qu'une seule fois

La façon la plus simple d'expliquer efficacement final est d'imaginer qu'il est modifié avec final S'il est modifié de cette manière, le programme s'exécutera toujours sans erreur (si la compilation. passe) ^0^), et est cohérent avec le résultat d'exécution d'origine, alors cette variable peut être considérée comme effectivement finale.

Avantages de final

La restriction des variables locales à des variables immuables valides est conçue pour permettre aux développeurs de mieux gérer la concurrence et le développement thread-safe. Les champs mutables sont toujours une source potentielle de problèmes de concurrence s'ils ne sont pas gérés correctement.

Utilisation du mot-clé final

Je pense que c'est une bonne habitude de déclarer les variables, les paramètres de méthode, etc. comme final. Cela peut être un bon rappel aux autres membres de l'équipe de ne pas le modifier à la légère. Mettez cela de côté, déclarez-le comme final, et le compilateur l'optimisera bien lors de sa compilation dans un fichier de classe.

Il existe de nombreux arguments contre "il est incorrect d'utiliser le mot-clé final dans les fichiers sources pour obtenir l'optimisation des fichiers de classe". Il est fortement recommandé de lire "Hardcore Java 》 Détails sur l'utilisation et l'optimisation des mots-clés finaux.

Dans une application, le mot-clé final rend l'intention de votre code évidente, et il ne sera pas modifié après la déclaration, ce qui est très sûr.

public class FinalTest {

    public static final int N_ITERATIONS = 10_00_000;

    public static String testFinal() {
        final String a = "a";
        final String b = "b";
        return a + b;
    }

    public static String testNonFinal() {
        String a = "a";
        String b = "b";
        return a + b;
    }

    public static void main(String[] args) {
        long tStart, tElapsed;

        tStart = System.currentTimeMillis();
        for (int i = 0; i < N_ITERATIONS; i++)
            testFinal();
        tElapsed = System.currentTimeMillis() - tStart;
        System.out.println("Method with finals took " + tElapsed + " ms");

        tStart = System.currentTimeMillis();
        for (int i = 0; i < N_ITERATIONS; i++)
            testNonFinal();
        tElapsed = System.currentTimeMillis() - tStart;
        System.out.println("Method without finals took " + tElapsed + " ms");

    }

}

Résultats en cours d'exécution :

Method with finals took 5 ms
Method without finals took 273 ms