Actionscript 3 在AS3中，假设每个库符号都链接到一个类，库符号是否可以扩展另一个库符号？

例如：

库符号“Card”链接到扩展了“MovieClip”的类“Card”。图书馆符号“卡片”包含卡片背景图像

图书馆符号“Ace”链接到类别“Ace”，该类别扩展了类别“卡片”。库符号“Ace”包含一个带有大号字母“a”的文本字段

所以我们有扩展MovieClip的Ace扩展卡。Ace因此扩展MovieClip，但不直接扩展MovieClip

当我把Ace的一个实例放在舞台上并编译剪辑时，所有显示的都是大号字母A。然而，我希望包括来自卡片的背景图像，因为Ace扩展了卡片，而卡片符号包含背景

---

Flash似乎忽略了符号内容，除非它属于正在实例化的顶级类。我认为一个符号不能扩展另一个符号是站不住脚的。当我编辑扩展它的Ace时，IDE可以很容易地将卡片绘制为不可编辑的背景，它应该实例化卡片的内容，然后在实例化Ace时实例化Ace的内容。想法？

你不能用程序化的方式来做这件事

相反，您必须使用Flash创作环境。通过创建一个包含基本符号的符号来扩展符号

---

而且，是的，我同意，这很差劲。

是的，我试过这么做。从理论上讲，您可能希望每个扩展类的显示列表都进行堆栈，但实际上并非如此——正如您所描述的那样，它可以正常工作，您只能看到与最新类相关联的图形

不过，它对您来说并不是一个破坏者——各种架构选项可供您选择。例如，您可以创建一个CardBackground类，该类从库中导出并具有卡片形状等。然后您可以创建一个具有background:CardBackground属性的卡片类。然后，你的Ace类可以扩展卡，它应该具有所需的背景

从技术上讲，你应该更喜欢组合而不是继承，但是Flash确实鼓励了继承思维。一旦你习惯了打破这种局面，你就会意识到，以所描述的方式使用组合来创建更强大、更健壮的类是可能的

---

干杯，我希望这有帮助

您的card\u mc（card movieclip）的基类可能是您的card类，但它不会使您的card类成为card\u mc的同义词

尝试这样做：

1） 创建一个包含卡片背景图像的movieclip，并将其命名为cardSprite_mc。给它命名为CardSprite，并将其基类设置为flash.display.Sprite

2） 创建一个包含包含字母“a”的文本字段的movieclip，并将其命名为ace_mc。给它一个类名Ace和一个基类com.cards.Ace

3） 使用以下代码创建名为Card的类：

package com.cards
{
    import flash.display.Sprite;

    public class Card extends Sprite
    {
        public function Card():void 
        {
            addChildAt(new CardSprite(), numChildren - 1);

        }// end function

    }// end class

}// end package

package com.cards
{
    import com.cards.Card;

    public class Ace extends Card
    {
        public function Ace():void 
        {

        }// end function

    }// end class

}// end package

4） 使用以下代码创建一个名为Ace的类：

package com.cards
{
    import flash.display.Sprite;

    public class Card extends Sprite
    {
        public function Card():void 
        {
            addChildAt(new CardSprite(), numChildren - 1);

        }// end function

    }// end class

}// end package

package com.cards
{
    import com.cards.Card;

    public class Ace extends Card
    {
        public function Ace():void 
        {

        }// end function

    }// end class

}// end package

现在，如果您将Ace实例添加到stage，您应该也会看到卡的背景图像

---

我希望这能有所帮助：）

Taurayi的解决方案很有启发性，因为它确定了类与符号之间缺少显式链接，从而确保符号的内容是实例化的，无论它是顶级类还是继承链中的基类。然而，这种方法的一个副作用是，它在卡片的内容中增加了一个额外的包含级别，即CardSprite容器

我已经设法实现了一个实用的通用解决方案，它实际上保留了所有继承符号的预期堆叠行为。例如，如果在下面的Symbol2实例上选中“numChildren”，它将恰好是Symbol1.numChildren和Symbol2.numChildren的总和，因此它是符号内容的真正合并堆栈

当您的符号位于继承链中时，只需在调用super（）方法后随时添加此“EnsureLink”调用

注意：不要忘记确保顶级符号也使用上述模式显式定义了一个类

当Symbol2和Symbol1链接到库中相应的符号时，它们的内容现在将堆叠起来。只需在舞台上放置一个Symbol2实例，然后测试电影。您将看到Symbol1的内容显示在Symbol2的内容下。（注意：不会出现在设计器中，因为这是一个运行时修复）

EnsureRelinkage的实施情况如下：

package
{
    import flash.utils.getQualifiedClassName;
    import flash.utils.getDefinitionByName;
    import flash.events.Event;

    public class BugFixes
    {

        public static var linkageMonitor:Object = new Object();
        private static var linkageMonitorAuthority:Array = new Array();

        public function BugFixes()
        {
        }

        public static function ensureLinkage( instance:*, className:String )
        {
            if (getQualifiedClassName( instance ) != className) //detect non-top-level construction
            {
                //prevent inevitable factorial-recursive construction
                var stack:Array = linkageMonitor[instance] as Array;
                if (stack == null)
                {
                    stack = new Array();
                    stack["numChildren"] = instance.numChildren;
                    linkageMonitor[instance] = stack;
                }

                var barredByAuthority:Boolean = false;
                if (linkageMonitorAuthority.length > 0)
                    barredByAuthority = (linkageMonitorAuthority[linkageMonitorAuthority.length - 1] as Array).indexOf( className ) > -1;
                if (stack.indexOf( className ) == -1 && !barredByAuthority)
                {
                    stack.push( className ); //remember construction
                    trace( "ensuring Linkage of inherited class " + className );

                    //perform top-level construction to trigger symbol linkage and child object instantiation
                    linkageMonitorAuthority.push( stack );
                    var temp:* = new (getDefinitionByName( className ) as Class)();
                    linkageMonitorAuthority.pop();

                    //Merge children
                    while (temp.numChildren > 0)
                        instance.addChild( temp.getChildAt( 0 ) );

                    //Merge properties
                    for (var prop:String in temp)
                        instance[prop] = temp[prop];
                }
                else
                {
                    trace( "skipping redundant construction of: " + className );
                }
            }
            else
            {
                var stack:Array = linkageMonitor[instance] as Array;
                if (stack != null)
                {
                    var nc:int = int(stack["numChildren"]);
                    trace("construction completing for " + getQualifiedClassName( instance ) );
                    for (var i:int = 0; i < nc; i++)
                        instance.setChildIndex( instance.getChildAt( 0 ), instance.numChildren - 1 );
                }
                delete linkageMonitor[instance]; //top-level constructor is completing, all relevant sub-objects have been constructed
            }
        }
    }
}

包
{
导入flash.utils.getQualifiedClassName；
导入flash.utils.getDefinitionByName；
导入flash.events.Event；
公共类错误修复
{
public static var linkageMonitor:Object=new Object（）；
私有静态var linkageMonitorAuthority:Array=newarray（）；
公共函数错误修复（）
{
}
公共静态函数EnsureLink（实例：*，类名：String）
{
if（getQualifiedClassName（实例）！=className）//检测非顶级构造
{
//防止不可避免的阶乘递归构造
var stack:Array=linkageMonitor[instance]作为数组；
if（stack==null）
{
stack=新数组（）；
堆栈[“numChildren”]=instance.numChildren；
linkageMonitor[实例]=堆栈；
}
var barredByAuthority:Boolean=false；
如果（linkageMonitorAuthority.length>0）
barredByAuthority=（linkageMonitorAuthority[linkageMonitorAuthority.length-1]作为数组）；
if（stack.indexOf（className）=-1&&！barredByAuthority）
{
stack.push（className）；//记住构造
跟踪（“确保继承类的链接”+类名）；
//执行顶级构造以触发符号链接和子对象实例化
linkageMonitorAuthority.pu