Kesan versi Java yang berbeza pada fungsi

Java 8 memperkenalkan ungkapan Lambda dan menyokong kelas dalaman tanpa nama untuk mengakses pembolehubah tempatan. Java 9 membenarkan ungkapan lambda untuk menangkap pembolehubah tempatan, dan Java 10 melaksanakan inferens jenis pembolehubah tempatan, di mana pengkompil boleh membuat kesimpulan parameter ekspresi lambda dan jenis pengembalian. Kes praktikal menunjukkan kesan ungkapan lambda pada akses pembolehubah tempatan dan inferens jenis dalam versi Java yang berbeza.

Impak Versi Java pada Ungkapan Lambda

Pengenalan

Ekspresi Lambda ialah ciri utama yang diperkenalkan dalam Java 8 yang membolehkan kami mengisytiharkan fungsi sebagai contoh objek. Sebelum Java 8, kami hanya boleh menggunakan kelas dalaman tanpa nama untuk melaksanakan fungsi.

Java 8

Dalam Java 8, ungkapan Lambda diwakili oleh simbol anak panah (->), yang memisahkan parameter input daripada badan fungsi. Contohnya:

(x) -> x + 1

Ungkapan Lambda ini mengambil parameter input int dan mengembalikan x + 1.

Java 9

Java 9 memperkenalkan sokongan untuk tangkapan pembolehubah tempatan untuk ekspresi Lambda. Ini bermakna ungkapan lambda kini boleh mengakses pembolehubah tempatan dalam skopnya, walaupun ia bukan jenis terakhir. Contohnya:

int y = 5;
(x) -> x + y

Ungkapan lambda ini boleh mengakses pembolehubah tempatan y walaupun ia bukan jenis akhir.

Java 10

Java 10 memperkenalkan sokongan untuk inferens jenis pembolehubah tempatan untuk ungkapan lambda. Ini bermakna pengkompil boleh membuat kesimpulan jenis parameter ekspresi lambda dan jenis pengembalian tanpa kami mengisytiharkannya secara eksplisit. Contohnya:

(x, y) -> x + y

Ungkapan Lambda ini boleh membuat kesimpulan bahawa parameter input adalah jenis int dan jenis pulangan adalah jenis int, walaupun kami tidak mengisytiharkannya secara eksplisit.

Kes praktikal

Berikut ialah kes praktikal yang menunjukkan kesan versi Java yang berbeza pada ungkapan Lambda:

// Java 8
public static void main(String[] args) {
    int y = 5;
    // 匿名内部类
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println(y); // 无法访问
        }
    };

    // Lambda 表达式
    Runnable lambda = () -> System.out.println(y); // 无法访问
}

Dalam Java 8, kelas dalaman tanpa nama tidak boleh mengakses pembolehubah tempatan y dalam skop kerana ia bukan jenis akhir . Ungkapan Lambda juga tidak boleh mengakses y kerana tangkapan pembolehubah tempatan tidak disokong dalam versi Java ini.

// Java 9
public static void main(String[] args) {
    int y = 5;
    // 匿名内部类
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println(y); // 可以访问
        }
    };

    // Lambda 表达式
    Runnable lambda = () -> System.out.println(y); // 可以访问
}

Dalam Java 9, kedua-dua kelas dalaman tanpa nama dan ungkapan Lambda kini boleh mengakses pembolehubah tempatan y dalam skop, kerana sokongan untuk penangkapan pembolehubah tempatan dilaksanakan.

// Java 10
public static void main(String[] args) {
    int y = 5;
    // Lambda 表达式，自动推断类型
    Runnable lambda = (x) -> {
        System.out.println(x + y);
    };
}

Dalam Java 10, ungkapan Lambda boleh membuat kesimpulan secara automatik jenis parameter input dan jenis pulangannya. Oleh itu, kita tidak perlu mengisytiharkan secara eksplisit jenis parameter input dan jenis pulangan dalam ungkapan lambda.

Atas ialah kandungan terperinci Kesan versi Java yang berbeza pada fungsi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!