java实现一个简单的监听器

在 Java 中，我们可以通过实现监听器（Listener）模式来处理事件和回调。监听器模式是一种常见的设计模式，用于实现对象间的松耦合通信。本文将介绍如何在 Java 中实现一个简单的监听器。

步骤

以下是实现一个监听器的基本步骤：

1. 定义监听器接口：

public interface MyListener {
    void onEvent(Event event);
}
1
2
3

2. 实现监听器类：

public class MyListenerImpl implements MyListener {
    @Override
    public void onEvent(Event event) {
        System.out.println("Event received: " + event.getData());
    }
}
1
2
3
4
5
6

3. 创建事件类：

public class Event {
    private String data;

    public Event(String data) {
        this.data = data;
    }

    public String getData() {
        return data;
    }
}
1
2
3
4
5
6
7
8
9
10
11

4. 创建事件源类：

import java.util.ArrayList;
import java.util.List;

public class EventSource {
    private List<MyListener> listeners = new ArrayList<>();

    public void addListener(MyListener listener) {
        listeners.add(listener);
    }

    public void removeListener(MyListener listener) {
        listeners.remove(listener);
    }

    public void fireEvent(Event event) {
        for (MyListener listener : listeners) {
            listener.onEvent(event);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

5. 使用监听器：

public class Main {
    public static void main(String[] args) {
        EventSource eventSource = new EventSource();
        MyListener listener = new MyListenerImpl();
        eventSource.addListener(listener);

        Event event = new Event("Hello, World!");
        eventSource.fireEvent(event);

        eventSource.removeListener(listener);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

结论

通过实现监听器模式，我们可以在 Java 中实现对象间的事件通信。监听器模式将事件的产生和处理解耦，提高了代码的可维护性和可扩展性。在实际开发中，我们可以根据需要自定义事件和监听器，并将其应用于各种场景。