Flash 跨对象实例的AS3侦听器-可能的/好的还是坏的做法？

我有一个关于as3侦听器和类实例的问题

主要问题：是否有一种方法可以从按钮实例中分派事件，使其他按钮实例可以侦听（而不需要文档类中的侦听器）

假设我有一个文档类和一个按钮类。文档将有多个按钮类实例添加到显示列表中。选择按钮后，将调用set方法将selected的包变量设置为该实例。我想从这里发送一个事件来通知所有其他实例

|document
|-button instance 1
|-button instance 2
|-button instance 3 (i want to send an event directly to instance 1 and 2...)

我当前的解决方案是创建一个buttonGroup类，该类实例化按钮，按钮将向组父级发送事件调用

|document
|-button group (catch the event and send an event to all instances within the group)
|---button instance 1
|---button instance 2
|---button instance 3 (dispatch  the event)

但是我的问题仍然存在——如果我有多个组，并且我想向所有组实例发送一个事件。。然后我需要一个buttonManager类来跟踪组（或者至少我是这样理解的？）

我并不反对这些“解决方案”，我只是想知道是否还有其他方法，或者我的解决方案是否是一种良好的做法。下面是我代码的基础（减去按钮管理器和组类）

我希望这是足够的描述，并温柔，我是新的OOP。。。 提前谢谢

文件.as

import flash.display.*;
import flash.events.*;
import myClasses.events.ButtonEvent;

public class Document extends MovieClip {       

    public function Document(){
        trace("initialising Document...");
        addEventListener(Event.ADDED_TO_STAGE, popStageVars);           
    }   


    private function popStageVars(e:Event){
        trace("popping stage vars...")

        var ob1:AbstractOBJ = new AbstractOBJ           
        var ob2:AbstractOBJ = new AbstractOBJ           
        var ob3:AbstractOBJ = new AbstractOBJ

        addChild(ob1)
        addChild(ob2)
        addChild(ob3)


        ob1.selected = ob1
        ob2.selected = ob2
        ob3.selected = ob3

    }       

}

按钮类：

import flash.display.*; 
import flash.events.*;
import myClasses.events.ButtonEvent;

public class ButtonOBJ extends MovieClip  implements IEventDispatcher {

    internal static var _selected:Object = null

    public function ButtonOBJ(){
        trace("initialising ButtonOBJ...");         
        addEventListener(Event.ADDED_TO_STAGE, popStageVars);
        addEventListener(AbstractEvent.SET_CUR, checkClip);
    }


    private function popStageVars(e:Event){
        trace("popping stage vars..." + this.name)
    }       

    private function checkClip(e:AbstractEvent){
        trace("checking button registered... " + this.name)
    }

    public function get selected():Object{
        return _selected                        
    }

    public function set selected(s:Object):void{
        var sName:String 

        if(selected != null){
            sName = selected.name
        }else{
            sName = null
        }

        trace(this.name + " is changing the current selected from: " + sName + " - to: " + s.name)          

        _selected = s
        dispatchEvent(new AbstractEvent(AbstractEvent.SET_CUR, true));  
    }       

}

还有按钮按钮：

package myClasses.events{       

import flash.events.Event;

public class ButtonEvent extends Event {

    public static const SET_CUR:String = "setSelected";
    public static const VERSION:Number = 1.0;

    public function ButtonEvent(type:String, bubbles:Boolean=false, cancelable:Boolean=false) {         
        super(type, bubbles, cancelable);
    }

    public override function clone():Event {
        return new ButtonEvent(this.type, this.bubbles, this.cancelable);
    }   

}
}

---

您的button类可以向阶段添加侦听器。如果你的事件冒泡，当目标发射事件时，它会冒泡到舞台上。按钮将“听到”事件并作出响应。我通常会做你正在做的事情，并将听众添加到一个组中。然后，当接收到事件时，我循环遍历按钮，如果

事件。target

与循环中的当前按钮相同，则将其设置为“selected”。

您的button类可以向阶段添加侦听器。如果你的事件冒泡，当目标发射事件时，它会冒泡到舞台上。按钮将“听到”事件并作出响应。我通常会做你正在做的事情，并将听众添加到一个组中。然后，当接收到事件时，我循环浏览按钮，如果

事件。target

与循环中的当前按钮相同，则将其设置为“selected”。

对于AS3来说也相对较新，但我最近在事件侦听器方面做了很多工作。将事件侦听器添加到后台的问题是，无论事件何时到达后台，都会触发is。此外，如果事件监听器是一个类的一部分，并且您添加了该类的10个实例，那么该阶段现在将有10个事件监听器都在做相同的事情，它们都将启动。如果你想要差异化（也就是说每个按钮都有不同的功能），你就必须循环使用它们，这就破坏了将其添加到舞台上的整个目的

我一直在做的就是在我的低级对象中，除了自定义事件之外，不使用任何事件监听器。假设我有三个按钮，当它们（而且只有它们）被点击时，我想做不同的事情。好吧，为了表现出来，他们必须被添加为某个东西的孩子，对吗？我将单个事件侦听器添加到它们的父级，然后从父级调用我希望出现的函数。像这样：

（注意：这是比实际代码更多的伪代码）

}

---

单击某个对象时，父对象将捕获该事件。然后它将检查单击的对象是否是ButtonObject（1、2或3；如果不是按钮，我们不希望有东西触发）。如果是，它将调用被单击的函数中的doStuff函数，而不是其他函数。您不必显式跟踪它们，因为它正在使用event.target查找对象。您还可以防止所有按钮一次触发，当然它们都可以执行不同的操作。

对于AS3来说也是相对较新的，但我最近在事件侦听器方面做了很多工作。将事件侦听器添加到后台的问题是，无论事件何时到达后台，都会触发is。此外，如果事件监听器是一个类的一部分，并且您添加了该类的10个实例，那么该阶段现在将有10个事件监听器都在做相同的事情，它们都将启动。如果你想要差异化（也就是说每个按钮都有不同的功能），你就必须循环使用它们，这就破坏了将其添加到舞台上的整个目的

我一直在做的就是在我的低级对象中，除了自定义事件之外，不使用任何事件监听器。假设我有三个按钮，当它们（而且只有它们）被点击时，我想做不同的事情。好吧，为了表现出来，他们必须被添加为某个东西的孩子，对吗？我将单个事件侦听器添加到它们的父级，然后从父级调用我希望出现的函数。像这样：

（注意：这是比实际代码更多的伪代码）

}

---

单击某个对象时，父对象将捕获该事件。然后它将检查单击的对象是否是ButtonObject（1、2或3；如果不是按钮，我们不希望有东西触发）。如果是，它将调用被单击的函数中的doStuff函数，而不是其他函数。您不必显式跟踪它们，因为它正在使用event.target查找对象。您还可以防止所有按钮一次触发，当然它们可以执行不同的操作。

如果我理解正确-您说的是将侦听器添加到文档类-但是按钮不会听到，因为事件会冒泡到顶部，并且不会命中其他实例-除非我弄错了。这种方法的问题是：它迫使我跟踪创建的所有按钮（一个数组，通过向实例发送方法调用循环），并失去了我所寻找的自我感知方法。这种方式基本上与团体相同。我爱你

package myClasses.events{       

import flash.events.Event;

public class ButtonEvent extends Event {

    public static const SET_CUR:String = "setSelected";
    public static const VERSION:Number = 1.0;

    public function ButtonEvent(type:String, bubbles:Boolean=false, cancelable:Boolean=false) {         
        super(type, bubbles, cancelable);
    }

    public override function clone():Event {
        return new ButtonEvent(this.type, this.bubbles, this.cancelable);
    }   

}
}

public class ParentObject extends Sprite{
    public ParentObject(){
        addchild(new ButtonObject1());
        addchild(new ButtonObject2());
        addchild(new ButtonObject3());
        addEventListener(MouseEvent.CLICK, doButtonThing);
    }

    private doButtonThing(e:MouseEvent):void{
        if(e.target is ButtonObject){
            e.target.doStuff();
        }
    }
}

public ButtonObject1 extends ButtonObject{ //This works for 2 and 3. Also note that all three objects extend a parent class called ButtonObject. This is useful in checking the event target.
    public ButtonObject1(){
        //Create the Object here.
    }

    public doStuff():void{
         //Whatever you want the button to do
    }