modificateur final orienté objet Java

1. Définition du modificateur final :

Le mot-clé final peut être utilisé pour modifier les classes, les variables et les méthodes

final modification Lorsqu'une variable est utilisée, cela signifie que la variable ne peut plus être modifiée une fois qu'elle a obtenu la valeur initiale (à proprement parler : une variable modifiée par final ne peut pas être modifiée. Une fois la valeur initiale obtenue, la valeur de la variable finale ne peut pas être réaffectée )

final peut modifier non seulement les variables membres (variables de classe et variables d'instance), mais également les variables locales et les paramètres formels

Tutoriels d'apprentissage vidéo associés : apprentissage en ligne Java

2. La syntaxe des variables membres finales stipule :

Les variables membres modifiées finales doivent spécifier explicitement la valeur initiale par le programmeur, et le système n'initialisera pas implicitement les membres finaux.

1. Les endroits où les variables de classe modifiées finales et les variables d'instance peuvent définir des valeurs initiales sont les suivantes :

Variables de classe : la valeur initiale doit être spécifiée dans le bloc d'initialisation statique ou lors de la déclaration de la variable de classe, et ne peut être spécifiée qu'à l'un des deux endroits

variables d'instance : la valeur initiale doit être spécifiée dans un bloc d'initialisation non statique, dans la déclaration de la variable d'instance, ou dans un constructeur, et ne peut être spécifié qu'à trois endroits L'un d'entre eux spécifie

Remarque : Si un bloc d'initialisation normal a spécifié une valeur initiale pour une variable d'instance, vous ne pouvez plus spécifier de valeur initiale pour la variable d'instance dans le constructeur

Le programme suivant démontre l'effet des variables membres finales modifiées :

package lextends;
public class FinalVariableTest {
    //定义成员变量时指定默认值，合法
    final int a = 6;
    //下面变量将在构造器或初始化块中分配初始值
    final String str;
    final int c;
    final static double d;

    //既没有指定默认值，又没有在初始化块、构造器中指定初始值
    //下面定义的ch实例是不合法的
    //final char ch;
    //初始化块，可对没有指定默认值的实例变量指定初始值
    {
        //在初始化块中为实例变量指定初始值，合法
        str = "Hello";
        //定义a实例变量时已经指定了默认值
        //不能为a重新赋值，因此下面赋值语句非法
        //a=9;
    }

    //静态初始化块，可对没有指定默认值的类变量指定初始值
    static {
        //在静态初始化块中为类变量指定初始值，合法
        d = 5.6;
    }

    //构造器，可以对既没有指定默认值，又没有在初始化块中，指定初始值的实例变量指定初始值
    public FinalVariableTest() {
        //如果在初始化块中已经对str指定了初始值
        //那么在构造器中不能对final变量重新赋值，下面赋值语句非法
        //str="java"
        c = 5;
    }

    public void changeFinal() {
        //普通方法不能为final修饰的成员变量赋值
        //d=1.2
        //不能在普通方法中为final成员变量指定初始值
        //ch = 'a';
    }
public static void mian(String[] args){
    FinalVariableTest ft= new FinalVariableTest();
    System.out.println(ft.a);
    System.out.println(ft.c);
    System.out.println(ft.d);}
}

2. Si vous prévoyez d'initialiser les variables membres finales dans le constructeur ou l'initialisation bloc, n’accédez pas à la valeur de la variable membre avant l’initialisation.

package lextends;
public class FinalErrorTest {
    //定义一个final修饰的实例变量
    //系统不会对final成员变量进行默认初始化
    final int age;
    {
        //age没有初始化，所以此处代码将引起错误，因为它试图访问一个未初始化的变量
        //只要把定义age时的final修饰符去掉，程序就正确了
        System.out.println(age);
        
        age=6;
        System.out.println(age);
    }
    public static void main(String[] args){
        new FinalErrorTest();
    }
}

3. Variables locales finales

Définition : Le système n'initialisera pas les variables locales et les variables locales doivent être explicitement initialisées par le programmeur. Par conséquent, lorsque vous utilisez final pour modifier des variables locales, vous pouvez spécifier une valeur par défaut lors de sa définition, ou vous ne pouvez pas spécifier de valeur par défaut.

Le programme suivant démontre la modification finale des variables locales et des paramètres formels :

(Le cas des paramètres formels finaux modifiés, car lorsque cette méthode est appelée, le système termine l'initialisation en fonction du paramètres transmis. Par conséquent, les valeurs ne peuvent pas être attribuées à l'aide du modificateur final.)

package lextends;
public class FinalLocalVariable {
    public void test(final int a){
        //不能对final修饰的形参赋值，下面语句非法
        //a=5;
    }
    public static void mian(String[] args){
        //定义final局部变量时指定默认值，则str变量无法重新赋值
        final String str="hello";
        //下面赋值语句非法
        //str="Java";
        
        //定义final局部变量时没有指定默认值，则d变量可被赋值一次
        final double d;
        d=5.6;
        //对final变量重新赋值，下面语句非法
        //d=6.4;
    }
}

4. La différence entre les variables de type de base modifiées finales et les variables de type de référence

Les variables de type référence utilisant la modification finale ne peuvent pas être réaffectées, mais le contenu de l'objet référencé par la variable de type référence peut être modifié

Par exemple, l'objet tableau référencé par la variable iArr ci-dessous, la variable iArr après la modification finale La modification ne peut pas être réaffectée, mais le tableau du tableau référencé par iArr Elements peut être modifié

eg.
//final修饰数组元素，iArr是一个引用变量
final int[] iArr={5,6,12,9};
System.out.println(Arrays.toString(iArr));
//对数组元素进行排序，合法
Arrays.sort(iArr);
System.out.println(Arrays.toString(iArr));
//对数组进行元素赋值，合法
iArr[2]=-8;
System.out.println(Arrays.toString(iArr));
//下面语句对iArr重新赋值，非法
//iArr=null；

5. Variables finales pouvant exécuter un "remplacement de macro"

1. Pour une variable finale, qu'il s'agisse d'une variable de classe ou d'instance, ou d'une variable locale, tant que la variable remplit trois conditions, cette variable finale n'est plus une variable, mais équivalente à une quantité directe.

(1) Utilisez le modificateur final pour modifier

(2) Spécifiez la valeur initiale lors de la définition de la variable finale

(3) La valeur initiale peut être définie à la compilation temps déterminé

2. Une utilisation importante du modificateur final est de définir des "variables macro". Lorsqu'une variable finale est définie, une valeur initiale est attribuée à la variable, et la variable peut être déterminée lorsqu'il s'agit d'une variable. Ensuite, cette variable finale est essentiellement une "variable macro", et le compilateur supprimera toutes les variables du programme. qui utilisent cette variable place directement remplacée par la valeur de la variable.

3.

eg.
String s1="疯狂Java";
//s2变量引用的字符串可以在编译时就确定下来
//因此s2直接引用变量池中已有的"疯狂Java"字符串
String s2="疯狂"+"Java";
System.out.println(s1==s2);//true

//定义两个字符串直接量
String str1="疯狂";
String str2="Java";
String s3=str1+str2;
System.out.println(s1==s3);//false

Pour s3, sa valeur est obtenue en concaténant str1 et str2 puisque str1 et str2 ne sont que deux variables ordinaires, le compilateur n'exécutera pas la "macro" Remplacer ", le compilateur ne peut donc pas déterminer la valeur de s3 et ne peut pas faire pointer s3 vers "Crazy Java" mis en cache dans le pool de chaînes.

Pour plus d'articles et de didacticiels sur Java, vous pouvez visiter : Tutoriel d'introduction à Java

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!