从基础开始深入学Flash AS3教程(7)(译文)

package {
class MyClass {
function MyClass() {
var helper:MyHelper = new MyHelper();
}
}
}
class MyHelper {
function MyHelper() {
var helper:HelpersHelper = new HelpersHelper();
}
}
class HelpersHelper {
function HelpersHelper () {
}
}
注意，在包块中最多只能定义一个类。在同一个文件中的辅助类不是包块的一部分，并且只能在此文件中可见和被使用。
18，访问属性
AS3为类和类成员引入了两个新的访问属性来扩展AS2中的private访问属性。在AS3中，现在有下面的访问控制属性：

public
protected
private
internal (默认)
public：public属性和AS2中一样。在任何地方定义的public属性，能在任何地方和被任何成员引用。
构造器必须定义成public。
应用程序类必须是public的。
protected：protected是一个新的属性。被protected指定的成员，只能被其本身或其子类访问。如果外部类尝试访问被protected的成员，将会抛出编译错误。
类和构造器不能被声明为protected。
private：AS2中已经有private属性，但是在AS2中，子类成员可以任意的访问父类的private成员。现在在AS3中，private属性只能在类内部被访问，其他类包括子类都不能直接访问此成员。也就是说，在子类中可以定义一个名称和父类某成员名称一样的成员，只要父类的此成员是声明为private的。
类和构造器不能被定义为private。
internal：internal和public比较类似，不同的地方在于类成员只能被同一个包中的成员所访问，而其他包中的成员不能访问。
internal是除了构造器以外的所有类和类成员的默认声明。
辅助类的访问控制有所不同。由于辅助类不属于任何包，internal的声明将限制其被访问只能是当前文件之内。注意：主类不能继承辅助类，只有辅助类能继承辅助类，并且要在同一个文件内。
访问控制的错误，并不仅仅是编译时错误，有时候也是运行时错误，在AS2中用来访问隐藏方法的方式，在AS3中不能用了，如：

package {

import flash.display.Sprite;

// 应用类必须定义成public (默认是internal)
public class AccessControl extends Sprite {

// 构造器总是public的
function AccessControl() {

// 只有在这个文件中才能访问辅助类
var helper:Helper = new Helper();

trace(helper.pubNum); // OK
// trace(helper.protNum); // Error - 错误，不能访问protected成员
// trace(helper.privNum); // Error - 错误，不能访问private成员
trace(helper.interNum); // OK
}
}
}
// 辅助类默认是internal
class Helper {

// public声明允许在任何地方被访问
// 变量通常被设置为private的，然后通过声明public的get set方法来访问
public var pubNum:Number = 1;

// protected声明只允许在子类中被访问
protected var protNum:Number = 2;

// private声明只能在类内部被访问
private var privNum:Number = 3;

// internal声明只允许在同一个包中被访问
// 但是对于辅助类来说，只能在同一个文件类被访问
internal var interNum:Number = 4;

// 构造器永远都是public的
function Helper() {
}
}
// 子辅助类默认是internal的
// 可以继承其他辅助类
class SubHelper extends Helper {

// 构造器，public
function SubHelper() {
trace(pubNum); // OK
trace(protNum); // OK - 继承得到的
// trace(privNum); // Error - 不能访问private
trace(interNum); // OK
}
}
另外一个例子：

package {

import flash.display.Sprite;
import containers.*;

// Application class needs to be public (internal by default)
public class AccessControl extends Sprite {

// constructors are always public
function AccessControl() {

// can access classes in other packages
// only if public
var bowl:Bowl = new Bowl(); // OK
// var basket:Basket = new Basket(); // Error - cannot access internal

trace(bowl.pubNum); // OK
// trace(bowl.protNum); // Error - cannot access protected
// trace(bowl.privNum); // Error - cannot access private
// trace(bowl.interNum); // Error - cannot access internal
}
}
}
ActionScript Code:
package containers {
// public class accessible anywhere
public class Bowl {

// public access granted anywhere
public var pubNum:Number = 1;

// protected access granted only for
// subclasses in that class
protected var protNum:Number = 2;

// private access granted only in this class
private var privNum:Number = 3;

// internal access granted only in the same package
internal var interNum:Number = 4;

// constructors are always public
function Bowl() {

// can access inteneral classes if in same package
var basket:Basket = new Basket();

trace(basket.pubNum); // OK
// trace(basket.protNum); // Error - cannot access protected
// trace(basket.privNum); // Error - cannot access private
trace(basket.interNum); // OK - same package

// clone using public method
var basketCopy:Basket = basket.clone();
}
}
}
ActionScript Code:
package containers {

// interal only accessible
// from other classes in package
internal class Basket {

// public access granted anywhere
public var pubNum:Number = 1;

// protected access granted only for
// subclasses in that class
protected var protNum:Number = 2;

// private access granted only in this class
private var privNum:Number = 3;

// internal access granted only in the same package
internal var interNum:Number = 4;

// constructors are always public
function Basket() {
}

// accessible anywhere as long as
// referencing a Basket instance
public function clone():Basket {
var basket:Basket = new Basket();
basket.pubNum = pubNum; // OK
basket.protNum = protNum; // OK - same class
basket.privNum = privNum; // OK - same class
basket.interNum = interNum; // OK
return basket;
}
}
}
19，抽象类
不幸的是，AS3中并没有抽象类（只能继承，不能实例化）。因此你不能在Flash中直接创建抽象类。但是，AS中的一些内置类实际上是抽象类。包括：

DisplayObject
InteractiveObject
DisplayObjectContainer
和抽象类一样，你不能使用new关键字创建这些类的实例。例如：
var myObj:InteractiveObject = new InteractiveObject(); //错误
但是，除此之外，在AS中，你也不能创建这些类的直接子类，例如：

package {
import flash.display.DisplayObject;
public class MyDisplay extends DisplayObject{
public function MyDisplay (){
// ERROR
}
}
}
这个类在的特性和在Player中如何定义有关。如果你创建这些类的直接子类并实例化，或者直接实例化这个类，都会出现Argument Error。
因此，如果你想扩展一个抽象类，可以采用扩展抽象类的现有的internal子类的方法。例如，如果你想扩展DisplayObject，你可以扩展Shape，一个轻量级的，internal访问级别的，DisplayObject的直接子类。