Scénarios courants : Comprendre comment utiliser les fonctions de rappel en Java

Scénarios d'utilisation courants des fonctions de rappel Java

La fonction de rappel est un modèle de conception courant dans la programmation fonctionnelle, qui permet à une fonction d'être transmise en tant que paramètre à une autre fonction et appelée sous certaines conditions. Les fonctions de rappel sont largement utilisées dans divers scénarios en Java, notamment :

• Traitement des événements : les fonctions de rappel sont généralement utilisées pour gérer divers événements, tels que les clics sur des boutons, les mouvements de la souris, la saisie au clavier, etc. Lorsqu'un événement se produit, la fonction de rappel correspondante sera appelée pour effectuer l'opération correspondante.
• Programmation asynchrone : les fonctions de rappel sont également couramment utilisées dans la programmation asynchrone, c'est-à-dire que lorsqu'une opération prend beaucoup de temps, vous pouvez transmettre la fonction de rappel en tant que paramètre à l'opération et appeler la fonction de rappel après l'opération. est terminé, évitant ainsi de bloquer le thread principal.
• Programmation multithread : Dans la programmation multithread, les fonctions de rappel peuvent être utilisées pour coordonner la communication et la synchronisation entre différents threads. Lorsqu'un thread doit attendre qu'un autre thread termine une certaine tâche, il peut transmettre la fonction de rappel en tant que paramètre au thread et appeler la fonction de rappel une fois la tâche terminée, réalisant ainsi la communication et la synchronisation entre les threads.

Exemple de code

Voici quelques exemples de code pour les fonctions de rappel Java :

• Gestion des événements :

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class ButtonExample {

    public static void main(String[] args) {
        // 创建一个按钮
        JButton button = new JButton("Click me!");

        // 添加一个点击事件监听器
        button.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                // 当按钮被点击时，执行此代码
                System.out.println("Button clicked!");
            }
        });

        // 显示按钮
        JFrame frame = new JFrame();
        frame.add(button);
        frame.setSize(300, 300);
        frame.setVisible(true);
    }
}

Dans cet exemple, lorsque le bouton est cliqué, actionPerformed() Le La méthode sera appelée, affichant ainsi "Bouton cliqué!". actionPerformed()方法会被调用，从而输出"Button clicked!"。

• 异步编程：

import java.util.concurrent.CompletableFuture;

public class AsyncExample {

    public static void main(String[] args) {
        // 创建一个CompletableFuture对象
        CompletableFuture<Integer> future = new CompletableFuture<>();

        // 创建一个新线程来执行任务
        new Thread(() -> {
            // 执行任务
            int result = calculateSomething();

            // 将结果设置到CompletableFuture对象中
            future.complete(result);
        }).start();

        // 注册一个回调函数，当CompletableFuture对象完成时执行
        future.thenAccept(result -> {
            // 当任务完成时，执行此代码
            System.out.println("Result: " + result);
        });
    }

    private static int calculateSomething() {
        // 模拟一个耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 返回结果
        return 42;
    }
}

在这个示例中，calculateSomething()方法模拟了一个耗时操作，thenAccept()方法则是一个回调函数，当calculateSomething()方法执行完成后，thenAccept()方法会被调用，从而输出"Result: 42"。

• 多线程编程：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadExample {

    public static void main(String[] args) {
        // 创建一个线程池
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        // 创建一个任务
        Runnable task = () -> {
            // 执行任务
            System.out.println("Task executed by thread: " + Thread.currentThread().getName());
        };

        // 将任务提交给线程池
        executorService.submit(task);

        // 注册一个回调函数，当所有任务都完成后执行
        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.MINUTES);

        System.out.println("All tasks completed.");
    }
}

在这个示例中，submit()方法将任务提交给线程池，shutdown()方法关闭线程池，awaitTermination()

🎜🎜Programmation asynchrone🎜 : 🎜🎜rrreee🎜Dans cet exemple, la méthode calculateSomething() simule une opération fastidieuse, et la méthode thenAccept() est une Fonction de rappel, lorsque la méthode calculateSomething() est terminée, la méthode thenAccept() sera appelée, produisant ainsi "Résultat : 42". 🎜🎜🎜🎜Programmation multithread🎜 : 🎜🎜rrreee🎜Dans cet exemple, la méthode submit() soumet la tâche au pool de threads, et la méthode shutdown() La méthode ferme le pool de threads, la méthode awaitTermination() attend que toutes les tâches soient terminées et affiche finalement "Toutes les tâches terminées.". 🎜

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!