AS3从父类引用子类的子类而不实例化？

Question

我可以访问子类的子类的静态变量吗？我不想实例化它，只是想获取变量，因为它已经由子类初始化了。

例如：

package
{
    public class A extends MovieClip {
        private var classB:B = new B();

        public function A() {
            //**ACCESS B.C.MYVAR**
        }
    }
}

package
{
    public class B extends MovieClip {
        private var classC:C = new C();
    }
}

package
{
    public class C extends MovieClip {

        public static var MYVAR = 1;
    }
}

谢谢！

Answer 1

要访问 public static var，您可以通过 Class.property 从同一包中的任何位置执行此操作。

因此，要访问 C 类中定义的 MYVAR，您可以使用 C.MYVAR。

您不需要创建类的实例来访问其中的静态属性或函数 - 只要它们是公共的即可。

我不建议使用静态，除非在极少数情况下，例如“实用程序”类或类似的东西。一个很好的例子是内置的 Math 类。

我主要在保存常量的类中使用 static ，就像这个例子：

package
{
    public class Elements
    {
        public static const FIRE:String = "FIRE_ELEMENT";
        public static const WATER:String = "WATER_ELEMENT";
        public static const ICE:String = "ICE_ELEMENT";
    }
}

然后我像这样使用它：

var myelement:String = Elements.WATER;

Answer 2

这个问题的答案已经被接受，但我的回答是为了回应蒂姆·乔伊斯在对已接受答案的评论中提出的问题：

谢谢你的回答，马蒂，什么
关于从 C 调用公共变量
不是静态的吗？这可能吗？什么
我有一个从 B 发送的事件
让我知道 C 改变了，但我
需要检索C中的变量
事件派发时从 A 开始。
伙计，我希望你能明白什么
我刚刚写了。

以下是我为回答该问题而创建的一个小型 Flash 应用程序：

package 
{
    import flash.display.Sprite;
    import flash.events.Event;

    public class Main extends Sprite 
    {
        private var _popcornMicrowave:PopcornMicrowave;

        public function Main():void 
        {
            if (stage) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);

        }// end function

        private function init(e:Event = null):void 
        {
            removeEventListener(Event.ADDED_TO_STAGE, init);

            // 1 minute and 30 seconds
            var delay:Number = PopcornMicrowave.MINUTE + (PopcornMicrowave.SECOND * 30);

            _popcornMicrowave = new PopcornMicrowave(delay);

            trace(_popcornMicrowave.popcorn.isReady); // output: false

            _popcornMicrowave.startTimer();

            _popcornMicrowave.addEventListener(Event.COMPLETE, onPopcornMicrowaveComplete);

        }// end function

        private function onPopcornMicrowaveComplete(e:Event):void
        {
            _popcornMicrowave.removeEventListener(Event.COMPLETE, onPopcornMicrowaveComplete);

            trace(_popcornMicrowave.popcorn.isReady) // output: true

        }// end function

    }// end class

}// end package

import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.TimerEvent;
import flash.utils.Timer;

internal class PopcornMicrowave extends EventDispatcher
{
    public static const SECOND:Number = 1000;
    public static const MINUTE:Number = SECOND * 60;

    private var _popcorn:Popcorn;
    private var _timer:Timer;

    public function get popcorn():Popcorn { return _popcorn }

    public function PopcornMicrowave(delay:Number = MINUTE) 
    { 
        _popcorn = new Popcorn();
        _timer = new Timer(delay, 1);

    }// end function

    public function startTimer():void
    {
        if (!_timer.running)
        {
            _timer.addEventListener(TimerEvent.TIMER_COMPLETE, onTimerComplete);
            _timer.start(); 

        }// end if

    }// end function

    private function onTimerComplete(e:TimerEvent):void
    {
        _timer.removeEventListener(TimerEvent.TIMER_COMPLETE, onTimerComplete);

        _popcorn.setIsReady(true);

        dispatchEvent(new Event(Event.COMPLETE));

    }// end function

}// end class

internal class Popcorn
{
    private var _isReady:Boolean;

    public function get isReady():Boolean { return _isReady }

    public function Popcorn() { }

    internal function setIsReady(boolean:Boolean):void 
    { 
        _isReady = boolean 

    }// end function

}// end class

Answer 3

静态变量可以轻松地从任何地方引用。无论它是访问其子类之一的超类（或子子类...类），还是依赖于相关静态变量的完全不同的类，您都可以通过以下方式访问它：

public function someFunction():void {
  //Direct Access: Most typical way - accessing a public static var / const,
  //your local-variable should match the data-type of the static
  //variable you're accessing.
  var localVar:String = ClassName.StaticVarName;

  //Dynamic Access: An alternative that can be handy for verifying
  //variables that exists, and then use them once confirmed:
  if(ClassName["StaticVarName"]!=null) {
     trace("Found value: " + ClassName["StaticVarName"]);
  }

  //Iterative Access: If you're looking to iterate through each static
  //variables of a certain class, you can collect those by accessing its
  //description XML document (E4X access that is).
  var classDescription:XML = describeType(ClassName);
  var classVarNames:XMLList =    classDescription.variable.attribute("name");
  for each(var classVarName:String in classVarNames) {
     trace("Found class var: " + classVarName);
  }
}

现在，在为了访问隐藏在类层次结构中几层的实例变量，您可以尝试如下操作：

// File: A.as
package {
    public class A {
        public function A() {

        }

        public function doSomething():void {
            switch(Object(this).constructor) {
                case B: trace( B(this).methodOnlyInB() ); break;
                case C: trace( C(this).variableOnlyInC ); break;
                default: trace("You are simply in 'A'!"); break;
            }
        }
    }
}

// File: B.as
package {
    public class B extends A {
        public function B() {
            super();
        }

        public function methodOnlyInB():String {
            return "You are calling a 'B' method!";
        }
    }
}

// File: C.as
package {
    public class C extends B {
        public var variableOnlyInC:String = "You are tracing a 'C' variable";

        public function C() {
            super();
        }
    }
}

// File: TestABC.as
var a:A = new A();
var b:B = new B();
var c:C = new C();

a.doSomething();  //Should trace: You are simply in 'A'!
b.doSomething();  //Should trace: You are calling a 'B' method!
c.doSomething();  //Should trace: You are tracing a 'C' variable!

沿着这条路线走下去有一点“问题”。这会让你写出“糟糕的代码”。超类不应该知道它的任何子类业务以及它们在某些条件下应该做什么。这是几乎所有编程设计模式都试图鼓励的规则（并且有充分的理由），从长远来看，违反这条规则可能会花费大量的时间、精力和麻烦。

像这样的情况需要“Controller”类。基本上，从其他地方实例化的类将负责分析 A/B/C 对象（例如：类似于 A.doSomething() 的 switch 语句执行此操作的方式）。这可以释放您的 Super &子类避免了混乱，并为扩展和可靠的代码留下了更多的空间。

希望这能满足您所有的变量访问需求！ :)