Apakah fungsi kata kunci akhir java

Dalam java, final boleh digunakan untuk mengubah suai kelas, kaedah dan pembolehubah. Kelas diubah suai akhir bermakna kelas itu tidak boleh diwarisi oleh mana-mana kelas lain, yang bermaksud bahawa kelas ini ialah kelas daun dalam pokok warisan, dan reka bentuk kelas ini telah dianggap sempurna dan tidak perlu diubah suai atau dilanjutkan. Kaedah dalam kelas diubah suai akhir bermakna kelas itu tidak boleh diwarisi oleh mana-mana kelas lain dan tidak boleh ditindih iaitu kaedah dikunci untuk menghalang kelas yang diwarisi daripada mengubahnya. final mengubah suai pembolehubah dalam kelas, menunjukkan bahawa pembolehubah tidak boleh diubah setelah ia dimulakan.

Persekitaran pengendalian tutorial ini: sistem Windows 7, versi Java 8, komputer DELL G3.

Apakah kata kunci terakhir?

1 Struktur yang akhir boleh digunakan untuk mengubah suai: kelas, kaedah, pembolehubah

2 : kelas ini Tidak boleh diwarisi oleh kelas lain.

Apabila kita perlu menghalang kelas daripada diwarisi, kita boleh menggunakan pengubahsuaian akhir, tetapi sila ambil perhatian: Semua kaedah ahli dalam kelas akhir akan ditakrifkan secara tersirat sebagai kaedah akhir .

Contohnya: Kelas rentetan, kelas Sistem, kelas StringBuffer

3 akhir digunakan untuk mengubah suai kaedah: menunjukkan bahawa kaedah ini tidak boleh ditindih

Fungsi
• (1) Kunci kaedah untuk menghalang kelas yang diwarisi daripada mengubahnya.
  (2) Kecekapan, dalam versi Java awal, kaedah akhir akan ditukar kepada panggilan dalam talian. Walau bagaimanapun, jika kaedah terlalu besar, mungkin tidak banyak peningkatan dalam prestasi. Oleh itu, dalam versi terkini, kaedah akhir tidak lagi diperlukan untuk pengoptimuman ini.
  Kaedah akhir bermaksud "akhir, muktamad" maksudnya, iaitu kaedah ini tidak boleh ditindih.

• Contohnya: getClass( ) dalam kelas Objek

4. pembolehubah adalah bersamaan dengan Pemalar

• akhir digunakan untuk mengubah suai atribut: lokasi yang boleh dipertimbangkan untuk tugasan ialah: pemulaan eksplisit, pemulaan dalam blok kod, pemulaan dalam pembina

• Pembolehubah tempatan diubah suai akhir: Terutama apabila akhir digunakan untuk mengubah suai parameter formal, ini menunjukkan bahawa parameter formal ialah pemalar. Apabila kami memanggil kaedah ini, kami menetapkan parameter sebenar kepada parameter malar Setelah ditetapkan, nilai parameter ini hanya boleh digunakan dalam badan kaedah dan tidak boleh ditetapkan semula.

• Jika muktamad mengubah suai jenis rujukan, selepas memulakannya, ia tidak lagi boleh menunjuk ke objek lain atau alamatnya tidak boleh berubah (kerana nilai rujukan ialah Alamat, muktamad memerlukan nilai, iaitu, nilai alamat tidak berubah), tetapi kandungan objek yang ditunjukkan oleh rujukan boleh berubah. Pada asasnya perkara yang sama.

5 Apabila menggunakan kata kunci akhir untuk mengisytiharkan kelas, pembolehubah dan kaedah, anda perlu memberi perhatian kepada perkara berikut:

Gunakan akhir Di hadapan pembolehubah, ini bermakna nilai pembolehubah tidak boleh diubah Dalam kes ini, pembolehubah boleh dipanggil pemalar.
akhir digunakan di hadapan kaedah untuk menunjukkan bahawa kaedah tidak boleh ditindih (jika subkelas mencipta kaedah dengan nama yang sama, jenis nilai pulangan yang sama dan parameter yang sama senaraikan sebagai kelas induk) , hanya pelaksanaan dalam badan kaedah berbeza untuk mencapai fungsi yang berbeza daripada kelas induk Kaedah ini dipanggil kaedah overriding, juga dikenali sebagai kaedah overwriting terperinci kemudian dalam tutorial).
final digunakan di hadapan kelas untuk menunjukkan bahawa kelas tidak boleh mempunyai subkelas, iaitu kelas tidak boleh diwarisi.

pembolehubah diubah suai akhir Pembolehubah yang diubah suai oleh muktamad menjadi pemalar dan hanya boleh diberikan nilai sekali, tetapi pembolehubah diubahsuai oleh muktamad Terdapat perbezaan antara pembolehubah tempatan dan pembolehubah ahli.

Pembolehubah tempatan diubah suai akhir mesti diberikan nilai sebelum ia boleh digunakan.
Pembolehubah ahli diubah suai akhir yang tidak diberikan nilai apabila diisytiharkan dipanggil "pembolehubah akhir kosong". Pembolehubah akhir yang kosong mesti dimulakan dalam pembina atau blok kod statik.
Nota: Adalah salah untuk mengatakan bahawa pembolehubah yang diubah suai oleh muktamad tidak boleh diberikan nilai Tegasnya, pembolehubah yang diubah suai oleh muktamad tidak boleh ditukar. pembolehubah akhir Nilai tidak boleh ditetapkan semula.

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

Selain itu, tidak kira apa jenis pemalar, ia hanya boleh ditetapkan sekali Lihat baris 29 kod untuk menetapkan nilai kepada pemalar b Kerana b telah ditetapkan sekali sebelum ini, ralat kompilasi akan berlaku berlaku di sini.

当使用 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 类，这将会引起编译错误。