委托事件
委托就像用别的方法代替了原来的方法，交给现在这个代替后的方法使用，使用时和原来的方法没有变化。
c#在语法中有委托的概念，所以实现起来非常方便，但是java中没有，所以只能自己使用发射机制来实现。
要在java中实现委托，必须首先定义事件类，其中包括要调用的对象、要调用的方法名称、方法所需的参数和参数类型
package com.suski.delegate；
import java.lang.reflect.Method；
公共类事件{
私有对象；
私有字符串方法名称；
权限对象[ ] params；
private Class[] paramTypes；
公共事件(objectobject，String method，Object.args ) )。
{
this.object=object；
this.methodName=method；
this.params=args；
contractparamtypes(this.Params；
}
privatevoidcontractparamtypes (object [ ] params ) )
{
this.param types=new class [ params.length ]；
for(intI=0； I
{
this.param types [ I ]=params [ I ].getclass (；
}
}
public void invoke () throws Exception
{
Method method=object.getClass ().get method (this.method name，this.paramTypes )； //判断此函数是否存在
if (空值==方法) )。
{
返回；
}
method.invoke(this.object，this.params )； //利用反射机制调用函数
}
}
定义完事件类后，可以使用委托。 传递调用方法的对象、方法名称和参数就好了。
弥补观察者模式的缺点
要实现在昨天的观察器模式中实现的效果(一个类将更改通知给几个类)，还必须定义事件管理队列中的类
package com.suski.delegate；
import java.util.ArrayList；
import java.util.List；
公共类事件管理器{
私有列表对象；
public EventHandler (
{
objects=new ArrayList (；
}
公共void addevent (objectobject，String methodName，Object.args ) )。
{
objects.add(newevent(object，methodName，args ) )；
}
public void notifyX () throws Exception
{
事件事件：对象) )。
{
event.invoke (；
}
}
}
这个类将所有事件放入List中，到时候一次取出
定义队列后，可以为通知定义抽象类
package com.suski.delegate；
公共类通告程序{
privateeventhandlereventhandler=new eventhandler (；
publiceventhandlergeteventhandler (
{
return eventHandler；
}
publicvoidseteventhandler (事件事件发生器) )。
{
this.eventHandler=eventHandler；
}
publicabstractvoidaddlistener (objectobject，String methodName，Object.args )；
公共备用语音通知(；
}
定义具体的实现类
package com.suski.delegate；
publicclassconcretenotifierextendsnotifier {
@Override
public void addlistener (object，String methodName，Object. args ) {
this.getEventHandler ().addevent(object，methodName，args )；
}
@Override
公共void notifyx (
try {
this.getEventHandler ().notifyX )；
}catch(exceptione ) {
//TODO: handle exception
e .打印任务跟踪(；
}
}
}
此时，定义需要通知的对象类即可
package com.suski.delegate；
import java.util.Date；
公共类watchingtvlistener {
public WatchingTVListener (
{
system.out.println(watchingTV )；
}
publicvoidstopwatchingtv (datedate ) )
{
system.out.println (stop watching ' date；
}
}
package com.suski.delegate；
import java.util.Date；
publicclassplayinggamelistener {
public PlayingGameListener (
{
system.out.println(playing )；
}
公共桌面播放表(datedate ) )。
{
system.out.println (stop playing ' date；
}
}
测试方法
package com.suski.delegate；
import java.util.Date；
公共类测试{
publicstaticvoidmain (string [ ] args ) )。
{
notifiergoodnotifier=newconcretenotifier (；
playinggamelistenerplayinggamelistener=newplayinggamelistener (；
watchingtvlistenerwatchingtvlistener=newwatchingtvlistener (；
good notifier.addlistener (playinggamelistener，' stopPlayingGame '，new Date ) )；
good notifier.addlistener (watchingtvlistener，' stopWatchingTV '，new Date ) )；
goodNotifier.notifyX (；
}
}
这样就负责c#的委托了。 这样，观察者模式的缺点也得到改善。 通知者类完全不知道自己需要通知的是谁，完全可以解除耦合。 同时也移除了抽象的观察者类。
昨天完全不知道java的委托怎么办，但终于找到了一个。 这感觉很好，所以写下来和大家分享。