继承

对于实例属性，无论是使用 function 、 var ，还是 const 关键字定义，只要在基类中未使用 private 属性进行声明，就可以由子类继承。例如，ActionScript 3.0 中的 Event 类具有许多子类，它们继承了所有事件对象共有的属性。

对于某些类型的事件，Event 类包含了定义事件所需的所有属性。这些类型的事件不需要 Event 类中定义的实例属性以外的实例属性。 complete 事件和 connect 事件就是这样的事件，前者在成功加载数据时发生，后者在建立网络连接时发生。

下面的示例是从 Event 类中摘录的，显示由子类继承的某些属性和方法。由于继承了属性，因此任何子类的实例都可以访问这些属性。

public class Event 
{ 
    public function get type():String; 
    public function get bubbles():Boolean; 
    ... 
 
    public function stopPropagation():void {} 
    public function stopImmediatePropagation():void {} 
    public function preventDefault():void {} 
    public function isDefaultPrevented():Boolean {} 
    ... 
}

其他类型的事件需要 Event 类中没有提供的特有属性。这些事件是使用 Event 类的子类定义的，所以可向 Event 类中定义的属性添加新属性。MouseEvent 类就是这样的一个子类，它可添加与鼠标移动或鼠标单击相关的事件的特有属性，如 mouseMove 和 click 事件。下面的示例是从 MouseEvent 类中摘录的，它说明了在子类中存在但在基类中不存在的属性的定义：

public class MouseEvent extends Event 
{ 
    public static const CLICK:String= "click"; 
    public static const MOUSE_MOVE:String = "mouseMove"; 
    ... 
 
    public function get stageX():Number {} 
    public function get stageY():Number {} 
    ... 
}

// Base.as in a folder named foo 
package foo 
{ 
    public class Base 
    { 
        public var str:String = "hello"; // change public on this line 
    } 
} 
 
// Extender.as in a folder named bar 
package bar 
{ 
    import foo.Base; 
    public class Extender extends Base 
    { 
        public function getString():String { 
            return str; 
        } 
    } 
} 
 
// main application class in file named AccessControl.as 
package 
{ 
    import flash.display.MovieClip; 
    import bar.Extender; 
    public class AccessControl extends MovieClip 
    { 
        public function AccessControl() 
        { 
            var myExt:Extender = new Extender(); 
            trace(myExt.str);// error if str is not public 
            trace(myExt.getString()); // error if str is private or internal 
        } 
    } 
}

trace(myExt.str);// error if str is not public

覆盖方法表示重新定义已继承方法的行为。静态方法不能继承，也不能覆盖。但是，实例方法可由子类继承，也可覆盖，只要符合以下两个条件：

• 实例方法在基类中不是使用 final 关键字声明的。当 final 关键字与实例方法一起使用时，该关键字指明程序员的设计目的是要禁止子类覆盖方法。

• 实例方法在基类中不是使用 private 访问控制说明符声明的。如果某个方法在基类中标记为 private ，则在子类中定义同名方法时不需要使用 override 关键字，因为基类方法在子类中不可见。

  要覆盖符合这些条件的实例方法，子类中的方法定义必须使用 override 关键字，且必须在以下几个方面与方法的超类版本相匹配：

• 覆盖方法必须与基类方法具有相同级别的访问控制。标记为内部的方法与没有访问控制说明符的方法具有相同级别的访问控制。

• 覆盖方法必须与基类方法具有相同的参数数。

• 覆盖方法参数必须与基类方法参数具有相同的数据类型注释。

• 覆盖方法必须与基类方法具有相同的返回类型。

但是，覆盖方法中的参数名不必与基类中的参数名相匹配，只要参数数和每个参数的数据类相匹配即可。

package { 
    import flash.display.MovieClip; 
    public class SuperExample extends MovieClip 
    { 
        public function SuperExample() 
        { 
            var myExt:Extender = new Extender() 
            trace(myExt.thanks()); // output: Mahalo nui loa 
        } 
    } 
} 
 
class Base { 
    public function thanks():String 
    { 
        return "Mahalo"; 
    } 
} 
 
class Extender extends Base 
{ 
    override public function thanks():String 
    { 
        return super.thanks() + " nui loa"; 
    } 
}

package 
{ 
    import flash.display.MovieClip; 
    public class OverrideExample extends MovieClip 
    { 
        public function OverrideExample() 
        { 
            trace(currentLabel) 
        } 
        override public function get currentLabel():String 
        { 
            var str:String = "Override: "; 
            str += super.currentLabel; 
            return str; 
        } 
    } 
}

静态属性不由子类继承。这意味着不能通过子类的实例访问静态属性。只能通过定义静态属性的类对象来访问静态属性。例如，以下代码定义了名为 Base 的基类和扩展名为 Extender 的 Base 子类。Base 类中定义了名为 test 的静态变量。以下摘录中编写的代码在严格模式下不会进行编译，在标准模式下会生成运行时错误。

package { 
    import flash.display.MovieClip; 
    public class StaticExample extends MovieClip 
    { 
        public function StaticExample() 
        { 
            var myExt:Extender = new Extender(); 
            trace(myExt.test);// error 
        } 
    } 
} 
 
class Base { 
    public static var test:String = "static"; 
} 
 
class Extender extends Base { }

访问静态变量 test 的唯一方式是通过类对象，如以下代码所示：

Base.test;

但允许使用与静态属性相同的名称定义实例属性。可以在与静态属性相同的类中或在子类中定义这样的实例属性。例如，以上示例中的 Base 类可以具有一个名为 test 的实例属性。在以下代码中，由于 Extender 类继承了实例属性，因此代码能够进行编译和执行。如果 test 实例变量的定义移到（不是复制）Extender 类，该代码也会编译并执行。

package 
{ 
    import flash.display.MovieClip; 
    public class StaticExample extends MovieClip 
    { 
        public function StaticExample() 
        { 
            var myExt:Extender = new Extender(); 
            trace(myExt.test);// output: instance 
        } 
    } 
} 
 
class Base 
{ 
    public static var test:String = "static"; 
    public var test:String = "instance"; 
} 
 
class Extender extends Base {}

虽然并不继承静态属性，但是静态属性在定义它们的类或该类的任何子类的作用域链中。同样，可以认为静态属性在定义它们的类和任何子类的 作用域 中。这意味着在定义静态属性的类体及该类的任何子类中可直接访问静态属性。

下面的示例对上一个示例中定义的类进行了修改，以说明 Base 类中定义的 test 静态变量在 Extender 类的作用域中。换句话说， Extender 类可以访问 test 静态变量，而不必用定义 test 的类名作为变量的前缀。

package 
{ 
    import flash.display.MovieClip; 
    public class StaticExample extends MovieClip 
    { 
        public function StaticExample() 
        { 
            var myExt:Extender = new Extender(); 
        } 
    } 
} 
 
class Base { 
    public static var test:String = "static"; 
} 
 
class Extender extends Base 
{ 
    public function Extender() 
    { 
        trace(test); // output: static 
    } 
     
}

如果使用与同类或超类中的静态属性相同的名称定义实例属性，则实例属性在作用域链中的优先级比较高。因此认为实例属性 遮蔽 了静态属性，这意味着会使用实例属性的值，而不使用静态属性的值。例如，以下代码显示如果 Extender 类定义名为 test 的实例变量， trace() 语句将使用实例变量的值，而不使用静态变量的值：

package 
{ 
    import flash.display.MovieClip; 
    public class StaticExample extends MovieClip 
    { 
        public function StaticExample() 
        { 
            var myExt:Extender = new Extender(); 
        } 
    } 
} 
 
class Base 
{ 
    public static var test:String = "static"; 
} 
 
class Extender extends Base 
{ 
    public var test:String = "instance"; 
    public function Extender() 
    { 
        trace(test); // output: instance 
    } 
     
}