In Java, if you’ve created an object from a particular class, you can use only properties and methods that were defined in this class. For example, if the following class:
class Person {
String name;
}
you can only manipulate with the name property:
Person p = new Person();
p.name = “Joe”;
System.out.println(p.name);
ActionScript calls such classes sealed, but it also has different animals: dynamic classes, which allow you to programmatically add new properties and behavior to classes during the run-time. Just add the magic keyword dynamic to the class definition:
dynamic class Person {
var name:String;
}
Now let’s add dynamically two variables name and age and the function printme() to the object of type Person:
Person p= new Person();
p.name=”Joe”;
p.age=25;
p.printMe = function () {
trace (p.name, p.age);
}
p.printMe(); // Joe 25
You do not have complete freedom though: you can dynamically add only public properties and methods. Of course, nothing comes for free and sealed classes are a bit more efficient in terms of memory consumption, because they do not need to create a hash table to store the properties and methods that are unknown during compilation. Another obvious restriction is that dynamically added functions can’t access private members of the dynamic class. Read the article Programming In Style or an Elevator Pitch to see how by just declaring standard Flex component dynamic, the your code becomes more simple and elegant.
In AS3, any function can be attached to a dynamically created property of a dynamic object, for example
function calcTax():Number {…}
var myObject:SomeObject = new SomeObject();
myObject.tax=calcTax; //add the tax property and attach the function calcTax()
var myTax=myObject.tax();
The delete operator destroys the property of an object and makes it eligible for garbage collection:
delete calcTax();
myTax=myObject.tax() // generates an error
Some of the Flex classes were defined as dynamic, i.e. Object, Array, MovieClip, NetConnection, TextField, and others. At the time of this writing, subclasses of dynamic classes are not dynamic by default.
Because of this, you may run into an ugly run-time error: imagine a sealed class S that extends a dynamic class D. If you create an object as
D myObj = new S(), an attempt to add a propery to myObj will produce a runtime error because the variable myObj points at a sealed object.
Let’s do a quick test. Create a new project in FlexBuilder and select ActionScript project as its type. Enter AS_Only_Project as the project name. In a couple of seconds you’ll see the auto-generated code that looks as follows:
package {
import flash.display.Sprite;
public class AS_Only_Project extends Sprite
{
public function AS_Only_Project()
{
}
}
}
Next, create a new class called D and check odd the Dynamic checkbox in FlexBuilder pop-up. You’ll get this class.
package {
public dynamic class D
{
}
}
Now, instantiate and test the dynamic nature of the class D by adding the constructor
public function AS_Only_Project()
{
var myD:D=new D();
myD.favoriteBand=”Pink Floyd”;
trace(“Favorite Band=”+myD.favoriteBand);
}
Run this application in the debug mode, and sure enough it’ll print
Favorite Band=Pink Floyd
Create one more sealed class called S inherited from the dynamic D:
package {
public class S extends D
{
}
}
An attempt to add properties on the fly to the instance of the class S fails miserably as expected:
var myS:D = new S();
myS.favoriteSinger=”Alla Pugacheva”;
trace(“Favorite Singer=”+myS.favoriteSinger);
ReferenceError: Error #1056: Cannot create property favoriteSinger on S.
at AS_Only_Project$iinit()[C:\TheRIABook\eclipse\AS_Only_Project\AS_Only_Project.as:13]
If you’ll try to instantiate your sealed class as follows:
var myS:D = new S() as D;
I have two news for you: the good news is that it compiles, and the bad (and expected) news is that it generates exactly the same runtime error.
Most likely Adobe’s gonna hire a hitman and kill me after the following statement, but I’m going to say it anyway (at least you’ll now who to blame)… May be I should not?…Life is so good, and I’d like to witness the success of Apollo…I’m sayyyiiiinng this:
If you need to add new functionality to one of the existing standard Flex components (buttons, comboboxes and the like), do not bother extending them and creating new classes. Just create one simple empty subclass with the keyword dynamic and instantiate and add new properties on the fly as needed, as was shown by the Smalltalk student in this article.
A sound of a silenced pistol shot. Curtain.
Yakov Fain