In Java kann final zum ?ndern von Klassen, Methoden und Variablen verwendet werden. Die endgültige ?nderung der Klasse bedeutet, dass die Klasse von keiner anderen Klasse geerbt werden kann. Dies bedeutet, dass diese Klasse eine Blattklasse in einem Vererbungsbaum ist und das Design dieser Klasse als perfekt angesehen wurde und nicht ge?ndert oder erweitert werden muss. Die Methode in der endgültigen ge?nderten Klasse bedeutet, dass die Klasse von keiner anderen Klasse geerbt und nicht überschrieben werden kann. Das hei?t, die Methode ist gesperrt, um zu verhindern, dass die geerbte Klasse sie ?ndert. final ?ndert eine Variable in einer Klasse und gibt an, dass die Variable nach der Initialisierung nicht mehr ge?ndert werden kann.

Die Betriebsumgebung dieses Tutorials: Windows7-System, Java8-Version, DELL G3-Computer.

Was ist das letzte Schlüsselwort?

1. Final kann zum ?ndern von Strukturen verwendet werden: Klassen, Methoden, Variablen

2. Final wird zum ?ndern einer Klasse verwendet: Diese Klasse kann nicht von anderen Klassen geerbt werden.

Wenn wir verhindern müssen, dass eine Klasse vererbt wird, k?nnen wir die endgültige ?nderung verwenden. Bitte beachten Sie jedoch: Alle Mitgliedsmethoden in der endgültigen Klasse werden implizit als endgültige Methoden definiert.

Zum Beispiel: String-Klasse, Systemklasse, StringBuffer-Klasse

3. final wird zum ?ndern der Methode verwendet: Zeigt an, dass diese Methode nicht überschrieben werden kann

• Funktion

  (1) Sperren Sie die Methode, um zu verhindern, dass geerbte Klassen verwendet werden ?ndern Sie es. Nehmen Sie ?nderungen vor.

  (2) Effizienz: In frühen Java-Versionen werden endgültige Methoden in Inline-Aufrufe umgewandelt. Wenn die Methode jedoch zu gro? ist, wird die Leistung m?glicherweise nicht wesentlich verbessert. Daher werden in neueren Versionen für diese Optimierungen keine endgültigen Methoden mehr ben?tigt.

  Die endgültige Methode bedeutet ?endgültig, endgültig“, dh diese Methode kann nicht überschrieben werden.

• Zum Beispiel: getClass( ) in der Object-Klasse

4. Zu diesem Zeitpunkt sind Variablen ?quivalent zu Konstanten.

• final wird zum ?ndern von Attributen verwendet Positionen, die für die Zuweisung in Betracht gezogen werden k?nnen, sind: Explizite Initialisierung, Initialisierung in Codebl?cken, Initialisierung in Konstruktoren

• final modifizierte lokale Variablen: Insbesondere wenn final zum ?ndern des formalen Parameters verwendet wird, zeigt dies an, dass der formale Parameter eine Konstante ist . Wenn wir diese Methode aufrufen, weisen wir dem konstanten Parameter einen tats?chlichen Parameter zu. Nach der Zuweisung kann der Wert dieses Parameters nur im Methodenk?rper verwendet und nicht erneut zugewiesen werden.

• Wenn final einen Referenztyp ?ndert, kann es nach der Initialisierung nicht mehr auf andere Objekte verweisen oder seine Adresse kann sich nicht ?ndern (da der Wert der Referenz eine Adresse ist und final einen Wert erfordert, d. h. Der Wert von die Adresse ?ndert sich nicht), aber der Inhalt des Objekts, auf das die Referenz zeigt, kann sich ?ndern. Im Wesentlichen das Gleiche.

5. Wenn Sie das Schlüsselwort final zum Deklarieren von Klassen, Variablen und Methoden verwenden, müssen Sie die folgenden Punkte beachten:

• final wird vor einer Variablen verwendet, um anzugeben, dass der Wert der Die Variable kann zu diesem Zeitpunkt nicht ge?ndert werden und kann als Konstante bezeichnet werden.

• final wird vor einer Methode verwendet, um anzuzeigen, dass die Methode nicht überschrieben werden kann (wenn in der Unterklasse eine Methode mit demselben Namen, demselben Rückgabewerttyp und derselben Parameterliste wie in der übergeordneten Klasse erstellt wird). Nur die Implementierung im Methodenk?rper unterscheidet sich. Um andere Funktionen als die der übergeordneten Klasse zu erreichen, wird diese Methode als Methodenüberschreibung oder Methodenüberschreibung bezeichnet. Sie k?nnen es hier verstehen, wir werden es sp?ter im Detail erkl?ren Tutorial).

• final wird vor einer Klasse verwendet, um anzugeben, dass die Klasse keine Unterklassen haben kann, dh die Klasse kann nicht vererbt werden.

endgültig ge?nderte Variablen

Die durch final ge?nderten Variablen werden zu Konstanten und k?nnen nur einmal zugewiesen werden, aber die durch final ge?nderten lokalen Variablen und Mitgliedsvariablen sind unterschiedlich.

• Endgültig ge?nderten lokalen Variablen muss ein Wert zugewiesen werden, bevor sie verwendet werden k?nnen.

• Endgültige ge?nderte Mitgliedsvariablen, denen bei der Deklaration kein Wert zugewiesen wird, werden als ?leere endgültige Variablen“ bezeichnet. Leere Endvariablen müssen in einem Konstruktor oder statischen Codeblock initialisiert werden.

Hinweis: Es ist falsch zu sagen, dass endgültig ge?nderte Variablen nicht ge?ndert werden k?nnen. Sobald der Anfangswert erhalten ist, kann der Wert der endgültigen Variablen nicht neu zugewiesen werden.

public class FinalDemo {
    void doSomething() {
        // 沒(méi)有在聲明的同時(shí)賦值
        final int e;
        // 只能賦值一次
        e = 100;
        System.out.print(e);
        // 聲明的同時(shí)賦值
        final int f = 200;
    }
    // 實(shí)例常量
    final int a = 5; // 直接賦值
    final int b; // 空白final變量
    // 靜態(tài)常量
    final static int c = 12;// 直接賦值
    final static int d; // 空白final變量
    // 靜態(tài)代碼塊
    static {
        // 初始化靜態(tài)變量
        d = 32;
    }
    // 構(gòu)造方法
    FinalDemo() {
        // 初始化實(shí)例變量
        b = 3;
        // 第二次賦值，會(huì)發(fā)生編譯錯(cuò)誤
        // b = 4;
    }
}

Die Zeilen 4 und 6 des obigen Codes deklarieren nur, dass es keine Zuweisung gibt, sie müssen jedoch vor der Verwendung zugewiesen werden (siehe Zeile 6 des Codes). Konstanten gleichzeitig mit der Deklaration. Die Zeilen 13, 14, 16 und 17 des Codes deklarieren alle Mitgliedskonstanten. Die Zeilen 13 und 14 des Codes sind Instanzkonstanten. Wenn es sich um eine leere Endvariable handelt (siehe Zeile 14 des Codes), muss sie im Konstruktor initialisiert werden (siehe Zeile 27 des Codes). Die Zeilen 16 und 17 des Codes sind statische Konstanten. Wenn es sich um eine leere Endvariable handelt (siehe Zeile 17 des Codes), muss sie in einem statischen Codeblock initialisiert werden (siehe Zeile 21 des Codes).

Unabh?ngig davon, welche Art von Konstante nur einmal zugewiesen werden kann, lesen Sie Zeile 29 des Codes, um der b-Konstante einen Wert zuzuweisen, da b bereits einmal zugewiesen wurde, sodass hier ein Kompilierungsfehler auftritt.

final ?ndert den Unterschied zwischen Basistypvariablen und Referenztypvariablen

當(dāng)使用 final 修飾基本類型變量時(shí)，不能對(duì)基本類型變量重新賦值，因此基本類型變量不能被改變。 但對(duì)于引用類型變量而言，它保存的僅僅是一個(gè)引用，final 只保證這個(gè)引用類型變量所引用的地址不會(huì)改變，即一直引用同一個(gè)對(duì)象，但這個(gè)對(duì)象完全可以發(fā)生改變。

下面程序示范了 final 修飾數(shù)組和 Person 對(duì)象的情形。

import java.util.Arrays;
class Person {
    private int age;
    public Person() {
    }
    // 有參數(shù)的構(gòu)造器
    public Person(int age) {
        this.age = age;
    }
    // 省略age的setter和getter方法
    // age 的 setter 和 getter 方法
}
public class FinalReferenceTest {
    public static void main(String[] args) {
        // final修飾數(shù)組變量，iArr是一個(gè)引用變量
        final int[] iArr = { 5, 6, 12, 9 };
        System.out.println(Arrays.toString(iArr));
        // 對(duì)數(shù)組元素進(jìn)行排序，合法
        Arrays.sort(iArr);
        System.out.println(Arrays.toString(iArr));
        // 對(duì)數(shù)組元素賦值，合法
        iArr[2] = -8;
        System.out.println(Arrays.toString(iArr));
        // 下面語(yǔ)句對(duì)iArr重新賦值,非法
        // iArr = null;
        // final修飾Person變量，p是一個(gè)引用變量
        final Person p = new Person(45);
        // 改變Person對(duì)象的age實(shí)例變量，合法
        p.setAge(23);
        System.out.println(p.getAge());
        // 下面語(yǔ)句對(duì)P重新賦值，非法
        // p = null;
    }
}

從上面程序中可以看出，使用 final 修飾的引用類型變量不能被重新賦值，但可以改變引用類型變量所引用對(duì)象的內(nèi)容。例如上面 iArr 變量所引用的數(shù)組對(duì)象，final 修飾后的 iArr 變量不能被重新賦值，但 iArr 所引用數(shù)組的數(shù)組元素可以被改變。與此類似的是，p 變量也使用了 final 修飾，表明 p 變量不能被重新賦值，但 p 變量所引用 Person 對(duì)象的成員變量的值可以被改變。

注意：在使用 final 聲明變量時(shí)，要求全部的字母大寫(xiě)，如 SEX，這點(diǎn)在開(kāi)發(fā)中是非常重要的。

如果一個(gè)程序中的變量使用 public static final 聲明，則此變量將稱為全局變量，如下面的代碼：

public static final String SEX= "女";

final修飾方法

final 修飾的方法不可被重寫(xiě)，如果出于某些原因，不希望子類重寫(xiě)父類的某個(gè)方法，則可以使用 final 修飾該方法。

Java 提供的 Object 類里就有一個(gè) final 方法 getClass()，因?yàn)?Java 不希望任何類重寫(xiě)這個(gè)方法，所以使用 final 把這個(gè)方法密封起來(lái)。但對(duì)于該類提供的 toString() 和 equals() 方法，都允許子類重寫(xiě)，因此沒(méi)有使用 final 修飾它們。

下面程序試圖重寫(xiě) final 方法，將會(huì)引發(fā)編譯錯(cuò)誤。

public class FinalMethodTest {
    public final void test() {
    }
}
class Sub extends FinalMethodTest {
    // 下面方法定義將出現(xiàn)編譯錯(cuò)誤，不能重寫(xiě)final方法
    public void test() {
    }
}

上面程序中父類是 FinalMethodTest，該類里定義的 test() 方法是一個(gè) final 方法，如果其子類試圖重寫(xiě)該方法，將會(huì)引發(fā)編譯錯(cuò)誤。

對(duì)于一個(gè) private 方法，因?yàn)樗鼉H在當(dāng)前類中可見(jiàn)，其子類無(wú)法訪問(wèn)該方法，所以子類無(wú)法重寫(xiě)該方法——如果子類中定義一個(gè)與父類 private 方法有相同方法名、相同形參列表、相同返回值類型的方法，也不是方法重寫(xiě)，只是重新定義了一個(gè)新方法。因此，即使使用 final 修飾一個(gè) private 訪問(wèn)權(quán)限的方法，依然可以在其子類中定義與該方法具有相同方法名、相同形參列表、相同返回值類型的方法。

下面程序示范了如何在子類中“重寫(xiě)”父類的 private final 方法。

public class PrivateFinalMethodTest {
    private final void test() {
    }
}
class Sub extends PrivateFinalMethodTest {
    // 下面的方法定義不會(huì)出現(xiàn)問(wèn)題
    public void test() {
    }
}

上面程序沒(méi)有任何問(wèn)題，雖然子類和父類同樣包含了同名的 void test() 方法，但子類并不是重寫(xiě)父類的方法，因此即使父類的 void test() 方法使用了 final 修飾，子類中依然可以定義 void test() 方法。

final 修飾的方法僅僅是不能被重寫(xiě)，并不是不能被重載，因此下面程序完全沒(méi)有問(wèn)題。

public class FinalOverload {
    // final 修飾的方法只是不能被重寫(xiě)，完全可以被重載
    public final void test(){}
    public final void test(String arg){}
}

final修飾類

final 修飾的類不能被繼承。當(dāng)子類繼承父類時(shí)，將可以訪問(wèn)到父類內(nèi)部數(shù)據(jù)，并可通過(guò)重寫(xiě)父類方法來(lái)改變父類方法的實(shí)現(xiàn)細(xì)節(jié)，這可能導(dǎo)致一些不安全的因素。為了保證某個(gè)類不可被繼承，則可以使用 final 修飾這個(gè)類。

下面代碼示范了 final 修飾的類不可被繼承。

final class SuperClass {
}
class SubClass extends SuperClass {    //編譯錯(cuò)誤
}

因?yàn)?SuperClass 類是一個(gè) final 類，而 SubClass 試圖繼承 SuperClass 類，這將會(huì)引起編譯錯(cuò)誤。

final 修飾符使用總結(jié)

1. final 修飾類中的變量

表示該變量一旦被初始化便不可改變，這里不可改變的意思對(duì)基本類型變量來(lái)說(shuō)是其值不可變，而對(duì)對(duì)象引用類型變量來(lái)說(shuō)其引用不可再變。其初始化可以在兩個(gè)地方：一是其定義處，也就是說(shuō)在 final 變量定義時(shí)直接給其賦值；二是在構(gòu)造方法中。這兩個(gè)地方只能選其一，要么在定義時(shí)給值，要么在構(gòu)造方法中給值，不能同時(shí)既在定義時(shí)賦值，又在構(gòu)造方法中賦予另外的值。

2. final 修飾類中的方法

說(shuō)明這種方法提供的功能已經(jīng)滿足當(dāng)前要求，不需要進(jìn)行擴(kuò)展，并且也不允許任何從此類繼承的類來(lái)重寫(xiě)這種方法，但是繼承仍然可以繼承這個(gè)方法，也就是說(shuō)可以直接使用。在聲明類中，一個(gè) final 方法只被實(shí)現(xiàn)一次。

3. final 修飾類

表示該類是無(wú)法被任何其他類繼承的，意味著此類在一個(gè)繼承樹(shù)中是一個(gè)葉子類，并且此類的設(shè)計(jì)已被認(rèn)為很完美而不需要進(jìn)行修改或擴(kuò)展。

Für Mitglieder in Abschlussklassen k?nnen Sie diese als Abschlussklassen definieren oder nicht. Was Methoden betrifft, so werden sie natürlich endgültig, da die Klasse, zu der sie geh?ren, endgültig ist. Sie k?nnen der endgültigen Klasse auch explizit eine endgültige Methode hinzufügen, was offensichtlich bedeutungslos ist.

Empfohlenes Tutorial: ?Java-Tutorial“

Das obige ist der detaillierte Inhalt vonWelche Funktion hat das Java-Schlüsselwort final?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!