L'impact des différentes versions de Java sur les fonctions

Java 8 introduit les expressions Lambda et prend en charge les classes internes anonymes pour accéder aux variables locales. Java 9 permet aux expressions lambda de capturer des variables locales, et Java 10 implémente l'inférence de type de variable locale, où le compilateur peut déduire les paramètres d'expression lambda et les types de retour. Des cas pratiques montrent l'impact des expressions lambda sur l'accès aux variables locales et l'inférence de type dans différentes versions de Java.

Impact de la version Java sur les expressions Lambda

Introduction

Les expressions Lambda sont une fonctionnalité clé introduite dans Java 8 qui nous permet de déclarer des fonctions en tant qu'instances d'objets. Avant Java 8, nous ne pouvions utiliser que des classes internes anonymes pour implémenter des fonctions.

Java 8

Dans Java 8, une expression Lambda est représentée par un symbole de flèche (->), qui sépare les paramètres d'entrée du corps de la fonction. Par exemple :

(x) -> x + 1

Cette expression Lambda prend un paramètre d'entrée int et renvoie x + 1.

Java 9

Java 9 introduit la prise en charge de la capture de variables locales pour les expressions Lambda. Cela signifie que les expressions lambda peuvent désormais accéder aux variables locales dans leur portée, même si elles ne sont pas de type final. Par exemple :

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

Cette expression lambda peut accéder à la variable locale y même si elle n'est pas de type final.

Java 10

Java 10 introduit la prise en charge de l'inférence de type de variable locale pour les expressions lambda. Cela signifie que le compilateur peut déduire les types de paramètres d'expression lambda et renvoyer les types sans que nous les déclarions explicitement. Par exemple :

(x, y) -> x + y

Cette expression Lambda peut déduire que les paramètres d'entrée sont de type int et que le type de retour est de type int, même si nous ne les avons pas déclarés explicitement.

Cas pratique

Ce qui suit est un cas pratique montrant l'impact des différentes versions de Java sur les expressions 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); // 无法访问
}

Dans Java 8, les classes internes anonymes ne peuvent pas accéder aux variables locales y dans la portée car elles ne sont pas de type final . Les expressions Lambda ne peuvent pas non plus accéder à y car la capture de variables locales n'est pas prise en charge dans cette version de Java.

// 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); // 可以访问
}

Dans Java 9, les classes internes anonymes et les expressions Lambda peuvent désormais accéder aux variables locales y dans la portée, car la prise en charge de la capture de variables locales est implémentée.

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

Dans Java 10, les expressions Lambda peuvent automatiquement déduire les types de leurs paramètres d'entrée et leurs types de retour. Par conséquent, nous n'avons pas besoin de déclarer explicitement les types de paramètres d'entrée et les types de retour dans l'expression lambda.

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!