Objektorientierter Java-Endmodifikator

1. Definition des endgültigen Modifikators:

Das Schlüsselwort final kann zum Ändern von Klassen, Variablen und Methoden verwendet werden

final Modifikation Wenn eine Variable verwendet wird, bedeutet dies, dass die Variable nicht mehr geändert werden kann, sobald sie den Anfangswert erhält (streng genommen: Eine durch final geänderte Variable kann nicht geändert werden. Sobald der Anfangswert erhalten wurde, kann der Wert der endgültigen Variablen nicht mehr neu zugewiesen werden )

final kann nicht nur Mitgliedsvariablen (Klassenvariablen und Instanzvariablen) ändern, sondern auch lokale Variablen und formale Parameter

Verwandte Video-Lerntutorials: Java-Online-Lernen

2. Die Syntax der endgültigen Mitgliedsvariablen legt fest:

Endgültig geänderte Mitgliedsvariablen müssen den Anfangswert explizit vom Programmierer angeben, und das System initialisiert die endgültigen Mitglieder nicht implizit.

1. Die Orte, an denen endgültig geänderte Klassenvariablen und Instanzvariablen Anfangswerte festlegen können, sind wie folgt:

Klassenvariablen: Der Anfangswert muss im statischen Initialisierungsblock angegeben werden bei der Deklaration der Klassenvariablen. Der Wert kann nur an einer von zwei Stellen angegeben werden.

Instanzvariablen: Der Anfangswert muss in einem nicht statischen Initialisierungsblock, in der Deklaration der Instanzvariablen oder angegeben werden in einem Konstruktor und kann nur an drei Stellen angegeben werden. Eine davon gibt

an. Hinweis: Wenn ein normaler Initialisierungsblock einen Anfangswert für eine Instanzvariable angegeben hat, können Sie keinen Anfangswert mehr angeben für die Instanzvariable im Konstruktor

Das folgende Programm demonstriert die Wirkung endgültig geänderter Mitgliedsvariablen:

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. Wenn Sie vorhaben, endgültige Mitgliedsvariablen im Konstruktor oder bei der Initialisierung zu initialisieren Block, greifen Sie vor der Initialisierung nicht auf den Wert der Mitgliedsvariablen zu.

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. Endgültige lokale Variablen

1. Definition: Das System initialisiert keine lokalen Variablen und lokale Variablen müssen explizit vom Programmierer initialisiert werden. Wenn Sie final zum Ändern lokaler Variablen verwenden, können Sie daher beim Definieren einen Standardwert angeben oder keinen Standardwert angeben.

Das folgende Programm demonstriert die endgültige Änderung lokaler Variablen und formaler Parameter:

(Der Fall endgültig geänderter formaler Parameter, denn wenn diese Methode aufgerufen wird, schließt das System die Initialisierung basierend auf ab Parameter übergeben. Daher können keine Werte mit dem endgültigen Modifikator zugewiesen werden.)

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. Der Unterschied zwischen endgültigen modifizierten Basistypvariablen und Referenztypvariablen

Referenztypvariablen, die die endgültige Änderung verwenden, können nicht neu zugewiesen werden, aber der Inhalt des Objekts, auf das die Referenztypvariable verweist, kann geändert werden

Zum Beispiel das Array-Objekt, auf das die iArr-Variable unten verweist, die iArr-Variable nach final Die Änderung kann nicht neu zugewiesen werden, aber das Array des von iArr Elements referenzierten Arrays kann geändert werden

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. Endgültige Variablen, die „Makroersetzung“ ausführen können

1. Für eine endgültige Variable, unabhängig davon, ob es sich um eine Klassenvariable oder eine Instanzvariable oder eine lokale Variable handelt, ist diese endgültige Variable keine Variable mehr, sondern entspricht einer direkten Größe, solange die Variable drei Bedingungen erfüllt.

(1) Verwenden Sie den Endmodifikator zum Ändern

(2) Geben Sie den Anfangswert an, wenn Sie die Endvariable definieren

(3) Der Anfangswert kann beim Kompilieren festgelegt werden Zeit bestimmt

2. Eine wichtige Verwendung des endgültigen Modifikators ist die Definition von „Makrovariablen“. Wenn eine endgültige Variable definiert ist, wird der Variablen ein Anfangswert zugewiesen, und die Variable kann bestimmt werden, ob es sich um eine Variable handelt. Dann ist diese endgültige Variable im Wesentlichen eine „Makrovariable“, und der Compiler löscht alle Variablen im Programm die diese Variable verwenden, direkt durch den Wert der Variablen ersetzen.

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

Für s3 wird der Wert durch Verketten von str1 und str2 erhalten. Da str1 und str2 nur zwei gewöhnliche Variablen sind, führt der Compiler das „Makro“ Ersetzen nicht aus. Daher kann der Compiler den Wert von s3 nicht ermitteln und s3 nicht auf „Crazy Java“ verweisen lassen, das im String-Pool zwischengespeichert ist.

Weitere Artikel und Tutorials zum Thema Java finden Sie unter: Java-Einführungs-Tutorial

Das obige ist der detaillierte Inhalt vonObjektorientierter Java-Endmodifikator. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!