在Java中创建自定义事件

我想用Java做类似的事情，但我不知道怎么做：

当“对象1说‘你好’”事件发生时， 然后对象2通过说“你好”来响应该事件

---

有人能给我一个提示或示例代码吗？

您可能想了解一下

下面是一些示例代码，您可以开始使用：

import java.util.*;

// An interface to be implemented by everyone interested in "Hello" events
interface HelloListener {
    void someoneSaidHello();
}

// Someone who says "Hello"
class Initiater {
    private List<HelloListener> listeners = new ArrayList<HelloListener>();

    public void addListener(HelloListener toAdd) {
        listeners.add(toAdd);
    }

    public void sayHello() {
        System.out.println("Hello!!");

        // Notify everybody that may be interested.
        for (HelloListener hl : listeners)
            hl.someoneSaidHello();
    }
}

// Someone interested in "Hello" events
class Responder implements HelloListener {
    @Override
    public void someoneSaidHello() {
        System.out.println("Hello there...");
    }
}

class Test {
    public static void main(String[] args) {
        Initiater initiater = new Initiater();
        Responder responder = new Responder();

        initiater.addListener(responder);

        initiater.sayHello();  // Prints "Hello!!!" and "Hello there..."
    }
}

import java.util.*；
//每个对“Hello”事件感兴趣的人都要实现的接口
接口HelloListener{
使某人说的话无效（）；
}
//说“你好”的人
类发起者{
私有列表侦听器=新的ArrayList（）；
public void addListener（HelloListener toAdd）{
添加（toAdd）；
}
公共空间{
System.out.println（“你好！！”；
//通知所有可能感兴趣的人。
对于（HelloListener hl:听众）
有人说：（）；
}
}
//对“你好”事件感兴趣的人
类响应程序实现HelloListener{
@凌驾
有人说公共空间无效{
System.out.println（“你好…”）；
}
}
课堂测试{
公共静态void main（字符串[]args）{
启动器启动器=新启动器（）；
Responder Responder=新的Responder（）；
Initiator.addListener（响应者）；
initiator.sayHello（）；//打印“你好！！！”和“你好…”
}
}

---

---

相关文章：

您需要的是的实现。您可以完全自己完成，也可以使用java类，如

java.util.Observer

和

java.util.Observable

有3种不同的设置方法：

投掷者

捕手内部

捕手

投掷器内部

投掷者

和

捕手

在本例中的另一个类内

测试

默认为选项3，要尝试其他选项，只需取消对要成为main的类的“

可选

”代码块的注释，并在

build.xml

文件中将该类设置为

${main class}

变量：

抛出端代码需要4件事：

import java.util.*;//import of java.util.event

//Declaration of the event's interface type, OR import of the interface,
//OR declared somewhere else in the package
interface ThrowListener {
    public void Catch();
}
/*_____________________________________________________________*/class Thrower {
//list of catchers & corresponding function to add/remove them in the list
    List<ThrowListener> listeners = new ArrayList<ThrowListener>();
    public void addThrowListener(ThrowListener toAdd){ listeners.add(toAdd); }
    //Set of functions that Throw Events.
        public void Throw(){ for (ThrowListener hl : listeners) hl.Catch();
            System.out.println("Something thrown");
        }
////Optional: 2 things to send events to a class that is a member of the current class
. . . go to github link to see this code . . .
}

---

以下内容不完全相同，但很相似，我正在搜索一个片段以添加对接口方法的调用，但发现了此问题，因此我决定为那些像我一样搜索此片段并发现此问题的人添加此片段：

 public class MyClass
 {
        //... class code goes here

        public interface DataLoadFinishedListener {
            public void onDataLoadFinishedListener(int data_type);
        }

        private DataLoadFinishedListener m_lDataLoadFinished;

        public void setDataLoadFinishedListener(DataLoadFinishedListener dlf){
            this.m_lDataLoadFinished = dlf;
        }



        private void someOtherMethodOfMyClass()
        {
            m_lDataLoadFinished.onDataLoadFinishedListener(1);
        }    
    }

用法如下：

myClassObj.setDataLoadFinishedListener(new MyClass.DataLoadFinishedListener() {
            @Override
            public void onDataLoadFinishedListener(int data_type) {
                }
            });

术语

• 侦听器是观察者/处理者
• dispatcher是主题/观察者容器

通常，当人们实现时，他们需要调度器存在，然后任何侦听器才能订阅它。但是有一种更好的方法叫做

信号是一个事件库。它通过引入一个Signal对象来解耦调度器的侦听器，该对象允许注册侦听器和分派事件。通过代理从接口自动创建信号。它负责管理侦听器的所有样板代码，并添加了一些漂亮的糖类代码API

界面聊天{
void onNewMessage（字符串s）；
}
福班{
Signal chatSignal=Signals.Signal（Chat.class）；
空条（）{
addListener（s->Log.d（“chat”，s））；//记录发送给Logcat的所有消息
}
}
第二类{
Signal chatSignal=Signals.Signal（Chat.class）；
void bar2（）{
chatSignal.dispatcher.onNewMessage（“来自Foo2的你好”）；//向所有侦听器发送“来自Foo2的你好”消息
}
}

在本例中，信号是从

聊天

界面自动创建的。它允许

Foo

注册它，并允许

Foo2

在无需交互的情况下发送新消息

---

免责声明：我是《信号》的作者。

没有通过的原因是否合法？它展示了如何使用最初提出的问题中的两个类来实现这一点。如果多个线程正在生成源事件，这会被正确同步吗？@GlassGhost:它被拒绝，因为它基本上是完全重写。如果他们修改了打字错误、格式和断开的链接等等，那么对其他人的答案进行编辑是很好的，但是他们不应该从根本上改变内容。（一些例外情况适用于标记为“CommunityWiki”的帖子。）java没有内置的东西吗？我真的更喜欢在抽象模式中这样做，而不是为每个事件实现for循环。由于java.util.Observer在java 9中被弃用，在实现自定义事件时是否有更好的选项？重用-回收。但是看看@GlassGhost：问题是

main

是静态的，在静态函数中没有

this

这样的东西。您需要在某处创建一个

新的Catcher1（）

，并传递该实例。1.5也不允许在静态上下文中使用

此
；我很确定它从未被允许过。@GlassGhost:使用
this
的代码在构造函数中，而不是在
main
中。这就是它起作用的原因。把它移到
main
，我保证不会。这就是人们一直试图告诉你的，而你的答案正试图做到的。我一点也不在乎github上有什么——我在乎github上有什么。“你的答案是不正确的。”格拉斯鬼：我不认为你的答案总体上是不充分的。我看到的问题是代码不能按原样工作——您试图使用
main
中的
this
，它不会在任何Java发布版本中编译。如果该部分位于构造函数中，或者如果
main
创建了一个
new Catcher1（）
，并使用该部分而不是
this
，则即使在1.6+中，它也应该可以工作。@GlassGhost:声明为静态的方法称为类方法。类方法总是在不引用特定对象的情况下被调用。试图将当前对象引用到我们
myClassObj.setDataLoadFinishedListener(new MyClass.DataLoadFinishedListener() {
            @Override
            public void onDataLoadFinishedListener(int data_type) {
                }
            });

interface Chat{
    void onNewMessage(String s);    
}

class Foo{
    Signal<Chat> chatSignal = Signals.signal(Chat.class);
    
    void bar(){
        chatSignal.addListener( s-> Log.d("chat", s) ); // logs all the messaged to Logcat
    }
}

class Foo2{
    Signal<Chat> chatSignal = Signals.signal(Chat.class);
    
    void bar2(){
        chatSignal.dispatcher.onNewMessage("Hello from Foo2"); // dispatches "Hello from Foo2" message to all the listeners
    }
}