主swf与子swf文件的参数传递

parent.swf 加载 son.swf.在parent.swf中当击按钮 时，发送一个事件 ，son.swf如何监听这个事件呢？
    我想到的解决方法是，建立一个公共事件

没有数据的话 直接dispatchEvent(new Event("fuck"));
有数据的话提供一个接口比较好 因为使用自定义事件的话  即使是同一个事件类 在2个swf编译出来也是不同的

     就比如 你自定义了一个OKEvent 然后在parent项目中使用他
并且在child项目中也使用他 那么当你企图在parent中发送一个FuckEvent给Child时 会发现这二者是不同的事件

     event是比较好的方法, 这样也不会影响单个影片的伸展适应性

     二个swf里都加单列类,就可以通过改变或添加属性来传递变量

 

as3的单例模式有两种实现方式

方式一：直接在构造函数里赋_instance值

package

{

public class MyClass

{

private static var _instance:MyClass;

public function MyClass()

{

_instance = this;

}



public static function getInstance():MyClass

{

return _instance;

}



}

}

方式二：常用的在getInstance()里根据需要才给_instance赋值

package

{

public class MyClass

{

private static var _instance:MyClass;

public function MyClass()

{

}



public static function getInstance():MyClass

{

if(_instance == null){

_instance = new MyClass();

}

return _instance;

}



}

}

 

 

单例类：

package com.tradow.errors

{       

        /**

         * 类的单例，当第二次实例化时，抛出这个错误.         

         */

        public class InstanceError extends Error

        {

                public static const CONSTRUCTOR_ERROR:String = "ERROR: 只能实例化一次.";                       

 

                public function InstanceError(message:String="", id:int=0)

                {   

                        super(message, id);

                }

        }

}

 

类InstanceEnforcer

package com.tradow.utils

{

 

        import com.tradow.errors.InstanceError;

 

        public class InstanceEnforcer

        {

                private static var num:uint;

                public static function enforceConstructor():void {

                        num++;

                        if (num >= 2) {

                                throw (new InstanceError(InstanceError.CONSTRUCTOR_ERROR));

                        }

                }               

        }

}

例子：

package com.tradow.event.mouse{

        import flash.events.EventDispatcher;

        import flash.display.DisplayObjectContainer;

        import flash.events.MouseEvent;

        import flash.ui.Mouse;

        import com.tradow.utils.InstanceEnforcer;

        final public class PressMouse extends EventDispatcher{

                 public function PressMouse(){

                   //只实例化一次

                            InstanceEnforcer.enforceConstructor();                       

                         }

 

                public static function instance():PressMouse{

                        return new PressMouse();

                }

}

 

 

抽象类：

package

{

import flash.errors.IllegalOperationError;

public class MyAbstractType

{

    public function MyAbstractType(self:MyAbstractType)

    {

        if(self != this)

        {

            //这样就只有该类的子类中能传入当前实例的引用 抛出错误

         trace("定义错误");

        }

    }

}

}

这时候如果 在外部 new MyAbstractType(); ，传入任何参数运行时都会抛出异常,只有在该类和该类的子类内部可以传入当前对象的引用，即 this。间接的起到了抽象类的作用。

package com.joshtynjala.abstract

{

public class MyConcreteType extends MyAbstractType

{

    public function MyConcreteType()

    {

        //传入 "this" 来通过抽象类的检查

        super(this);

    }

}

}