Question

我有两个类derivedClassA和derivedClassB，它们都扩展为parentClass 我宣布var o:parentClass然后，根据发生的情况，我想将o强制转换为derivedClassA或derivedClassB类型。

基本上，这个：

var o:parentClass  

...  

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

但是它没有用，我遇到了各种各样的错误。这不是类继承如何工作？我觉得我错过了一些非常基本的东西，但我无法弄清楚是什么。我应该使用接口吗？还有另一种做我想做的事吗？

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

Answer 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();
        }
    }
}

<强> SuperClass.as

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

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

<强> DerivedClassA.as

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

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

<强> DerivedClassB.as

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

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

Answer 2

我会建立一个界面，以便能够做你想要的。这样您就不必转换变量了，它可以让您访问doSomething函数。以下是使用您的结构的一个小示例：请注意，所有类都在同一个根包中，因此没有import语句。

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();
        }
    }
}

<强> Parent.as

package  
{
    import flash.display.Sprite;

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

<强> DerivedClassA.as

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

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

<强> DerivedClassB.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方法。希望能帮助到你... 祝你好运

Answer 3

您提出的问题的具体答案是：

o["doSomething"]();

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

在兄弟级别之间进行投射，AS3

3 个答案: