En programmation, on peut parfois espérer que certaines données ne puissent pas être modifiées. C'est à ce moment-là que le final entre en jeu. Final est un mot-clé en Java, qui signifie « cette partie ne peut pas être modifiée ». Il y a deux raisons de ne pas vouloir changer : l’efficacité et le design. Il existe trois situations dans lesquelles final est utilisé : les données, les méthodes et les classes.

Données finales

Oui. La constance des données est très utile lorsqu'elle peut réduire la charge du système pendant l'exécution. Pour ces données constantes, je peux les appeler « constantes ». "Constante" est principalement utilisé aux deux endroits suivants :

2. Lors de l'initialisation pendant l'exécution, nous espérons qu'il ne sera pas modifié.

Pour les constantes de compilation, elles ont été initialisées pendant le processus de chargement de la classe, elles ne peuvent donc pas être modifiées une fois le chargement de la classe terminé. pendant la compilation Il est substitué dans toute formule de calcul qui l'utilise, ce qui signifie que la formule de calcul peut être exécutée au moment de la compilation. Bien entendu, pour les constantes de compilation, seuls les types de base peuvent être utilisés et ils doivent être initialisés lors de leur définition.

Certaines variables, nous voulons qu'elles se comportent différemment selon différents objets, mais en même temps nous ne voulons pas qu'elles soient modifiées pour le moment. nous pouvons utiliser la constante d'exécution. Pour les constantes d'exécution, il peut s'agir d'un type de données de base ou d'un type de données de référence. Ce qui est immuable dans un type de données de base est son contenu, tandis que ce qui est immuable dans un type de données de référence est sa référence, et le contenu de l'objet spécifié par la référence est modifiable.

public class Person {
    private String name;

    Person(String name){
        this.name = name;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class FinalTest {
    private final String final_01 = "chenssy";    //编译期常量，必须要进行初始化，且不可更改
    private final String final_02;                //构造器常量，在实例化一个对象时被初始化
    
    private static Random random = new Random();
    private final int final_03 = random.nextInt(50);    //使用随机数来进行初始化
    
    //引用
    public final Person final_04 = new Person("chen_ssy");    //final指向引用数据类型
    
    FinalTest(String final_02){
        this.final_02 = final_02;
    }
    
    public String toString(){
        return "final_01 = " + final_01 +"   final_02 = " + final_02 + "   final_03 = " + final_03 +
               "   final_04 = " + final_04.getName();
    }
    
    public static void main(String[] args) {
        System.out.println("------------第一次创建对象------------");
        FinalTest final1 = new FinalTest("cm");
        System.out.println(final1);
        System.out.println("------------第二次创建对象------------");
        FinalTest final2 = new FinalTest("zj");
        System.out.println(final2);
        System.out.println("------------修改引用对象--------------");
        final2.final_04.setName("chenssy");
        System.out.println(final2);
    }
}

------------------
Output:
------------第一次创建对象------------
final_01 = chenssy   final_02 = cm   final_03 = 34   final_04 = chen_ssy
------------第二次创建对象------------
final_01 = chenssy   final_02 = zj   final_03 = 46   final_04 = chen_ssy
------------修改引用对象--------------
final_01 = chenssy   final_02 = zj   final_03 = 46   final_04 = chenssy

Copier après la connexion

Le seul point expliqué ici est : ne pensez pas que si certaines données sont définitives, vous pouvez connaître leur valeur au moment de la compilation. Nous la connaissons via final_03. Ici, des nombres aléatoires sont utilisés pour l'initialisation, qui ne peut être que. connue au moment de l'exécution.

2. Méthode finale

Toutes les méthodes marquées comme finale ne peuvent pas être héritées ou modifiées, donc la première raison d'utilisation une dernière méthode est le verrouillage de méthode pour empêcher toute sous-classe de la modifier. Quant à la deuxième raison, c'est le problème d'efficacité. Je ne comprends pas très clairement ce problème d'efficacité. J'ai extrait ce passage d'Internet : Au début de l'implémentation de Java, si vous spécifiez une méthode comme finale, vous acceptez le compilateur. Tous les appels à cette méthode sont convertis en appels en ligne. Lorsque le compilateur trouve une commande d'appel de méthode finale, il utilisera son propre jugement pour ignorer la méthode d'appel normale consistant à insérer le code du programme et exécutera le mécanisme d'appel de méthode (pousser les paramètres sur la pile, passer au code de méthode pour l'exécution, puis Revenez en arrière et nettoyez les paramètres sur la pile, gérez la valeur de retour) et remplacez l'appel de méthode par une copie du code réel dans le corps de la méthode. Cela éliminera la surcharge des appels de méthode. Bien sûr, si une méthode est volumineuse, le code de votre programme sera gonflé et vous ne verrez peut-être pas les gains de performances liés à l'inline, car les gains de performances seront réduits par le temps passé dans la méthode.

Je ne comprends pas très bien ce passage, alors je l'ai copié. Cet expert Java peut l'expliquer ! !

La méthode finale de la classe parent ne peut pas être remplacée par la sous-classe, ce qui signifie que la sous-classe ne peut pas avoir la même méthode que la classe parent. .

public class Custom extends Person{
    public void method1(){
        System.out.println("Person&#39;s  method1....");
    }
    
//    Cannot override the final method from person：子类不能覆盖父类的final方法
//    public void method2(){
//        System.out.println("Person&#39;s method2...");
//    }
}

Copier après la connexion

3. Cours final

Si une classe est modifiée avec final, cela indique que la classe est la classe finale et qu'elle ne veut pas ou ne permet pas aux autres d'en hériter. En programmation, pour des raisons de sécurité ou pour d'autres raisons, nous n'autorisons aucune modification à cette classe, et nous ne voulons pas qu'elle ait de sous-classes. Pour le moment, nous pouvons utiliser final pour modifier la classe.

对于final修饰的类来说，它的成员变量可以为final，也可以为非final。如果定义为final，那么final数据的规则同样适合它。而它的方法则会自动的加上final，因为final类是无法被继承，所以这个是默认的。

四、 final参数

在实际应用中，我们除了可以用final修饰成员变量、成员方法、类，还可以修饰参数、若某个参数被final修饰了，则代表了该参数是不可改变的。

如果在方法中我们修改了该参数，则编译器会提示你：The final local variable i cannot be assigned. It must be blank and not using a compound assignment。

public class Custom {
    public void test(final int i){
      //i++;     ---final参数不可改变
        System.out.println(i);
    }
    
    public void test(final Person p){
     //p = new Person();    --final参数不可变
     p.setName("chenssy");
    }
}

Copier après la connexion

同final修饰参数在内部类中是非常有用的，在匿名内部类中，为了保持参数的一致性，若所在的方法的形参需要被内部类里面使用时，该形参必须为final。详情参看：//m.sbmmt.com/。