ActionScript 3.0 提供了四个特殊的属性来控制对在类中定义的属性的访问：public、private、protected 和 internal。

public 属性使某一属性在脚本的任何位置可见。例如，要使某个方法可用于包外部的代码，必须使用 public 属性声明该方法。这适用于任何属性，不管属性是使用 var、const 还是 function 关键字声明的。

private 属性使某一属性只对属性的定义类中的调用方可见。这一行为与 ActionScript 2.0 中的 private 属性有所不同，后者允许子类访问超类中的私有属性。另一处明显的行为变化是必须执行运行时访问。在 ActionScript 2.0 中，private 关键字只在编译时禁止访问，运行时很容易避开它。在 ActionScript 3.0 中，这种情况不复存在。标记为 private 的属性在编译时和运行时都不可用。

例如，下面的代码创建一个带一个私有变量的名为 PrivateExample 的简单类，然后尝试从该类的外部访问该私有变量。

class PrivateExample 
{ 
    private var privVar:String = "private variable"; 
} 
 
var myExample:PrivateExample = new PrivateExample(); 
trace(myExample.privVar);// compile-time error in strict mode 
trace(myExample["privVar"]); // ActionScript 2.0 allows access, but in ActionScript 3.0, this is a run-time error. 

在 ActionScript 3.0 中使用严格模式时，尝试使用点运算符 (myExample.privVar) 访问私有属性会导致编译时错误。否则，会在运行时报告错误，就像使用属性访问运算符 (myExample["privVar"]) 时一样。

下表汇总了试图访问属于密封（非动态）类的 private 属性的结果：

在使用 dynamic 属性声明的类中尝试访问私有变量不会导致运行时错误。但是，变量不可见，因此返回值 undefined。但是，如果在严格模式下使用点运算符，则会发生编译时错误。下面的示例与上一个示例相同，只是 PrivateExample 类被声明为动态类：

dynamic class PrivateExample 
{ 
    private var privVar:String = "private variable"; 
} 
 
var myExample:PrivateExample = new PrivateExample(); 
trace(myExample.privVar);// compile-time error in strict mode 
trace(myExample["privVar"]); // output: undefined

当类外部的代码尝试访问 private 属性时，动态类通常会返回值 undefined，而不是生成错误。下表说明了只有在严格模式下使用点运算符访问 private 属性时才会生成错误：

protected 属性是 ActionScript 3.0 中的新增属性，可使某一属性对于其所属类或子类中的调用方可见。换句话说，protected 属性在其所属类中可用，或者对继承层次中该类下面的类可用。无论子类在同一包中还是在不同包中，这一点都适用。

对熟悉 ActionScript 2.0 的人来说，本功能类似于 ActionScript 2.0 中的 private 属性。ActionScript 3.0 中的 protected 属性也类似于 Java 中的 protected 属性。不同之处在于 Java 版本还允许访问同一包中的调用方。如果存在子类需要的变量或方法，但要对继承链外部的代码隐藏该变量或方法，此时 protected 属性会很有用。

internal 属性是 ActionScript 3.0 的新增属性，可使某一属性对所在包中的调用方可见。该属性是包中代码的默认属性，它适用于任何没有以下任意属性的属性：

• public

• private

• protected

• 用户定义的命名空间

internal 属性与 Java 中的默认访问控制相似，不过，在 Java 中该访问级别没有明确的名称，只能通过省略所有其它访问修饰符来实现。ActionScript 3.0 中提供的 internal 属性旨在为您提供一个明确表达自己意图的选项，以使属性仅对所在包中的调用方可见。

static 属性可以与用 var、const 或 function 关键字声明的那些属性一起使用，使用该属性可将属性附加到类而不是类的实例。类外部的代码必须使用类名（而不是使用实例名）调用静态属性。

静态属性不由子类继承，但是这些属性是子类作用域链中的一部分。这意味着在子类体中，不必引用在其中定义静态变量或方法的类，就可以使用静态变量或方法。

作为预定义访问控制属性的替代方法，您可以创建自定义命名空间以用作属性。每个定义只能使用一个命名空间属性，而且不能将命名空间属性与任何访问控制属性（public、private、protected 和 internal）组合使用。

构造函数方法有时称为构造函数，是与在其中定义函数的类共享同一名称的函数。只要使用 new 关键字创建了类实例，就会执行构造函数方法中包括的所有代码。例如，以下代码定义名为 Example 的简单类，该类包含名为 status 的属性。status 变量的初始值是在构造函数中设置的。

class Example 
{ 
    public var status:String; 
    public function Example() 
    { 
        status = "initialized"; 
    } 
} 
 
var myExample:Example = new Example(); 
trace(myExample.status); // output: initialized

构造函数方法只能是公共方法，但可以选择性地使用 public 属性。不能对构造函数使用任何其它访问控制说明符（包括使用 private、protected 或 internal）。也不能对函数构造方法使用用户定义的命名空间。

构造函数可以使用 super() 语句显式地调用其直接超类的构造函数。如果未显式调用超类构造函数，编译器会在构造函数体中的第一个语句前自动插入一个调用。还可以使用 super 前缀作为对超类的引用来调用超类的方法。如果决定在同一构造函数中使用 super() 和 super，务必先调用 super()。否则，super 引用的行为会与预期不符。另外，super() 构造函数也应在 throw 或 return 语句之前调用。

下面的示例说明如果在调用 super() 构造函数之前尝试使用 super 引用，将会发生什么情况。新类 ExampleEx 扩展了 Example 类。ExampleEx 构造函数尝试访问在其超类中定义的状态变量，但访问是在调用 super() 之前进行的。ExampleEx 构造函数中的 trace() 语句生成了 null 值，原因是 status 变量在 super() 构造函数执行之前不可用。

class ExampleEx extends Example 
{ 
    public function ExampleEx() 
    { 
        trace(super.status); 
        super(); 
    } 
} 
 
var mySample:ExampleEx = new ExampleEx(); // output: null

虽然在构造函数中使用 return 语句是合法的，但是不允许返回值。换句话说，return 语句不得有相关的表达式或值。因此，不允许构造函数方法返回值，这意味着不可以指定任何返回值。

如果没有在类中定义构造函数方法，编译器会自动为您创建一个空构造函数。如果某个类扩展了另一个类，编译器会在所生成的构造函数中包括 super() 调用。

静态方法也叫做类方法，它们是使用 static 关键字声明的方法。静态方法附加到类而不是类的实例，因此在封装对单个实例的状态以外的内容有影响的功能时，静态方法很有用。由于静态方法附加到整个类，所以只能通过类访问静态方法，而不能通过类实例访问。

静态方法为封装所提供的功能不仅仅在影响类实例状态的方面。换句话说，如果方法提供的功能对类实例的值没有直接的影响，该方法应是静态方法。例如，Date 类具有名为 parse() 的静态方法，它接收字符串并将其转换为数字。该方法就是静态方法，因为它并不影响类的单个实例。而 parse() 方法使用表示日期值的字符串，分析该字符串，然后使用与 Date 对象的内部表示形式兼容的格式返回一个数字。此方法不是实例方法，因为将该方法应用到 Date 类的实例并没有任何意义。

请将静态 parse() 方法与 Date 类的一个实例方法（如 getMonth()）相比较。getMonth() 方法是一个实例方法，因为它通过检索 Date 实例的特定组件（即 month），对实例值直接执行操作。

由于静态方法不绑定到单个实例，因此不能在静态方法体中使用关键字 this 或 super。this 和 super 这两个引用只在实例方法上下文中有意义。

与其它基于类的编程语言不同，ActionScript 3.0 中的静态方法不是继承的。

实例方法指的是不使用 static 关键字声明的方法。实例方法附加到类实例而不是整个类，在实现对类的各个实例有影响的功能时，实例方法很有用。例如，Array 类包含名为 sort() 的实例方法，该实例方法直接对 Array 实例执行操作。

在实例方法体中，静态变量和实例变量都在作用域中，这表示使用一个简单的标识符可以引用同一类中定义的变量。例如，以下类 CustomArray 扩展了 Array 类。CustomArray 类定义一个名为 arrayCountTotal 的静态变量（用于跟踪类实例总数）、一个名为 arrayNumber 实例变量（用于跟踪创建实例的顺序）和一个名为 getPosition() 的实例方法（用于返回这两个变量的值）。

public class CustomArray extends Array 
{ 
    public static var arrayCountTotal:int = 0; 
    public var arrayNumber:int; 
 
    public function CustomArray() 
    { 
        arrayNumber = ++arrayCountTotal; 
    } 
     
    public function getArrayPosition():String 
    { 
         return ("Array " + arrayNumber + " of " + arrayCountTotal); 
    } 
}

虽然类外部的代码必须使用 CustomArray.arrayCountTotal 通过类对象来访问 arrayCountTotal 静态变量，但是位于 getPosition() 方法体中的代码可以直接引用静态 arrayCountTotal 变量。即使对于超类中的静态变量，这一点也适用。虽然在 ActionScript 3.0 中不继承静态属性，但是超类的静态属性在作用域中。例如，Array 类有几个静态变量，其中一个是名为 DESCENDING 的常量。位于 Array 子类中的代码可以使用一个简单的标识符来访问静态常量 DESCENDING：

public class CustomArray extends Array 
{ 
    public function testStatic():void 
    { 
        trace(DESCENDING); // output: 2 
    } 
}

实例方法体中的 this 引用的值是对方法所附加实例的引用。下面的代码说明 this 引用指向包含方法的实例：

class ThisTest 
{ 
    function thisValue():ThisTest 
    { 
        return this; 
    } 
} 
 
var myTest:ThisTest = new ThisTest(); 
trace(myTest.thisValue() == myTest); // output: true

使用关键字 override 和 final 可以控制实例方法的继承。可以使用 override 属性重新定义继承的方法，以及使用 final 属性禁止子类覆盖方法。

get 和 set 存取器函数还分别称为 getter 和 setter，可以使用这些函数为创建的类提供易于使用的编程接口，并遵循信息隐藏和封装的编程原则。使用 get 和 set 函数可保持类的私有类属性，但允许类用户访问这些属性，就像他们在访问类变量而不是调用类方法。

这种方法的好处是，可避免出现具有不实用名称的传统存取器函数，如 getPropertyName() 和 setPropertyName()。getter 和 setter 的另一个好处是，使用它们可避免允许进行读写访问的每个属性有两个面向公共的函数。

下面的示例类名为 GetSet，其中包含名为 publicAccess() 的 get 和 set 存取器函数，用于提供对名为 privateProperty 的私有变量的访问：

class GetSet 
{ 
    private var privateProperty:String; 
     
    public function get publicAccess():String 
    { 
        return privateProperty; 
    } 
     
    public function set publicAccess(setValue:String):void 
    { 
        privateProperty = setValue; 
    } 
}

如果尝试直接访问属性 privateProperty，将发生错误，如下所示：

var myGetSet:GetSet = new GetSet(); 
trace(myGetSet.privateProperty); // error occurs

GetSet 类的用户所使用的对象是显示为名为 publicAccess 的属性，但实际上这是对名为 privateProperty 的 private 属性执行的一对 get 和 set 取值函数。下面的示例将实例化 GetSet 类，然后使用名为 publicAccess 的公共存取器设置 privateProperty 的值：

var myGetSet:GetSet = new GetSet(); 
trace(myGetSet.publicAccess); // output: null 
myGetSet.publicAccess = "hello"; 
trace(myGetSet.publicAccess); // output: hello

使用 getter 和 setter 函数还可以覆盖从超类继承来的属性，这是使用常规类成员变量时不能做到的。在子类中不能覆盖使用 var 关键字声明的类成员变量。但是，使用 getter 和 setter 函数创建的属性没有此限制。可以对从超类继承的 getter 和 setter 函数使用 override 属性。

绑定方法有时也叫做闭包方法，就是从它的实例提取的方法。作为参数传递给函数的方法或作为值从函数返回的方法都是绑定方法。在 ActionScript 3.0 中，新增的绑定方法类似于闭包函数，其中保留了词汇环境，即使从其实例中提取出来也是如此。绑定方法与闭包函数之间的主要不同差别是，绑定函数的 this 引用保留到实现方法的实例的链接或绑定。换句话说，绑定方法中的 this 引用总是指向实现方法的原始对象。对于闭包函数，this 引用是通用的，这意味着调用函数时，该引用指向与函数关联的任何对象。

如果使用 this 关键字，了解绑定方法就很重要。重新调用 this 关键字可提供对方法父对象的引用。大多数 ActionScript 编程人员都希望 this 关键字总是表示包含方法定义的对象或类。但是，如果不使用方法绑定，并不是总是做到这样。例如，在以前版本的 ActionScript 中，this 引用并不总是引用实现方法的实例。从 ActionScript 2.0 的实例中提取方法后，不但 this 引用不绑定到原始实例，而且实例类的成员变量和方法也不可用。在 ActionScript 3.0 中不存在这样的问题，这是因为将方法当作参数传递时会自动创建绑定方法。绑定方法用于确保 this 关键字总是引用在其中定义了方法的对象或类。

下面的代码定义了名为 ThisTest 的类，该类包含一个名为 foo() 的方法（该方法定义绑定方法）和一个名为 bar() 的方法（该方法返回绑定方法）。类外部的代码创建 ThisTest 类的实例，然后调用 bar() 方法，最后将返回值存储在名为 myFunc 的变量中。

class ThisTest 
{ 
    private var num:Number = 3; 
    function foo():void // bound method defined 
    { 
        trace("foo's this: " + this); 
        trace("num: " + num); 
    } 
    function bar():Function 
    { 
        return foo; // bound method returned 
    } 
} 
 
var myTest:ThisTest = new ThisTest(); 
var myFunc:Function = myTest.bar(); 
trace(this); // output: [object global] 
myFunc(); 
/* output:  
foo's this: [object ThisTest] 
output: num: 3 */

代码的最后两行表明：虽然前一行中的 this 引用指向全局对象，但绑定方法 foo() 中的 this 引用仍然指向 ThisTest 类的实例。另外，存储在 myFunc 变量中的绑定方法仍然可以访问 ThisTest 类的成员变量。如果以上代码在 ActionScript 2.0 中运行，this 引用会匹配，但 num 变量将为 undefined。

绑定方法最值得注意的一种情况是使用事件处理函数，因为 addEventListener() 方法要求将函数或方法作为参数来传递。

要嵌入资源，首先将该资源放入 FLA 文件的库中。接着，使用资源的链接属性，提供资源的嵌入资源类的名称。如果无法在类路径中找到具有该名称的类，则将自动生成一个类。然后，可以创建嵌入资源类的实例，并使用任何由该类定义或继承的属性和方法。例如，以下代码可用于播放链接到名为 PianoMusic 的嵌入资源类的嵌入声音：

var piano:PianoMusic = new PianoMusic(); 
var sndChannel:SoundChannel = piano.play();

还可使用 [Embed] 元数据标签在 Flash Professional 项目中嵌入资源，如下面所述。如果在代码中使用 [Embed] 元数据标签，Flash Professional 将使用 Flex 编译器而非 Flash Professional 编译器编译您的项目。

如果您正在使用 Flex 编译器编译代码，可使用 [Embed] 元数据标签将资源嵌入到 ActionScript 代码中。将资源放置在项目生成路径中的主资源文件夹或其它文件夹中。当 Flex 编译器遇到 Embed 元数据标签时，会创建嵌入资源类。通过紧接 [Embed] 元数据标签之后声明的数据类型 Class 的变量，可以访问该资源类。例如，下面的代码嵌入名为 sound1.mp3 的声音，使用名为 soundCls 的变量来存储对该声音的关联嵌入资源类的引用。然后，该示例创建嵌入资源类的实例，并对该实例调用 play() 方法：

package 
{ 
    import flash.display.Sprite; 
    import flash.media.SoundChannel; 
    import mx.core.SoundAsset; 
 
    public class SoundAssetExample extends Sprite 
    { 
        [Embed(source="sound1.mp3")] 
        public var soundCls:Class; 
         
        public function SoundAssetExample() 
        { 
            var mySound:SoundAsset = new soundCls() as SoundAsset; 
            var sndChannel:SoundChannel = mySound.play(); 
        } 
    } 
}