Let’s talk about some basic Object Oriented programming (OOP) principles - modifiers. Although some modifiers are used often, especially access modifier (private, public, protected and internal), others are rarely used since they are not needed in most cases. With that said, we tend to forget them and end up never using them, even when they are needed.

I decided to create a useful one page summary that can be revisited every time you forget the different types of modifiers available in ActionScript 3.0.

To begin let’s split the modifiers into two groups;

• Access modifier – is a modifier that changes the visibility of a class or its members.
• AS 3.0 Modifiers - used to modify declarations of types and type members in AS.

Access Modifiers

AS 3.0 Modifiers

* Keyword is not available

As default I highly recommend you to declare your objects as private unless you need to let other class access the object. The goal is to keep your object as abstracted as possible; making your code as loosely coupled to other objects, which will increase the re-usability of the objects.

When developing API’s in Action Script we design and choose from different modifiers, however when the wrong modifier is used the object can be misused and the objects become coupled to other objects.

Here’s my wish list for AS 4.0;

• Action Script supports the abstract modifier.
• Action Script support for static classes to insure they are not being created by creating an instance reference.
• Action Script allow the creation of Private class constructors.

There are many scripts out there to add these modifiers but many seem like a hack than an elegant solution. They basically help you enforce how the modifiers should act.
The only one that I see as a good solution, and not as somewhat of a hack is for creating Abstract methods and classes, here’s an example of how to create and implement;

package com.utils
{
    import flash.errors.IllegalOperationError;
    public class AbstractClass
    {
		public function AbstractClass(self:MyAbstractClass)
    	{
    		if(self != this)
    		{
    			throw new IllegalOperationError(”Abstract class did not receive reference to self. MyAbstractClass cannot be instantiated directly.”);
    		}
    	}

		public function method(param:String):void
    	{
    		throw new IllegalOperationError(”abstract function must be overriden”);
    	}
    }
}

And here’s how you would implement the class;

package com
{
    public class MyImplementClass extends AbstractClass
    {
	    public function MyImplementClass()
    	{
    		super(this);
    	}

		public override function method():void
    	{
    		trace("Method");
    	}
    }
}