Welche Funktion hat das Java-Schlüsselwort final?

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() {
        // 没有在声明的同时赋值
        final int e;
        // 只能赋值一次
        e = 100;
        System.out.print(e);
        // 声明的同时赋值
        final int f = 200;
    }
    // 实例常量
    final int a = 5; // 直接赋值
    final int b; // 空白final变量
    // 静态常量
    final static int c = 12;// 直接赋值
    final static int d; // 空白final变量
    // 静态代码块
    static {
        // 初始化静态变量
        d = 32;
    }
    // 构造方法
    FinalDemo() {
        // 初始化实例变量
        b = 3;
        // 第二次赋值，会发生编译错误
        // 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

当使用 final 修饰基本类型变量时，不能对基本类型变量重新赋值，因此基本类型变量不能被改变。 但对于引用类型变量而言，它保存的仅仅是一个引用，final 只保证这个引用类型变量所引用的地址不会改变，即一直引用同一个对象，但这个对象完全可以发生改变。

下面程序示范了 final 修饰数组和 Person 对象的情形。

import java.util.Arrays;
class Person {
    private int age;
    public Person() {
    }
    // 有参数的构造器
    public Person(int age) {
        this.age = age;
    }
    // 省略age的setter和getter方法
    // age 的 setter 和 getter 方法
}
public class FinalReferenceTest {
    public static void main(String[] args) {
        // 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;
        // final修饰Person变量，p是一个引用变量
        final Person p = new Person(45);
        // 改变Person对象的age实例变量，合法
        p.setAge(23);
        System.out.println(p.getAge());
        // 下面语句对P重新赋值，非法
        // p = null;
    }
}

从上面程序中可以看出，使用 final 修饰的引用类型变量不能被重新赋值，但可以改变引用类型变量所引用对象的内容。例如上面 iArr 变量所引用的数组对象，final 修饰后的 iArr 变量不能被重新赋值，但 iArr 所引用数组的数组元素可以被改变。与此类似的是，p 变量也使用了 final 修饰，表明 p 变量不能被重新赋值，但 p 变量所引用 Person 对象的成员变量的值可以被改变。

注意：在使用 final 声明变量时，要求全部的字母大写，如 SEX，这点在开发中是非常重要的。

如果一个程序中的变量使用 public static final 声明，则此变量将称为全局变量，如下面的代码：

public static final String SEX= "女";

final修饰方法

final 修饰的方法不可被重写，如果出于某些原因，不希望子类重写父类的某个方法，则可以使用 final 修饰该方法。

Java 提供的 Object 类里就有一个 final 方法 getClass()，因为 Java 不希望任何类重写这个方法，所以使用 final 把这个方法密封起来。但对于该类提供的 toString() 和 equals() 方法，都允许子类重写，因此没有使用 final 修饰它们。

下面程序试图重写 final 方法，将会引发编译错误。

public class FinalMethodTest {
    public final void test() {
    }
}
class Sub extends FinalMethodTest {
    // 下面方法定义将出现编译错误，不能重写final方法
    public void test() {
    }
}

上面程序中父类是 FinalMethodTest，该类里定义的 test() 方法是一个 final 方法，如果其子类试图重写该方法，将会引发编译错误。

对于一个 private 方法，因为它仅在当前类中可见，其子类无法访问该方法，所以子类无法重写该方法——如果子类中定义一个与父类 private 方法有相同方法名、相同形参列表、相同返回值类型的方法，也不是方法重写，只是重新定义了一个新方法。因此，即使使用 final 修饰一个 private 访问权限的方法，依然可以在其子类中定义与该方法具有相同方法名、相同形参列表、相同返回值类型的方法。

下面程序示范了如何在子类中“重写”父类的 private final 方法。

public class PrivateFinalMethodTest {
    private final void test() {
    }
}
class Sub extends PrivateFinalMethodTest {
    // 下面的方法定义不会出现问题
    public void test() {
    }
}

上面程序没有任何问题，虽然子类和父类同样包含了同名的 void test() 方法，但子类并不是重写父类的方法，因此即使父类的 void test() 方法使用了 final 修饰，子类中依然可以定义 void test() 方法。

final 修饰的方法仅仅是不能被重写，并不是不能被重载，因此下面程序完全没有问题。

public class FinalOverload {
    // final 修饰的方法只是不能被重写，完全可以被重载
    public final void test(){}
    public final void test(String arg){}
}

final修饰类

final 修饰的类不能被继承。当子类继承父类时，将可以访问到父类内部数据，并可通过重写父类方法来改变父类方法的实现细节，这可能导致一些不安全的因素。为了保证某个类不可被继承，则可以使用 final 修饰这个类。

下面代码示范了 final 修饰的类不可被继承。

final class SuperClass {
}
class SubClass extends SuperClass {    //编译错误
}

因为 SuperClass 类是一个 final 类，而 SubClass 试图继承 SuperClass 类，这将会引起编译错误。

final 修饰符使用总结

1. final 修饰类中的变量

表示该变量一旦被初始化便不可改变，这里不可改变的意思对基本类型变量来说是其值不可变，而对对象引用类型变量来说其引用不可再变。其初始化可以在两个地方：一是其定义处，也就是说在 final 变量定义时直接给其赋值；二是在构造方法中。这两个地方只能选其一，要么在定义时给值，要么在构造方法中给值，不能同时既在定义时赋值，又在构造方法中赋予另外的值。

2. final 修饰类中的方法

说明这种方法提供的功能已经满足当前要求，不需要进行扩展，并且也不允许任何从此类继承的类来重写这种方法，但是继承仍然可以继承这个方法，也就是说可以直接使用。在声明类中，一个 final 方法只被实现一次。

3. final 修饰类

表示该类是无法被任何其他类继承的，意味着此类在一个继承树中是一个叶子类，并且此类的设计已被认为很完美而不需要进行修改或扩展。

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!