【转】flash.events.IEventDispatcher介绍

转自：http://hi.baidu.com/ambitionwzj1818/blog/item/06816c24ad053b08908f9d13.html

如果你一个类，比如

public class fatherClass
{  
   public function fatherClass() 
   {   
   }  
}

然后又写一个sonClass类，继承这个fatherClass：

public class sonClass extends fatherClass
{  
   public function sonClass() 
   {   
   }  
}

这时候你的sonClass要添加发送消息的功能，而它继承的父类没有这个功能，要怎么办？

这个时候就要实现IEventDispatcher接口，可以这样写：

import flash.events.IEventDispatcher;
import flash.events.EventDispatcher;
import flash.events.Event;

/**如何使用IEventDispatcher
* 1、当需要一个可以发送事件的类；
* 2、这个类继承自某个类，并且父类没有发送事件的能力；
* 3、这个情况下该类不能继承自EventDispatcher类了，但他可以
*    通过实现IEventDispatcher接口来获得发送事件的能力；
* 4、本质上说，他还是在使用EventDispatcher；
*/
public class InfaceEventDispatcher implements IEventDispatcher
{
   private var dispatcher:EventDispatcher;
  
   public var testPara:String = "访问参数成功";
  
   public function InfaceEventDispatcher() 
   {
    dispatcher = new EventDispatcher(this);
   }

   public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void
   {
    dispatcher.addEventListener(type, listener, useCapture, priority);
   }

   public function dispatchEvent(evt:Event):Boolean
   {
    /**
    * 完成了发送事件的动作并且返回一个boolean值
    */
    return dispatcher.dispatchEvent(evt);
   }

   public function hasEventListener(type:String):Boolean
   {
    return dispatcher.hasEventListener(type);
   }

   public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void
   {
    dispatcher.removeEventListener(type, listener, useCapture);
   }

   public function willTrigger(type:String):Boolean
   {
    return dispatcher.willTrigger(type);
   }
}

为什么要实现IEventDispatcher接口呢？看起来都是里面的一个EventDispatcher在起作用啊，不实现这个接口可以吗？比如：

package myEvent 
{
import flash.events.EventDispatcher;
import flash.events.Event;

/**
* 1、要使一个类具有事件发送能力，并不一定要实现IEventDispatcher接口；
* 2、但是如果不实现这个接口，无法将this的引用注入到dispatcher里面，
*    发送事件是由该类里面的dispatcher发送，接收是由该类里面的dispatcher
*    接收，虽然该类是可以发送、接收事件，删除侦听，但是侦听函数的target
*    对象指向的是dispatcher，而不是该类本身，所以这样的定义方法在实际应
*    用中是不可取的；
* 3、在这个类里，我们不实现这个接口，我们只定义我们需要用到的方法；
* 
*/
public class nofaceEventDispatcher
{
   private var dispatcher:EventDispatcher;
  
   public var testPara:String = "访问参数成功";
  
   public function nofaceEventDispatcher() 
   {
   //dispatcher = new EventDispatcher(this);
    dispatcher = new EventDispatcher();
   }
   public function addEventListener(type:String, listener:Function):void
   {
    dispatcher.addEventListener(type, listener);
   }
   public function dispatchEvent(evt:Event):Boolean
   {
    return dispatcher.dispatchEvent(evt);
   }
   public function removeEventListener(type:String, listener:Function):void
   {
    dispatcher.removeEventListener(type, listener);
   }
  
}

}

你会发现你无法将当前类的引用注入到EventDispatcher里，因为类型不对。

尽管这样写dispatcher = new EventDispatcher();也是可以的，一样会有收发消息的功能，

但是做是有问题的。来看主类：

import flash.display.Sprite;
import flash.events.Event;

import myEvent.InfaceEventDispatcher;
import myEvent.nofaceEventDispatcher;

import flash.events.EventDispatcher;

public class Main extends Sprite 
{
   private var inEvent:InfaceEventDispatcher;
  
   private var noEvent:nofaceEventDispatcher;
  
   public function Main()
   {
    init();
   }
  
   private function init():void 
   {
    /*
    inEvent = new InfaceEventDispatcher();
    inEvent.addEventListener("doSomething", onSomethingHandler);
    inEvent.dispatchEvent(new Event("doSomething"));
    */
   
    noEvent = new nofaceEventDispatcher();
    noEvent.addEventListener("doSomething", onSomethingHandler);
    noEvent.dispatchEvent(new Event("doSomething"));
   
   }
  
   private function onSomethingHandler(e:Event):void 
   {
    trace("发送事件成功!");
    trace(e.target);
    //trace(e.target.testPara);
    /**
    * e.target:
    * InfaceEventDispatcher:[object InfaceEventDispatcher]
    * nofaceEventDispatcher:[object EventDispatcher]
    */
    /**
    * e.target.testPara:
    * InfaceEventDispatcher:访问成功
    * nofaceEventDispatcher:报错
    */
   }
  
}

因此，必须要实现IEventDispatcher接口的，才能有一个完整且正常的消息发送机制。

转载于:https://www.cnblogs.com/nnugaozhi/archive/2011/06/08/2075270.html