1

这是我的代码行：

  new (getDefinitionByName(String( "mypackage.MyDynamicClass"  )) as Class) ;

这会产生一个错误： mypackage.MyDynamicClass 未定义。

我用谷歌搜索并找到了一个解决方案：在导入语句中使用类的名称。

所以，

  import mypackage.MyDynamicClass 
  new (getDefinitionByName(String( "mypackage.MyDynamicClass"  )) as Class) ;

有效！！！

但是，我对这个解决方案并不满意，因为它确实违反了动态类的好处。如果我知道类的名称（在 import 中），那么为什么我会将它用作字符串？

使动态加载类起作用的任何替代方法？

维什瓦斯

4

3 回答 3

5

看看这篇文章： http: //blogs.adobe.com/cantrell/archives/2010/09/loading-classes-dynamically-in-actionscript-3.html 你不能避免在运行时包含你需要的类。您可以随时使用：

import mypackage.*

请注意，在包中包含所有类可能会增加代码大小。

于 2013-01-10T16:40:55.090 回答
3

它绝对不会违反 Class 的动态加载，因为我们的编译器会在我们的项目中检测到未使用的 class/import 语句，然后删除那些打包为 swc 或 swf 的类文件，这样我们最终输出文件大小的优势就可以减少。

除非几次无法减小文件大小。

在确保该类可用之前，您可能知道要通过 getDefinitionByName() 加载的类是什么IncludeClass.as

为了更好的方式，您可以为您的项目导入语句

package
{
    public class IncludeClasses
    {
        import com.abc.db.Database; Database;
        import com.abc.RemoteLogTarget; RemoteLogTarget;
        import com.abc.LocalLogTarget; LocalLogTarget;
        import com.abc.exception.GlobalExceptionHandler; GlobalExceptionHandler;
        import com.abc.utils.NetConnectionMonitor; NetConnectionMonitor;
    }
}

如果您想更好地使用您的方式，您可以尝试使用编译器选项。

于 2013-01-05T07:55:10.697 回答
2

我建议您使用抽象工厂 http://en.wikipedia.org/wiki/Abstract_factory_pattern 它是一种非常灵活的方式来创建对象，而无需知道您将要实例化哪个类。

在这个抽象工厂类中，您需要导入您可能从中创建对象的所有类，这不需要您在主类中导入所有类，但您仍然需要导入抽象工厂和接口以进行通信与您的新对象。

这是一个简单的例子：

/*
The interface you will use to communicate with your objects
*/
InterfaceForAllMyClasses.as
public interface InterfaceForAllMyClasses
{
    public function callMe();
    public function callMe2();
}

/*
Your Classes wich implement the interface
*/
Class1.as
import mypackage.InterfaceForAllMyClasses;
public class Class1 implements InterfaceForAllMyClasses
{
    public function callMe() { trace("called Class1"); }
    public function callMe2() { trace("called Class1 too"); }
}

Class2.as
import mypackage.InterfaceForAllMyClasses;
public class Class1 implements InterfaceForAllMyClasses
{
    public function callMe() { trace("called Class2"); }
    public function callMe2() { trace("called Class2 too"); }
}

/*
The Abstract Factory
*/
AbstractFactory.as
import mypackage.InterfaceForAllMyClasses;
public class AbstractFactory
{
    public function giveMeObject(classNumber:Number):InterfaceForAllMyClasses
    {
        switch(classNumber)
        {
            case 0: return(new Class1()); break;
            case 1: return(new Class2()); break;
            // for any new class that you add you must add a case entry here
        }
    }
}

/*
Your Program
*/
import mypackage.InterfaceForAllMyClasses;
import mypackage.AbstractFactory;
MyProgram.as
public class MyProgram
{
    var abstractFactory:AbstractFactory = new AbstractFactory();

    public function main()
    {
        var x:InterfaceForAllMyClasses=AbstractFactory.giveMeObject(0);
        var y:InterfaceForAllMyClasses=AbstractFactory.giveMeObject(1);

        x.callMe();
        x.callMe2();
        y.callMe();
        y.callMe2();        
    }
}

如果您无法从主应用程序中导入这些类，因为它们是在外部模块 (swfs) 中声明的，那么您可以将每个模块设为抽象工厂，这是一个示例：

Interfaces/IModuleInterface.as

package Interfaces
    {
        public interface IModuleInterface
        {
            function giveMeObject(classNumber:Number):IObjectInterface;
        }
    }

Interfaces/IObjectInterface.as

package Interfaces
    {
        public interface IObjectInterface
        {
            function callMe():void;
            function callMeToo():void;
        }
    }

Modules/ModuleOne.mxml

    <?xml version="1.0" encoding="utf-8"?>
    <s:Module xmlns:fx="http://ns.adobe.com/mxml/2009" 
      xmlns:s="library://ns.adobe.com/flex/spark" 
      xmlns:mx="library://ns.adobe.com/flex/mx" width="400" height="300"         implements="Interfaces.IModuleInterface">
        <fx:Script>
            <![CDATA[
                import Interfaces.IObjectInterface;
                public function giveMeObject(classNumber:Number):IObjectInterface
                {
                    switch(classNumber)
                    {
                        case 1:
                            trace("ModuleOne: Instantiating 1");
                            return(new ModuleOneClassOne()); 
                            break;
                        case 2:
                            trace("ModuleOne: Instantiating 2");
                            return(new ModuleOneClassTwo()); 
                            break;
                    }
                    return(null);
                }
            ]]>
        </fx:Script>
        <fx:Declarations>
            <!-- Place non-visual elements (e.g., services, value objects) here -->
        </fx:Declarations>
        <s:Label x="10" y="10" text="Module One Loaded"/>
    </s:Module>

Modules/ModuleOneClassOne.as

    package Modules
    {
        import Interfaces.IObjectInterface;

        public class ModuleOneClassOne implements IObjectInterface
        {
            public function ModuleOneClassOne()
            {
                trace("ModuleOneClassOne: Instantiated");
            }

            public function callMe():void
            {
                trace("ModuleOneClassOne: called callMe()");
            }

            public function callMeToo():void
            {
                trace("ModuleOneClassOne: called callMeToo()");
            }
        }
    }

Modules/ModuleOneClassTwo.as

    package Modules
    {
        import Interfaces.IObjectInterface;

        public class ModuleOneClassTwo implements IObjectInterface
        {
            public function ModuleOneClassTwo()
            {
                trace("ModuleOneClassTwo: Instantiated");
            }

            public function callMe():void
            {
                trace("ModuleOneClassTwo: called callMe()");
            }

            public function callMeToo():void
            {
                trace("ModuleOneClassTwo: called callMeToo()");
            }
        }
    }

AbstractFactoryInModules.mxml

    <?xml version="1.0" encoding="utf-8"?>
    <s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009"
                   xmlns:s="library://ns.adobe.com/flex/spark"
                   xmlns:mx="library://ns.adobe.com/flex/mx"
                   width="345" height="200">

        <fx:Script>
            <![CDATA[
                import Interfaces.IModuleInterface;
                import Interfaces.IObjectInterface;

                import mx.events.ModuleEvent;
                protected var module:IModuleInterface;
                protected var object:IObjectInterface;

                protected function ButtonLoadSwf_clickHandler(event:MouseEvent):void
                {
                    loader.unloadModule();
                    loader.url=moduleUrl.text;
                }

                protected function loader_readyHandler(event:ModuleEvent):void
                {
                    this.module = (loader.child) as IModuleInterface;
                }

                protected function ButtonCreateObject_clickHandler(event:MouseEvent):void
                {
                    this.object = this.module.giveMeObject(Number(TClassNumber.text));
                }

                protected function BCallMe_clickHandler(event:MouseEvent):void
                {
                    this.object.callMe();
                }

                protected function BCallMeToo_clickHandler(event:MouseEvent):void
                {
                    this.object.callMeToo();
                }
            ]]>
        </fx:Script>

        <fx:Declarations>
            <!-- Place non-visual elements (e.g., services, value objects) here -->
        </fx:Declarations>
        <s:Button id="ButtonLoadSwf" x="236" y="10" width="99" label="Load SWF"
                  click="ButtonLoadSwf_clickHandler(event)"/>
        <s:Button id="ButtonCreateObject" x="150" y="108" label="Create Object"
                  click="ButtonCreateObject_clickHandler(event)"/>
        <s:TextInput id="TClassNumber" x="96" y="107" width="46" text="1"/>
        <s:ModuleLoader x="10" y="39" width="325" height="60" id="loader" ready="loader_readyHandler(event)">
        </s:ModuleLoader>
        <s:TextInput id="moduleUrl" x="10" y="10" width="218" text="Modules/ModuleOne.swf"/>
        <s:Button id="BCallMe" x="96" y="137" width="150" label="callMe"
                  click="BCallMe_clickHandler(event)"/>
        <s:Button id="BCallMeToo" x="96" y="166" width="150" label="callMeToo"
                  click="BCallMeToo_clickHandler(event)"/>
    </s:WindowedApplication>
于 2013-01-14T14:03:58.453 回答