Quelle est l'alternative aux classes internes anonymes en Java ?

Les expressions Lambda, comme alternative aux classes internes anonymes, offrent un moyen plus concis de définir l'implémentation des interfaces fonctionnelles : utilisez la syntaxe courte (paramètres) -> expression pour définir des fonctions anonymes. Convient aux situations où des interfaces fonctionnelles doivent être implémentées (une seule méthode abstraite). Peut simplifier des tâches telles que le tri de liste et la définition de thread.

Expressions lambda

Comme alternative aux classes internes anonymes, Java 8 a introduit les expressions lambda. Une expression lambda est une fonction anonyme légère qui peut être définie et utilisée sans déclarer de classe.

Syntaxe :

(parameters) -> expression

Par exemple, le code suivant utilise une classe interne anonyme pour ajouter un écouteur pour un bouton :

Button button = new Button();
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        // 实现事件处理代码
    }
});

À l'aide d'expressions lambda, il peut être simplifié en :

Button button = new Button();
button.addActionListener(e -> {
    // 实现事件处理代码
});

Interface fonctionnelle

lambda les expressions ne peuvent être utilisées que pour implémenter des interfaces fonctionnelles, c'est-à-dire des interfaces qui ne contiennent qu'une seule méthode abstraite. Plusieurs interfaces fonctionnelles intégrées sont fournies en Java, telles que Runnable、Callable 和 Comparator.

Cas pratique

Utilisation d'expressions lambda pour trier des listes :

List<String> names = Arrays.asList("John", "Mary", "Bob");

// 使用匿名内部类
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o1.compareToIgnoreCase(o2);
    }
});

// 使用 lambda 表达式
Collections.sort(names, (o1, o2) -> o1.compareToIgnoreCase(o2));

Définir des threads à l'aide d'interfaces fonctionnelles :

// 使用匿名内部类
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        // 线程逻辑
    }
});

// 使用 lambda 表达式
Thread thread = new Thread(() -> {
    // 线程逻辑
});

Conclusion

Les expressions lambda offrent plus de concision que les classes internes anonymes , une manière plus élégante pour écrire du code. Ils simplifient l’utilisation des interfaces fonctionnelles et améliorent la lisibilité et la maintenabilité du code.

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!