C#.net事件和java

所以我来自c#net背景，我正试图用java实现这一点

Class A{

public delegate void EventHandler();

    public static event EventHandler workComplete();

void doWork(){

    // DO WORK  

}

void onWorkComplete(){

    // Riase Event

    workComplete();

}

} 班长{

A a = new A();

a.workComplete += () -> {

    // On Class A Complete Work

    Console.WriteLine("Work Complete");

`
}; }

我在Java sense中搜索委托事件是requers委托，就像在c#.net中一样，但看起来Java没有委托，然后我开始搜索Java中事件的工作方式，然后我分为三件事 1-动作侦听器 2-事件侦听器 3-和许多接口 4-观察者模式

我完全搞混了，可能是因为我只知道C#events使用委托

因此，如果有人能给出一个示例，比如上面用Java编写的c#.net代码，那将是非常有用的

---

谢谢你。

我要把它弄得又快又脏。 不幸的是，在Java中，您必须编写更多的代码才能产生相同的结果

我将代码分为3个部分：

• 类似于

  委托

  声明的接口

• A类

  包含

  事件

  声明、订阅逻辑和提升逻辑

• B类

  它是“事件使用者”并声明事件处理程序

祝你好运

// this is what you used to have as a delegate declaration {
public interface IWorkCompletedListener {
    public void someMethodName(Object sender, Object args);
}
// }

// class A will be the event provider
public class A {

    // this is what you used to have for an event declaration {
    // used for the storage of listeners
    private static Vector<IWorkCompletedListener> workComplete = new Vector<IWorkCompletedListener>();

    // used for +=
    public static void addWorkCompleteListener(IWorkCompleteListener listener) {
        A.workComplete.add(listener);
    }
    // used for -=
    public static void removeWorkCompleteListener(IWorkCompleteListener listener) {
        A.workComplete.remove(listener);
    }
    // }

    // this is what you would use to raise the event {
    private static void raiseWorkCompletedListener(Object sender, Object args) {
        for (IWorkCompletedListener listener : A.workComplete)
            listener.someMethodName(sender, args);
    }
    // }

    // and the test code
    public static void doWork() {
        // Stuff goes here
        A.raiseWorkCompletedListener(null, null);
    }

}

// class B will be the event consumer
public class B {

    public static void subscribeAndCallDoWork() {
        // this is what += used to be
        A.addWorkCompleteListener(new IWorkCompletedListener {
            public void someMethodName(Object sender, Object args) {

                // I didn't want to force class B to implement the interface
                // hence I used an anonymous interface implementation
                // from which I'm calling the "event handler"
                B.onWorkCompleted(sender, args);

            }
        });

        A.doWork();
    }

    private static onWorkCompleted(Object sender, Object args) {
       // expect to be called here
    }

}

//这是您过去用作委托声明的内容{
公共接口IWorkCompletedListener{
public void someMethodName（对象发送方、对象参数）；
}
// }
//类将是事件提供程序
公共A类{
//这是用于事件声明的内容{
//用于存储侦听器
私有静态向量workComplete=新向量（）；
//用于+=
公共静态void addWorkCompleteListener（IWorkCompleteListener侦听器）{
A.workComplete.add（侦听器）；
}
//用于-=
公共静态void removeWorkCompleteListener（IWorkCompleteListener侦听器）{
A.工作完成。删除（侦听器）；
}
// }
//这是你用来举办活动的{
私有静态void raiseWorkCompletedListener（对象发送方、对象参数）{
for（IWorkCompletedListener侦听器：A.workComplete）
someMethodName（发送方，args）；
}
// }
//以及测试代码
公共静态无效工作（）{
//这里有东西
A.raiseWorkCompletedListener（null，null）；
}
}
//B类将是活动消费者
公共B级{
公共静态无效subscribeAndCallDoWork（）{
//这就是+=过去的样子
A.addWorkCompleteListener（新的iWorkCompleteListener{
public void someMethodName（对象发送方、对象参数）{
//我不想强迫B类实现接口
//因此，我使用了匿名接口实现
//我从中调用“事件处理程序”
B.已完成的工作（发送方，args）；
}
});
A.道工（）；
}
私有静态onWorkCompleted（对象发送方、对象参数）{
//期待在这里被召唤
}
}

Java对事件使用观察者模式（在Java中通常被称为侦听器）。谷歌java监听器的例子。