0

我有两个类，derivedClassA它们derivedClassB都扩展了parentClass 我要声明var o:parentClass的内容，然后，根据发生的情况，我想将其转换o为 typederivedClassA或derivedClassB.

本质上，这是：

var o:parentClass  

...  

if(shouldUseA)  
    o = new derivedClassA();  
else  
    o = new derivedClassB();  
o.doSomething();

但它不起作用，我遇到了各种各样的错误。这不是类继承的工作原理吗？我觉得我错过了一些非常基本的东西，但我不知道是什么。我应该改用接口吗？还有另一种方法可以做我想做的事吗？

编辑澄清：
-doSomething()被定义parentClass为公共，并在派生类中override public function doSomething()
- 我得到的错误是“通过静态类型 parentClass 的引用调用可能未定义的方法 doSomething”。和“将 derviedClassA 类型的值隐式强制转换为不相关的类型 parentClass”

4

3 回答 3

1

我以前做过这个：在基类中的虚函数中抛出错误，在错误调用它时明显指出。当我制作抽象基类时，我会这样做。

Main.as（文档类）

package
{
    import flash.display.Sprite;

    public class Main extends Sprite
    {
        private var superClassRef:SuperClass;
        private var idLikeToBuyAnA:Boolean = true;

        public function Main()
        {
            trace("Main()");
            if (idLikeToBuyAnA)
            {
                superClassRef = new DerivedClassA();
            }
            else
            {
                superClassRef = new DerivedClassB();
            }

            superClassRef.doSomething();
        }
    }
}

超类.as

package
{
    public class SuperClass
    {
        public function SuperClass()
        {
        }

        public function doSomething():void
        {
            throw new Error("Override me, I wish I were virtual!");
        }
    }
}

派生类A.as

package
{
    public class DerivedClassA extends SuperClass
    {
        public function DerivedClassA()
        {
        }

        override public function doSomething():void
        {
            trace("I'm and A!");
        }
    }
}

派生类B.as

package
{
    public class DerivedClassB extends SuperClass
    {
        public function DerivedClassB()
        {
        }

        override public function doSomething():void
        {
            trace("I'm a B!");
        }
    }
}
于 2011-03-29T01:51:01.470 回答
0

你问的问题的具体答案是这样的：

o["doSomething"]();

但是，我不建议您这样做。我认为真正的问题是您的父类应该定义 doSomething()，然后派生类应该覆盖该函数。

于 2011-03-29T00:19:47.840 回答
0

我会做一个接口来做你所要求的。你不必强制转换变量，它会让你访问你的 doSomething 函数。这是一个使用您的结构的小示例：请注意，所有类都在同一个根包中，因此没有导入语句。

MainApp.as（这是默认应用程序）

package  
{
    import flash.display.Sprite;

    public class MainApp extends Sprite 
    {
        private var parentClass : IParent;
        private var doA : Boolean = false;

        public function MainApp()
        {

            if (doA)
            parentClass = new DerivedClassA();
            else
            parentClass = new DerivedClassB();

            parentClass.doSomething();
        }
    }
}

父级

package  
{
    import flash.display.Sprite;

    public class Parent extends Sprite
    {
        public function Parent()
        {
        }
    }
}

派生类A.as

package  
{
    public class DerivedClassA extends Parent implements IParent
    {
        public function DerivedClassA()
        {
            super();
        }

        public function doSomething() : void 
        {
            trace (this + " done something");
        }
    }
}

派生类B.as

package  
{
    public class DerivedClassB extends Parent implements IParent
    {
        public function DerivedClassB()
        {
            super();
        }

        public function doSomething() : void 
        {
            trace (this + " done something");
        }
    }
}

IParent.as

package  
{
    public interface IParent 
    {
        function doSomething():void;
    }
}

如您所见，使用接口，您调用函数 doSomething 而不进行强制转换。强制转换变量没有问题，但这可以为您提供更结构化的代码，并确保您在实现接口的类中有 doSomething 方法。希望它有帮助......运气好

于 2010-06-17T09:43:45.037 回答