0

あるクラスでaddEventListenerを使用して、クリックされている別のクラスのボタンに反応する方法を知っています。それよりも一般的な目的で使用したい場合はどうなりますか？呼び出されている他のクラスのメンバー関数の1つに反応するためにそれを使用したい場合はどうなりますか？そのための構文はありますか？ありがとう！

編集：私はすでに答えをグーグルで検索していることに注意してください。

4

3 に答える 3

2

別のクラスのメンバー関数呼び出しをリッスンする場合は、イベントをディスパッチするためにその関数呼び出しが必要です。これは簡単です...

リスナークラス

addEventListener("customEvent", listenerFunc);

ディスパッチャクラス（EventDispatcherを拡張/ IEventDispatcherを実装）

dispatchEvent(new Event("customEvent"));

リスナークラスがオブジェクト階層のディスパッチャクラスの上にある限り、これは完全に機能します。そうでない場合は、ある種のグローバルEventDispatcherクラスを使用して、そのクラスにすべてのリスナーを登録することをお勧めします。

于 2012-05-07T16:25:36.307 に答える
1

これは、java.awt.Componentインスタンスおよびjava.awt.Componentを拡張するすべてのオブジェクトのJAVAに似ています。AS3では、IEventDispatcherのメソッドを実装するflash.display.Spriteインスタンスを拡張するすべてのオブジェクトにリスナーを追加できます...

したがって、flash.display.Spriteを拡張しないクラスがある場合、インスタンスにリスナーを追加してイベントを処理するには、EventDispatcherを拡張する必要があります...

クラスがEventDispatcherを拡張できない場合は、IEventDispatcherを実装する必要があります。

これが[classMovieClip]を拡張した[classMainClass]です

このMainClassインスタンスは、以下を作成します。

[class Object]を拡張し、IEventDispatcherを実装する[classObjectA]のインスタンス。

[classEventDispatcher]を拡張する[classObjectB]のインスタンス

拡張メソッドと実装メソッドを使用するコードは次のとおりです。この簡単な例がお役に立てば幸いです...（そして私の英語は申し訳ありませんが、これは私の母国語ではありません。）

MainClass.asで：

package com
{
import flash.utils.getDefinitionByName;
import flash.display.MovieClip;
import flash.utils.getDefinitionByName;
import flash.utils.getQualifiedClassName;
import flash.utils.getQualifiedSuperclassName;
import com.classes.ObjectA;
import com.classes.ObjectB;
import flash.events.Event;

public class MainClass extends flash.display.MovieClip
{

    private static const DEBUG:Boolean = true;
    private static var instance:MainClass;
    private static var instanceOfA:ObjectA;
    private static var instanceOfB:ObjectB;

    public function MainClass()
    {
        MainClass.debug("MainClass constructor called");
        MainClass.debug(getClassInformations(MainClass));
        MainClass.debug(getClassInformations(ObjectA));
        MainClass.debug(getClassInformations(ObjectB));

        instanceOfA = new ObjectA();
        instanceOfB = new ObjectB();
        instanceOfA.addEventListener(ObjectA.DO_SOMETHING_EVENT,onInstanceOfA_doSomething,false,0,false);
        instanceOfB.addEventListener(ObjectB.DO_SOMETHING_EVENT,onInstanceOfB_doSomething,false,0,false);
        instanceOfA.doSomething();
        instanceOfB.doSomething();
    }
    public static function onInstanceOfA_doSomething(e:Event):void
    {
        trace("An ObjectA has Dispatched An Event of type \"" + e.type + "\"" + " on " + e.target);
    }
    public static function onInstanceOfB_doSomething(e:Event):void
    {
        trace("An ObjectB has Dispatched An Event of type \"" + e.type + "\"" + " on " + e.target);
    }
    public static function getDebugMode():Boolean
    {
        return DEBUG;
    }

    public static function debug(string:String)
    {
        if (getDebugMode())
        {
            trace(string);
        }
    }
    public static function getClassInformations(someClass:Class):String
    {
        var clss:Object = null;
        var supClss:Object = null;

        clss = getDefinitionByName(getQualifiedClassName(someClass));
        try
        {
            supClss = getDefinitionByName(getQualifiedSuperclassName(someClass));
        }
        catch (e:ArgumentError)
        {
            // Has no superClass (ex:Object)
        }
        if (supClss != null)
        {
            return ("class " + clss + " extends " + supClss);
        }
        else
        {
            return ("class " + clss);
        }
    }
}
}

ObjectB.as （最も簡単な方法）：

package com.classes{
import com.MainClass;
import flash.events.EventDispatcher;
import flash.events.Event;

public class ObjectB extends EventDispatcher {
    public static var DO_SOMETHING_EVENT:String = "do_something_event";
    private var onDoSomethingEvent:Event = new Event(DO_SOMETHING_EVENT,false,false);
    public function ObjectB() {
        MainClass.debug("constructor ObjectB called");
    }
    public function doSomething():void{
        this.dispatchEvent(onDoSomethingEvent);
    }

}

}

ObjectA.as内（インターフェイスIEventDispatcherのすべてのメソッドを実装する必要があります）：

package com.classes
{
import com.MainClass;
import flash.events.IEventDispatcher;
import flash.events.EventDispatcher;
import flash.events.Event;

public class ObjectA implements IEventDispatcher
{
    public static var DO_SOMETHING_EVENT:String = "do_something_event";
    private var onDoSomethingEvent:Event = new Event(DO_SOMETHING_EVENT,false,false);
    private var dispatcher:EventDispatcher;
    public function ObjectA()
    {
        dispatcher = new EventDispatcher(this);
        MainClass.debug("constructor ObjectA called");
    }
    public function doSomething():void
    {
        this.dispatchEvent(onDoSomethingEvent);
    }
    public function addEventListener( 
    event_type:String, 
    event_listener:Function, 
    use_capture:Boolean = false, 
    priority:int = 0, 
    weakRef:Boolean = false 
    ):void
    {
        // implements addEventListener here
        dispatcher.addEventListener(event_type, event_listener, use_capture, priority, weakRef);
    }
    public function dispatchEvent(e:Event):Boolean
    {
        // implements dispatchEvent here
        return dispatcher.dispatchEvent(e);
    }
    public function removeEventListener(
    event_type:String, 
    event_listener:Function, 
    use_capture:Boolean = false
    ):void
    {
        // implements removeEventListener here
        dispatcher.removeEventListener(event_type, event_listener, use_capture);
    }
    public function hasEventListener(type:String):Boolean
    {
        // implements hasEventListener here
        return dispatcher.hasEventListener(type);
    }
    public function willTrigger(type:String):Boolean
    {
        // implements willTrigger here
        return dispatcher.willTrigger(type);
    }
}

}

EventDispatcherを拡張する場合は、一部のメソッドをオーバーライドすることもできます。この場合、「overrideキーワードを次のように使用する必要があります。

public override function dispatchEvent (e:Event):Boolean {
        // a method of EventDispatcher may be overridden if needed !
        // do what you need HERE...
        return dispatchEvent(e);
    }

AS3では、overrideキーワードを指定する必要があります。指定しないと、エラー1024が発生します。

「オーバーライドのマークが付いていない関数をオーバーライドします。」

実装または拡張を介して新しいEventDispatcherを作成する場合、このオブジェクトに次のように追加の引数とメソッドを指定することもできます。

public function ListenerObject (v:View,m:Main) {
        dispatcher = new EventDispatcher(this);
        view = v;
        master = m;
    }
public function getView ():View {
        return view;
    }
public function getMain ():Main {
        return master;
    }

次に、コールバックメソッドでこれらのメソッドを次のように使用します。

public function callback(e:Event):void{
    e.target.getView ();
    //...
}
于 2012-05-08T10:08:01.543 に答える
1

独自のイベントを作成して他のクラスからディスパッチし、リスニング クラスでリッスンすることができます。ここにいくつかのコードがあります

クラス A (EventDispatcher を継承すると仮定)

public function classAMethod():void
{
   dispatchEvent(new Event("someCustomTypeForEvent"));
}

クラス B (クラス A への参照があると仮定)

public function classBMethod():void
{
   classA.addEventListener("someCustomTypeForEvent",customHandler);
}

public function customHandler(e:Event):void
{
   trace("handle event");
}
于 2012-05-07T16:27:28.753 に答える