Plongez dans Java Final

Dans cet article, l'éditeur présentera Java Final à tout le monde. Les amis dans le besoin peuvent s'y référer

Le mot-clé JAVA final est utilisé pour modifier des données, des méthodes ou des classes, ce qui signifie généralement "ne peut pas être modifié". " , 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 :

Constantes du temps de compilation

2. . Initialisation à l'exécution La valeur de

pour les constantes de compilation fait référence à un champ à la fois final et statique (selon la convention, les constantes de compilation sont toutes nommées avec des lettres majuscules et utilisent des traits de soulignement pour séparer chaque mot) , qui n'occupe qu'une section qui ne peut pas modifier l'espace de stockage. 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 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 ne peut pas être modifié. modifié (s'applique aux tableaux, qui sont également des objets).

Le code est le suivant :

public class javaFinalData{
    private static final String TESTD = "test";
    public static final String TESTE = "test";
    public static final String[] TESTF = {"1","2"}; //非基本类型
    private static final String[] TESTG = new String[2];
    public static void main(String args[]){
        final int testA = 1;
        final String testB = "test";
        final int[] testC = {1,1,2,};
        System.out.println(testC[1]);
        testC[1] = 123;
        System.out.println(testC[1]);
    }
}

[Champ final non attribué]

JAVA permet de générer des champs finaux non attribués, mais ils doivent être dans le champ Attribuez le champ final à la définition ou dans chaque constructeur (autant de constructeurs qu'il y en a), assurez-vous qu'il est 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.

Le code est le suivant :

public class javaBlankFinal{
    private final int blank;
    public javaBlankFinal(){
        blank = 2011;
    }
    public javaBlankFinal(int temp){
        blank = 2012;
    }
    public javaBlankFinal(String temp){
        blank = 2014;
    }
    public static void main(String args[]){
        new javaBlankFinal();
    }
}

[méthode finale]

Il y a deux raisons d'utiliser la méthode finale : l'une est de verrouiller la méthode pour éviter qu'il ne soit écrasé. Assurez-vous que le comportement de la méthode reste inchangé pendant l'héritage ; la seconde consiste à convertir les appels de méthode en appels inlining (inlining) pour réduire la surcharge des appels de méthode. 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é.

À propos de 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.

Utilisez l'annotation @Override pour éviter les problèmes ci-dessus. Comme indiqué dans le programme :

Le code est le suivant :

class finalFunction{
    private void finalFunctionA(){
        System.out.println("finalFunctionA");
    }

    private final void finalFunctionB(){
        System.out.println("finalFunctionB");
    }

    final void finalFunctionC(){
        System.out.println("finalFunctionC");
    }

    void functionD(){}
}
class overrideFinalFunction extends finalFunction{
    //@Override   添加@Override注解可以识别是否是override
    public void finalFunctionA(){               
        System.out.println("override finalFunctionA");
    }

    public final void finalFunctionB(){
        System.out.println("override finalFunctionB");
    }

    //final void finalFunctionC(){}   //Cannot override the final method from finalFunction

    @Override   
    void functionD(){} //真正的override方法
}
public class javaFinalFunction extends finalFunction{
    public static void main(String args[]){
        finalFunction ff = new finalFunction();
        //ff.finalFunctionA();  //无法调用private方法
        //ff.finalFunctionB();

        overrideFinalFunction off = new overrideFinalFunction();
        off.finalFunctionA();   //public方法
        off.finalFunctionB();
    }
}

[classe finale]

L'utilisation de la classe finale est généralement destinée au design raisons, pas Autoriser l'héritage de cette 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. La spécification de final pour la classe String empêche la substitution 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.

Le code est le suivant :

final class finalClass{
    int testA = 2011;
}
//class extendFinalClassextends finalClass{}  //can not extendthe final class finalClass
public class javaFinalClass{
    public static void main(String args[]){
       finalClass fc = new finalClass();
       System.out.println(fc.testA);
       fc.testA = 2012;
       System.out.println(fc.testA);
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!