Comment les fermetures sont-elles implémentées en Java ?

Les fermetures en Java permettent aux fonctions internes d'accéder aux variables de portée externe même si la fonction externe est terminée. Implémentée via des classes internes anonymes, la classe interne contient une référence à la classe externe et maintient les variables externes actives. Les fermetures augmentent la flexibilité du code, mais vous devez être conscient du risque de fuite de mémoire, car les références à des variables externes par des classes internes anonymes maintiennent ces variables en vie.

Implémentation des fermetures en Java

En Java, une fermeture est une fonction qui a accès à une variable de portée englobante. Les fermetures sont implémentées en conservant une référence à une variable externe même si la fonction externe est terminée. Cela permet aux fonctions internes de conserver leur état dans l'environnement externe, créant ainsi un code plus flexible et réutilisable.

Méthode d'implémentation

Les fermetures en Java sont implémentées via des classes internes anonymes. Lorsqu'une classe interne anonyme accède à une variable externe, elle stocke une référence à la classe externe, gardant ainsi la variable externe active.

// 定义外部类
public class Outer {
    private int x = 10;

    // 创建一个闭包
    public Runnable createClosure() {
        // 匿名内部类定义了闭包
        return new Runnable() {
            @Override
            public void run() {
                System.out.println("x: " + x);
            }
        };
    }
}

Cas pratique

Le code suivant démontre l'utilisation des fermetures en Java :

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        
        // 创建闭包
        Runnable closure = outer.createClosure();
        
        // 外部变量 x 的值已更改
        outer.x = 20;

        // 即使外部函数退出，闭包仍然可以访问外部变量
        closure.run(); // 打印 "x: 20"
    }
}

Sortie :

x: 20

Comprendre l'impact des fermetures

• Les fermetures peuvent améliorer la flexibilité du code car l'état externe peut être conservé et transmis à travers les appels de fonction.
• Les fermetures peuvent provoquer des fuites de mémoire car la classe interne anonyme contient une référence à la variable externe même si la fonction externe s'est terminée. Il est donc important de gérer soigneusement les références lors de l’utilisation des fermetures.

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!