宁静的夏天

6、----------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------
*标签申明

在AS3中引入了标签，新的标签可以和循环体一起使用。例如，现在有两个嵌套的循环体，如果想要在内

循环体中break掉外循环，一般使用下面的方法：

var i:Number;
var j:Number;
var exit:Boolean = false;
for (i=0; i<10; i++) {
    for (j=0; j<10; j++) {
        if (i > 3 && j > 3) {
            exit = true;
            break;
        }
    }
    if (exit) {
        break;
    }
}在引入了新的标签以后，可以使用下面的方法从内循环体中直接break掉外循环体：

var i:Number;
var j:Number;
mainLoop: for (i=0; i<10; i++) {
    for (j=0; j<10; j++) {
        if (i > 3 && j > 3) {
            break mainLoop;
        }
    }
}在第一个循环体上设置了mainLoop的标签，因此在循环体内任何地方使用break mainLoop直接中止外循

环。

*检测鼠标离开Movie的动作

在以前的AS版本中，你无法做到检测鼠标是否还在Flash Movie上。因此影片不能检测到用户是否在关注

着当前的Movie。另外一个问题是，如果使用了自定义的鼠标样式，在鼠标移出Movie后，自定义的鼠标还

是继续停留在影片上，而不能正确的显示鼠标当前的位置。

现在，AS3允许你通过监听stage的mouseLeave行为来捕获鼠标移出Movie的动作。mouseLeave行为在鼠标

移出Movie的时候执行。但是现在并没有mouseEnter事件，不过你可以通过使用mouseMove来设置。

下面的例子中使用了一个方框来作为自定义的鼠标：

package {
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.ui.Mouse;
    
    public class Test extends Sprite {
        
        private var cursor:Sprite = new Sprite();
        
        public function Test() {
            cursor.graphics.beginFill(0xFF);
            cursor.graphics.drawRect(0, 0, 25, 25);
            addChild(cursor);
            
            stage.addEventListener(Event.MOUSE_LEAVE, cursorHide);
            stage.addEventListener(MouseEvent.MOUSE_MOVE, cursorFollow);
            Mouse.hide();
        }
        
        public function cursorHide(evt:Event):void {
            cursor.visible = false;
        }
        
        public function cursorFollow(evt:MouseEvent):void {
            if (!cursor.visible) cursor.visible = true;
            cursor.x = stage.mouseX;
            cursor.y = stage.mouseY;
            evt.updateAfterEvent();
        }
    }
}当鼠标离开Movie的时候，鼠标指针将被隐藏。当鼠标再次移动到Movie上的时候，mouseMove会被执行，

然后显示鼠标。

7、----------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------
*SimpleButton实例

AS3现在有一个新的类：SimpleButton（flash.display.SimpleButton）。这个类允许你通过AS创建一个

按钮。

var myButton:SimpleButton = new SimpleButton();SimpleButton类有4个属性分别代表按钮的四个不同

状态：upState，overState，downState和hitAreaState。你可以为每一个状态创建一个新的显示对象，

然后将显示对象赋予SimpleButton的各种状态：

myButton.upState = mySprite1;
myButton.overState = mySprite2;
myButton.downState = mySprite3;
myButton.hitAreaState = mySprite4;*数组定义中的逗号

本文非直接翻译，原文解释部分如下：
When defining arrays in ActionScript 3 using the shorthand array access operator (brackets),

you can now have a trailing comma following the last element without causing an error (like

in PHP). This makes working with multi-line array definitions a little less error-prone when

rearranging elements.

先来看一个例子：

var myList:Array = [
    "The",
    "quick",
    "brown",
    "fox",
];在AS1和2中，"fox"后的逗号会导致一个编译错误，但是在AS3中不会了。

注意，这个逗号只是在使用[]定义数组的时候有效，使用Array()或new Array()的时候是无效的。

8、----------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------
*包块

AS3中的包定义方式和AS2中有所不同。在AS3中，包路径不再是类定义的一部分，而是使用一个包块来包

含类。定义包块使用的是package标签，如下：

package my.package.path {
    class MyClass {
    }
}而在AS2中，应该是下面的样式：

// ActionScript 2:
class my.package.path.MyClass {
}实际上，在AS3中，所有的类都必须定义在包里面，如果一个类不属于任何一个包，也需要使用空的包路

径来定义：

package {
    class NotInAPackageClass {
    }
}每一个包块可以将一些有关联的类或者方法包含在一个文件里面。文件中包块里的类或方法必须使用和

文件名相同的名称：

package com.kirupa.utils {
    function StripString(str:String):void {
        // ...
    }
}上面的代码应该保存在一个名称为StripString.as的文件中，并放在路径为com/kirupa/utils的文件夹

里。

*一个文件中的多个类

一般来说，一个.as文件中就一个类，但是在AS3中，现在允许在一个文件中定义多个类用来辅助主类。

在.as文件中的辅助类，必须定义在类包以外，并且只针对此文件中的主类和其他辅助类可见。

例如：

package {
    class MyClass {
        function MyClass() {
            var helper:MyHelper = new MyHelper();
        }
    }
}
class MyHelper {
    function MyHelper() {
        var helper:HelpersHelper = new HelpersHelper();
    }
}
class HelpersHelper {
    function HelpersHelper () {
    }
}注意，在包块中最多只能定义一个类。在同一个文件中的辅助类不是包块的一部分，并且只能在此文件

中可见和被使用。

9、----------------------------------------------------------------------------------------

-------------------------------------------------------------------------------------
*访问属性

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;
        }
    }
}*抽象类

不幸的是，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的直接子类

。