关于AsBroadcaster(广播)类的讨论

static function initialize(o:Object);  
//o:对象  
//initialize:初始化方法，为对象o附加上作为事件源的各项功能。那么事件源都有什么功能呢？  
static function broadcastMessage(msg:String);  
//msg:消息  
//broadcastMessage:广播方法，事件源的一个主要功能就是向外界广播一条消息，告知听广播的人"某一事件发生啦!"  
static function addListener(o:Object);  
//o:对象  
//addListener:注册监听者方法，也就是决定广播消息给谁听的意思  
static function removeListener(o：Object);  
//o:对象  
//removeListener:注销监听者方法，也就是消息不再广播给谁听

var 司令部=new Object(); 
//啊，司令部是个发布指挥消息的地方，用它做事件源是个不错的选择 
AsBroadcaster.initialize(司令部); 
//这里直接用AsBroadcaster来引用AsBroadcaster类,原因如上述 
//调用AsBroadcaster类的静态方法initialize,为司令部附加上作为事件源的各项功能 
var 步兵=new Object(); 
//生成步兵对象 
步兵.on进攻=function(){ 
//on进攻: 这里之所以用’on’做前缀，是为了表明这个方法是响应一定事件的方法 
trace("步兵接到司令部来电，轻装上阵，火速向敌方阵地前进!"); 
// 接到’on进攻’消息后采取的措施 
} 
步兵.on驻守=function(){ 
//同上 
trace("步兵接到司令部来电，就地待命，多设岗哨,严防来犯之敌!"); 
} 
司令部.addListener(步兵); 
//将步兵添加为司令部的监听者，从现在起他将听从司令部的指令行事 
//以下雷同的地方，恕不赘述 
var 装甲兵=new Object(); 
装甲兵.on进攻=function(){ 
trace("装甲兵接到司令部来电，加足马力，火速向敌方阵地开进!"); 
} 
装甲兵.on驻守=function(){ 
trace("装甲兵接到司令部来电，就地待命，检修装甲,作好随时进攻的准备!"); 
} 
司令部.addListener(装甲兵); 
var 炮兵=new Object(); 
炮兵.on进攻=function(){ 
trace("炮兵接到司令部来电，向敌方阵地猛烈轰击!"); 
} 
炮兵.on驻守=function(){ 
trace("炮兵接到司令部来电，就地待命，保证弹药准备充足!"); 
} 
司令部.addListener(炮兵);
//-------------------下面开始演示------------------------------------
trace("司令部一号指示"); 
司令部.broadcastMessage("on进攻"); 
//司令部用’broadcastMessage’ 方法广播’on进攻’指令 
trace("司令部二号指示"); 
司令部.removeListener(步兵); 
//"将在外，君令有所不授"，司令部用’removeListener’方法注销了’步兵’听从指令的义务 
司令部.broadcastMessage("on驻守"); 
//司令部用’broadcastMessage’ 方法广播’on驻守’指令。注意:步兵现在不会驻守哦 
-----AsBroadcaster测试.fla 结束-----

static function initialize(object:Object):Void 
//object:对象 
//initialize:初始化方法，为对象object附加上作为事件源(在这里可以理解为派遣中心吧)的各项功能。 
static function _removeEventListener(queue:Object, event:String, handler):Void 
//一个内部方法,注销监听事件源相关事件的监听者,removeEventListener方法会调用它.

function dispatchEvent(eventObj:Object):Void 
/*事件派遣方法，向外界广播一个消息，并附有关于消息的相关描述(请与broadcastMessage(msg:String)方法比较) 
eventObj:事件对象，它至少应含有2个属性,假设司令部为一个事件派遣中心，一般定义如下: 
var eventObj=new Object(); 
eventObj.target=司令部;//定义广播消息的对象 
eventObj.type="on进攻";//定义消息的具体类型

*/function dispatchQueue(queueObj:Object, eventObj:Object):Void 
/*这个方法的中文意思，我根据它的功能将它称为"事件传达"。 
queueObj:一个事件派遣中心对象 
eventObj:事件对象,注意:与 dispatchEvent不同，它的target并无默认值，需要你手工设定.  
    为什么将这个方法称为事件传达呢?因为它可以让当前的事件派遣中心指示另一个事件派遣中心(方法的第一个参数)向外界广播消息。其实在dispatchEvent方法的内部就调用了dispatchQueue，只是将参数queueObj设为当前的事件派遣中心罢了。
*/function addEventListener(event:String, handler):Void 
/*注册某个事件的监听者 
event:监听的事件名称 
handler:监听事件的对象 
这个方法与AsBroadcaster类的addListener方法相比，多出了参数event， 
明确了所监听的具体事件。
*/
function removeEventListener(event:String, handler)
/*注销某个事件的监听者 
    event:事件名称  
    handler:要注销的监听事件的对象  
    这个方法与AsBroadcaster类的removeListener方法相比，多出了参数event，明确了从哪个事件中注销监听对象。
*/

import mx.events.EventDispatcher; 
//导入 mx.events.EventDispatcher类 
var 司令部 = new Object(); 
司令部.名称 = "司令部"; 
EventDispatcher.initialize(司令部); 
//为司令部对象附加上派遣中心的相关功能。 
var 战地指挥部 = new Object(); 
战地指挥部.名称="战地指挥部"; 
EventDispatcher.initialize(战地指挥部); 
//为战地指挥部对象附加上派遣中心的相关功能。 
var 步兵 = new Object(); 
步兵.on进攻 = function(eventObj) { 
　　　　　//步兵的’on进攻’事件处理方法，记住需要有参数 
var 来自=eventObj.target.名称; 
　　　　　//eventObj.target引用广播’on进攻’事件的对象，用它可以访问事件源并反馈消息。 
var 阵地=eventObj.阵地; 
　　　　　 //获取事件的关于’ 阵地’属性值 
trace("步兵接到"+来自+"来电，轻装上阵，火速向敌方"+阵地+"前进!"); 
}; 
步兵.on驻守 = function(eventObj) { 
var 来自=eventObj.target.名称; 
trace("步兵接到"+来自+"来电，就地待命，多设岗哨,严防来犯之敌!"); 
}; 
步兵.on冲锋=function(eventObj){ 
var 来自=eventObj.target.名称; 
var 阵地=eventObj.阵地; 
trace("步兵接到"+来自+"来电，向敌方"+阵地+"发起冲锋!"); 
} 
司令部.addEventListener("on驻守", 步兵); 
//向司令部的’on驻守’事件注册监听对象’步兵’ 
战地指挥部.addEventListener("on进攻", 步兵); 
//向司令部的’on进攻’事件注册监听对象’步兵’ 
战地指挥部.addEventListener("on冲锋",步兵); 
//向战地指挥部的’on冲锋’事件注册监听对象’步兵’ 
var 炮兵 = new Object(); 
炮兵.on进攻 = function(eventObj) { 
var 来自=eventObj.target.名称; 
var 阵地=eventObj.阵地; 
trace("炮兵接到"+来自+"来电，向敌方"+阵地+"阵地猛烈轰击!"); 
}; 
炮兵.on驻守 = function(eventObj) { 
var 来自=eventObj.target.名称; 
trace("炮兵接到"+来自+"来电，就地待命，保证弹药准备充足!"); 
}; 
司令部.addEventListener("on驻守", 炮兵); 
司令部.addEventListener("on进攻", 炮兵); 
var 敢死队=new Object(); 
敢死队.on冲锋=function(eventObj){ 
var 来自=eventObj.target.名称; 
var 阵地=eventObj.阵地; 
trace("敢死队接到"+来自+"来电，向敌方"+阵地+"发起冲锋!拼死也要拿下！"); 
} 
战地指挥部.addEventListener("on冲锋",敢死队); 
//--------------------------------------------------------------------- 
trace("司令部指示:"); 
var eventObj1 = new Object(); 
//定义事件对象eventObj1 
eventObj1.target = 司令部; 
//定义事件对象eventObj1的target属性值为司令部 
eventObj1.type = "on进攻"; 
//定义事件对象的事件类型为’on进攻’ 
eventObj1.阵地="505阵地" 
//一个自定义的属性’阵地’,你可以附加更多其他的属性 
司令部.dispatchEvent(eventObj1); 
//司令部将定义好的事件对象广播出去，只有向它注册了’on进攻’属性的监听对象才能收到。步兵并不会发动进攻。 
trace("战地指挥部指示:"); 
var eventObj2=new Object(); 
//eventObj2.target=战地指挥部; 
//因为dispatchEvent方法会自动将事件对象的target属性设为默认的广播消息的对象，所以这句也可以注释掉。 
eventObj2.type = "on进攻"; 
eventObj2.阵地="105阵地" 
战地指挥部.dispatchEvent(eventObj2); 
trace("传达司令部指示:"); 
var eventObj3=new Object(); 
eventObj3.target=战地指挥部; 
//这里必须设定事件对象的target属性。因为dispatchQueue不会为target属性设定默认值 
eventObj3.type="on冲锋"; 
eventObj3.阵地="123阵地"; 
司令部.dispatchQueue(战地指挥部,eventObj3); 
//战争时期也许司令部并不知道前线部队的布置情况，所以它可以将指令传达给战地指挥部，由战地指挥部将事件对象广播给向自己的相关事件注册的监听对象 
-----EventDispatcher测试.fla 结束-----

function 鼓励士气(){ 
trace("冲啊!杀啊!"); 
} 
战地指挥部.addEventListener("on冲锋",鼓励士气);

战地指挥部.on冲锋=function(){ 
trace("同志们，我们一定会取得最后的胜利！"); 
} 
战地指挥部.addEventListener("on冲锋",战地指挥部); 
但是还有一种更简洁的写法: 
战地指挥部.on冲锋Handler=function(){ 
trace("同志们，我们一定会取得最后的胜利！"); 
}

步兵.handlerEvent=function(eventObj){ 
var 来自=eventObj.target.名称; 
var 阵地=eventObj.阵地; 
var e=eventObj.type; 
switch(e){ 
case "on进攻": 
trace("步兵接到"+来自+"来电，轻装上阵，火速向敌方"+阵地+"前进!"); 
break; 
case "on驻守": 
trace("步兵接到"+来自+"来电，就地待命，多设岗哨,严防来犯之敌!"); 
break; 
case "on冲锋": 
trace("步兵接到"+来自+"来电，向敌方"+阵地+"发起冲锋!"); 
break; 
default: 
break; 
}  
    司令部.addEventListener("on驻守", 步兵);  
    战地指挥部.addEventListener("on进攻", 步兵);  
    战地指挥部.addEventListener("on冲锋",步兵);