getProperty and setProperty are methods used in Proxy classes that are used to manage property access. When a property not defined within a proxy instance is retrieved, getProperty is called to retrieve it. When set, setProperty is used to set it.

As with all methods of the Proxy class, getProperty and setProperty are defined within the flash_proxy namespace (flash.utils.flash_proxy) to prevent conflicts with public. When you override these methods within your own Proxy subclasses, you will want to be sure to use the flash_proxy namespace.

The following example, CustomObject, extends Proxy and uses getProperty and setProperty to manage dynamic properties set for its instances.

ActionScript Code:

package {

import flash.utils.Proxy;
import flash.utils.flash_proxy;

dynamic public class CustomObject extends Proxy {

public var classProperty:String = "classProperty"; // generic class variable
private var customProperties:Object = new Object(); // store custom variables

public function CustomObject() {
}

// called when getting dynamic variables
override flash_proxy function getProperty(name:*):* {
if (name in customProperties) {
return customProperties[name];
}
return "Property does not exist";
}
// called when setting dynamic variables
override flash_proxy function setProperty(name:*, value:*):void {
customProperties[name] = "Property "+name+": "+value;
}
}
}

ActionScript Code:

// usage example
var myObj:CustomObject = new CustomObject();
trace(myObj.foo); // Property does not exist
myObj.foo = "bar";
trace(myObj.foo); // Property foo: bar

trace(myObj.classProperty); // classProperty
myObj.classProperty = "bar";
trace(myObj.classProperty); // bar

Notice that when getting and setting the foo property, getProperty and setProperty are used to control its ultimate value which is stored within a customProperties defined for the class. Also, since classProperty is not a dynamic variables, instead being one defined for the class, getProperty and setProperty to not apply.

這句話寫得簡短，這邊再作進一步的解釋，抽象部份指的是行為方面定義，實現方面指的是與特定平台相依的代碼實現。

一個實際的例子在Gof書中有提到，假設您定義了一個IWindo介面，這個介面只定義一些抽象的繪圖行為，而不涉及平台的實作，今天您可以繼承這個類 來開發適用於X Windo的XWindow類，也可以繼承這個類來開發適用於Windows X系統的WindowsXP類，為了善用系統資源，您在實作IWindow介面時，會將與系統相關的實現代碼撰寫在介面的實作中。

假設今天您繼承了IWindow介面撰寫了一個I3DWindo介面，當中擴充一個drawBox()方法用於3圖形的繪製，簡單的說， I3DWindo介面擴充了抽象行為，為了讓實現I3DWindow的類別也能在XWindow與Windows XP兩個不同的系統中運行，您必須再度撰寫與系統相關的實現代碼。

簡單的說，抽象行為定義與平台相關實現混雜在一起了，為了將抽象部份與它的實現部份分離，使它們都可以獨立地變化，您可以使用以下的結構。

在上圖的右邊中，與平台相關的實現部份，被與右邊抽象行方面的發展分開了，左邊的抽象部份您可以一直發展下去，而不再因為綁定了平台特定實作方法，而使得整個結構越來越失去彈性。

Bridge模式UML 類別結構圖如下

The in operator (in operator) is a new operator in ActionScript 3 that is used to see if a value exists within an object. This is similar to hasOwnProperty but will also work for inherited values.

ActionScript Code:

ActionScript 3 introduces a new class to take the place of ActionScript 1 and ActionScript 2's addProperty method and __resolve handler for objects. This class is the Proxy Class (flash.utils.Proxy).

In ActionScript 1 and ActionScript 2:

• addProperty() - used to dynamically add a getter/setter property for an object or class. This dynamically created a variable that was set and whose value was retrieved through functions passed into the addProperty call.
• __resolve - a handler that, when defined for an object, would be called when a property or method was accessed that did not exist for that object. This let you capture unresolved references from an object and react accordingly

In ActionScript 3 you create a class that extends Proxy to take advantage of all its features. They include

• Capturing property setting
• Capturing property getting
• Capturing property checking (if exists)
• Capturing property deletion
• Capturing method calls
• Capturing decendant access
• Capturing attribute checking
• Handling property iteration

Though these features hold a lot of advange over what was available with AS1 and AS2, there are some drawbacks to using Proxy:

• Instance typing is limited since classes need to extend Proxy; you tend to have to rely on interfaces
• You cannot have Proxy classes that inherit from classes that don't already inherit from Proxy
• Display objects cannot be Proxy classes

Proxy classes are generally used for variable container classes that need extra the flexibility.

The Proxy class will be covered in more detail in later tips

If you're using MXMLC (the MXML and ActionScript 3 stand alone, command line compiler provided with the free Flex 2 SDK) to compile your ActionScript 3 SWFs, you can use the SWF metadata tag to set common properties for your movie. The SWF metadata tag supports 4 properties

• width
• height
• frameRate
• backgroundColor

Example:

ActionScript Code:

package {
[SWF(width="500", height="450", frameRate="24", backgroundColor="#FFFFFF")]
public class MyApp extends Sprite {

}
}

When compiled, the above makes a SWF 500x450 in size with a background color of white and a framerate of 24.

The final keyword (Toplevel final keyword) is an attribute for classes and methods that lets you prevent overriding (methods) and subclassing (classes).

When a method is marked as final, no subclasses of that class can create a method of the same name that overrides that method. This ensures that when the method is called, it will always be the method marked final.

ActionScript Code:

final public function methodName() {
// your statements here
}

Similarly, for classes, if a class is marked final, no subclasses can be created that extend that class.

ActionScript Code:

package{
final public class ClassName {
// your statements here
}
}

Note: it is pointless to have methods marked as final in a class marked as final since that class cannot be extended. Since it cannot be extended, there would be no way for methods to be overridden as that only occurs within subclasses of the original class.

There are times where you might want to have actions only run when the mouse is within a sprite or movie clip. Director's Lingo programing language has a mouseWithin event that facilitates this. Flash, however, has no such event. However, with ActionScript 3's event model, you can easily create your own.

A mouseWithin event is essentially an enterFrame event that only runs when the mouse is within or touching the display object in which its associated. So, in making your own, all you need to do is define an enterFrame event when the mouse enters the object and remove it when the mouse leaves the object. And yes, technically you could do this in ActionScript 1 and ActionScript 2, but it would mean using up event handlers like onRollOver and onEnterFrame which could interfere with other actions for your movie clip (since you can only have one per movie clip).

For ActionScript 3, implementing a mouseWithin event just means giving your sprite or movie clip class a few event handlers and setting up some listeners, e.g.

ActionScript Code:

// methods managing mouseWithin
private function addMouseWithin(event:MouseEvent):void {
addEventListener(Event.ENTER_FRAME, mouseWithin);
}
private function removeMouseWithin(event:MouseEvent):void {
removeEventListener(Event.ENTER_FRAME, mouseWithin);
}
private function mouseWithin(event:Event):void {
dispatchEvent(new MouseEvent("mouseWithin"));
}

// in constructor
public function MySpriteClass() {
addEventListener(MouseEvent.MOUSE_OVER, addMouseWithin);
addEventListener(MouseEvent.MOUSE_OUT, removeMouseWithin);
}

With that, a mouseWithin event fires every frame whenever the mouse is within the sprite. To add listeners for it, just use:

ActionScript Code:

addEventListener("mouseWithin", mouseWithinHandler);

Like ActionScript 2, ActionScript 3 allows you to create dynamic classes using the dynamic keyword (dynamic keyword). Dynamic classes are classes you can add properties to dynamically without needing to declare or define them within the class definition. An example of a dynamic class would be Array. When you create an Array instance, you can assign to it any variariable you want despite it not being within the Array class definiton.

In AS2, when you extended a class that was dyanmic, that subclass too became dynamic.

ActionScript Code:

// superclass.as
dynamic class superclass {
}

// subclass.as
class subclass extends superclass {
}

// main movie
var instance:subclass = new subclass();
trace(instance.anything); // ok since subclass inherited dynamic

This is no longer the case with AS3. Subclasses of dynamic classes are no longer dynamic unless specified as being dynamic themselves

ActionScript Code:

// superclass.as
package {
dynamic class superclass {
}
}

// subclass.as
package {
class subclass extends superclass {
}
}

// main movie
var instance:subclass = new subclass();
trace(instance.anything); // error, property not defined (not dynamic)

When you want to access a class member in a namespace, you need to reference that member through the namespace in which it was defined. One way to do this is through the name qualifier operator (name qualifier operator).

The name qualifier operator takes the form of two colons that connects the namespace with the member of the class you are trying to access that exists within that namespace, eg. namespace::member. Ex:

ActionScript Code:

package {

public class UsingNameSpaces {

public namespace company = "http://www.example.com/company";
public namespace individual = "http://www.example.com/individual";

company var value:int = 10;
individual var value:int = 2;

public function UsingNameSpaces(){
company::showValue(); // traces 10
individual::showValue(); // traces 2
}

company function showValue() {
trace(company::value);
}

individual function showValue() {
trace(individual::value);
}
}
}

Note that even though showValue is being called within the namespace, the namespace is still needed to reference variables (or other members) in namespaces used within the function body.

ActionScript 3 now supports namespaces. Namespaces in AS3 are similar to namespaces in XML and provide a way to separate code in to separate "spaces" or collections identifiable through a name (namespace). Namespaces in this respect act much like packages. In the same manner that packages allow you to have different classes with the same name in one application (only defined in different packages), namespaces allow you to have different methods with the same name in one class (defined in different namespaces). Though you may not have known it, chances are you've already been using namespaces. Predefined namespaces include public, private, protected, and internal.

When you use a namespace, you have to declare it just like you declare any other class member. Namespaces are declared using the namespace keyword (namespace Keyword). Once declared you can use it to separate members into different namespaces. Ex:

ActionScript Code:

package {

public class UsingNameSpaces {

public namespace company;
public namespace individual;

company var value:int = 10;
individual var value:int = 2;

public function UsingNameSpaces(){
}

company function showValue() {
}

individual function showValue() {
}
}
}

Two namespaces were used here, company and individual. They were used to defined a value variable and a showValue method - one for each namespace. Though they have the same names, since they are in different namespaces, they are allowed.

Additionally, namespaces can otionally be defined with a namespace uri when declared in the class:

ActionScript Code:

package {

public class UsingNameSpaces {

public namespace company = "http://www.example.com/company";
public namespace individual = "http://www.example.com/individual";

company var value:int = 10;
individual var value:int = 2;

public function UsingNameSpaces(){
}

company function showValue() {
}

individual function showValue() {
}
}
}

ActionScript 3 has a new iteration statement: for each..in (for each..in). for each..in works much like for..in (for..in) execpt it loops through the values of an object rather than its keys. Example:

ActionScript Code:

var object:Object = new Object();
object.name = "senocular";
object.id = 2867;
object.isModerator = true;
for each (var value:* in object){
trace(value);
}
/* Output:
true
2867
senocular
*/

Respectively, a for..in would look like:

ActionScript Code:

var object:Object = new Object();
object.name = "senocular";
object.id = 2867;
object.isModerator = true;
for (var key:String in object){
trace(key + ": " + object[key]); // object[key] is value
}
/* Output:
isModerator: true
id: 2867
name: senocular
*/

Note that the key is not available in for each..in.

ActionScript 3 also maintains array element order (using numeric array indices) when using for..in and for each..in rather than basing order off of when the value was created as was the case in ActionScript 1 and 2. Example:

ActionScript Code:

var array:Array = new Array();
array[1] = 1;
array[0] = 2;
array[2] = 3;
for (var key:String in array){
trace("array[" + key + "] = "+ array[key]);
}

Output AS 1 & AS 2:

Code:

Output AS 3:

Code:

This provices a more intuitive order when iterating through arrays with for..in and for each..in.

Note: To use the for each..in statement with an instance of a user-defined class, you must declare the class with the dynamic attribute.

ActionSript 3 now allows you to specify default values for your function's parameters. In doing so, that parameter then becomes optional and the default value assigned to the respective argument in the function call if a value is explicitly not provided.

ActionScript Code:

function method(required:String, optional:String = "default"):void {
trace(required +" "+optional);
}
method("Hello"); // "Hello default"

You can only place parameters with default values after all required parameters. In other words you can't have

ActionScript Code:

// Incorrect:
function method(required:String = "default", optional:String):void { ...

since there would be no way for optional to be set without required having to be set as well.

Since ActionSript 3 checks argument count when functions are called you are not able to pass any number of arguments to any function like you could in ActionScript 1 or ActionScript 2. Instead, to allow for this, you need to use a new special kind of parameter called ...(rest) (Keyword: ...(rest)).

The ...(rest) parameter is a special parameter placed at the end of a parameter list in a function that specifies that there can be any number of additional arguments of any type passed into that function when its called. The form of the parameter is 3 periods followed by a keyword. When the function is called, the additional arguments are assigned to that keyword in the form of an array.

ActionScript Code:

function usingRest(required:Number, ... optionalArgs):void {
trace(required); // 1
trace(optionalArgs); // [2, 3, 4]
}
usingRest(1, 2, 3, 4);