Quelle est la fonction du mot - clé final Java

En Java, final peut être utilisé pour modifier des classes, des méthodes et des variables. La classe finale modifiée signifie que la classe ne peut être héritée par aucune autre classe, ce qui signifie que cette classe est une classe feuille dans un arbre d'héritage, et la conception de cette classe a été considérée comme parfaite et n'a pas besoin d'être modifiée ou étendue. La méthode dans la classe finale modifiée signifie que la classe ne peut être héritée par aucune autre classe et ne peut pas être remplacée ; c'est-à-dire que la méthode est verrouillée pour empêcher la classe héritée de la modifier. final modifie une variable dans une classe, indiquant que la variable ne peut pas être modifiée une fois initialisée.

L'environnement d'exploitation de ce tutoriel : système windows7, version java8, ordinateur DELL G3.

Quel est le mot-clé final ?

1. Final peut être utilisé pour modifier des structures : classes, méthodes, variables

2. Final est utilisé pour modifier une classe : cette classe ne peut pas être héritée par d'autres classes.

Lorsque nous devons empêcher l'héritage d'une classe, nous pouvons utiliser la modification finale, mais veuillez noter : Toutes les méthodes membres de la classe finale seront implicitement définies comme méthodes finales.

Par exemple : classe String, classe System, classe StringBuffer

3. final est utilisé pour modifier la méthode : indiquant que cette méthode ne peut pas être remplacée

• Fonction

  (1) Verrouiller la méthode pour empêcher les classes héritées de en le modifiant Apportez des modifications.

  (2) Efficacité, dans les premières versions de Java, les méthodes finales seront converties en appels en ligne. Cependant, si la méthode est trop volumineuse, les performances risquent de ne pas être améliorées. Par conséquent, dans les versions récentes, les méthodes finales ne sont plus nécessaires pour ces optimisations.

  La méthode finale signifie le sens « final, final », c'est-à-dire que cette méthode ne peut pas être remplacée.

• Par exemple : getClass() dans la classe Object

4 final est utilisé pour modifier les variables. À l'heure actuelle, les variables sont équivalentes aux constantes

• final est utilisé pour modifier les attributs. les positions qui peuvent être considérées pour l'affectation sont : : Initialisation explicite, initialisation dans des blocs de code, initialisation dans des constructeurs

• variables locales modifiées finales : Surtout lorsque final est utilisé pour modifier le paramètre formel, cela indique que le paramètre formel est une constante . Lorsque nous appelons cette méthode, nous attribuons un paramètre réel au paramètre constant. Une fois attribuée, la valeur de ce paramètre ne peut être utilisée que dans le corps de la méthode et ne peut pas être réaffectée.

• Si final modifie un type référence, après l'avoir initialisé, il ne peut plus pointer vers d'autres objets ou son adresse ne peut pas changer (car la valeur de la référence est une adresse, et final nécessite une valeur, c'est-à-dire La valeur de l'adresse ne change pas), mais le contenu de l'objet pointé par la référence peut changer. Essentiellement la même chose.

5. Lorsque vous utilisez le mot-clé final pour déclarer des classes, des variables et des méthodes, vous devez faire attention aux points suivants :

• final est utilisé devant une variable pour indiquer que la valeur du La variable ne peut pas être modifiée. À ce stade, la variable peut être appelée constante.

• final est utilisé devant une méthode pour indiquer que la méthode ne peut pas être remplacée (si une méthode est créée dans la sous-classe avec le même nom, le même type de valeur de retour et la même liste de paramètres que dans la classe parent , seule l'implémentation dans le corps de la méthode est différente , pour obtenir des fonctions différentes de celles de la classe parent, cette méthode est appelée remplacement de méthode, également appelée écrasement de méthode. Vous pouvez le comprendre ici, nous l'expliquerons en détail plus tard dans le. tutoriel).

• final est utilisé devant une classe pour indiquer que la classe ne peut pas avoir de sous-classes, c'est-à-dire que la classe ne peut pas être héritée.

variables finales modifiées

La variable modifiée par final devient une constante et ne peut se voir attribuer une valeur qu'une seule fois, mais les variables locales et les variables membres modifiées par final sont différentes.

• Les variables locales modifiées finales doivent se voir attribuer une valeur avant de pouvoir être utilisées.

• Les variables membres finales modifiées qui ne reçoivent pas de valeur lorsqu'elles sont déclarées sont appelées "variables finales vierges". Les variables finales vides doivent être initialisées dans un constructeur ou un bloc de code statique.

Remarque : Il est faux de dire que les variables finales modifiées ne peuvent pas être attribuées. À proprement parler, les variables finales modifiées ne peuvent pas être modifiées. Une fois la valeur initiale obtenue, la valeur de la variable finale ne peut pas être réaffectée.

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;
    }
}

Les lignes 4 et 6 du code ci-dessus déclarent des constantes locales. La ligne 4 déclare seulement qu'il n'y a pas d'affectation, mais elle doit être attribuée avant utilisation (voir la ligne 6 du code. En fait, il est préférable d'initialiser local). constantes en même temps qu’elles sont déclarées. Les lignes 13, 14, 16 et 17 du code déclarent toutes des constantes membres. Les lignes 13 et 14 du code sont des constantes d'instance. S'il s'agit d'une variable finale vide (voir ligne 14 du code), elle doit être initialisée dans le constructeur (voir ligne 27 du code). Les lignes 16 et 17 du code sont des constantes statiques. S'il s'agit d'une variable finale vide (voir ligne 17 du code), elle doit être initialisée dans un bloc de code statique (voir ligne 21 du code).

De plus, quel que soit le type de constante ne peut être attribué qu'une seule fois, voir la ligne 29 du code pour attribuer une valeur à la constante b, car b a été attribué une fois auparavant, donc une erreur de compilation se produira ici.

final modifie la différence entre les variables de type de base et les variables de type référence

当使用 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 修饰类

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

Pour les membres en classes terminales, vous pouvez les définir comme finales ou non. Quant aux méthodes, la classe à laquelle elles appartiennent étant définitive, elles le deviennent naturellement. Vous pouvez également ajouter explicitement une méthode final à la classe finale, ce qui n'a évidemment aucun sens.

Tutoriel recommandé : "Tutoriel 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!