Simon Wacker

Basic implementation:

// :: Context :: //
class Context{
        private var state:State;

        public function request():Void{
                state.handle();
        }
        public function setState(aState:State):Void{
                state = aState;
        }
        public function getState():State{
                return state;
        }
}

// :: State :: //
interface State{
        public function handle():Void;
}

// :: ConcreteStateA :: //
class ConcreteStateA implements State{
        public function handle():Void{
                trace(”ConcreateStateA: handle“);
        }
}

// :: ConcreteStateB :: //
class ConcreteStateB implements State{
        public function handle():Void{
                trace(”ConcreateStateB: handle“);
        }
}

// usage
aContext = new Context();
aContext.setState(new ConcreteStateA());
aContext.request();
aContext.setState(new ConcreteStateB());
aContext.request();

This is only one way to change the state. I have chosen this way for simplicity. You could also change the state dynamically depending on for example a local connection or a mouse press etc. It depends on the context.

Basic implementation:

// :: Component :: //
interface Component{
        public function operation():Void;
}

// :: Leaf :: //
class Leaf implements Component{
        private var number:Number;

        public function Leaf(aNumber:Number){
                number = aNumber;
        }
        public function operation():Void{
                trace(”Leaf ” + number + “: operation“);
        }
}

// :: Composite :: //
class Composite implements Component{
        private var children:Array;

        public function Composite(){
                children = new Array();
        }
        public function operation():Void{
                for(var i:Number=0; i < children.length; i++){
                        children[i].operation();
                }
        }
        public function addComponent(aComponent:Component):Number{
                return children.push(aComponent)-1;
        }
        public function removeComponent(aNumber:Number):Void{
                children.splice(aNumber, 1);
        }
        public function getChild(aNumber:Number):Component{
                return children[aNumber];
        }
}

// usage
var aComponent:Composite = new Composite();
aComponent.addComponent(new Leaf(0));

var aComposite:Composite = new Composite();
aComposite.addComponent(aComponent);
aComposite.addComponent(new Leaf(1));
var leaf2 = aComposite.addComponent(new Leaf(2));
aComposite.addComponent(new Leaf(3));

aComposite.operation();

trace(”——————————–“);

aComposite.getChild(leaf2).operation();

trace(”——————————–“);

aComposite.removeComponent(leaf2);
aComposite.operation();

/* Output:
Leaf 0: operation
Leaf 1: operation
Leaf 2: operation
Leaf 3: operation
——————————–
Leaf 2: operation
——————————–
Leaf 0: operation
Leaf 1: operation
Leaf 3: operation
*/

Dave Yang already showed on his blog how to implement the Singleton Pattern. Therefore I think I don’t have to rewrite the code. Here’s the link: Singleton Pattern by Dave Yang.

Basic implementation:

// :: Builder :: //
class Builder{
        private var result:String;

        private function Builder(){
                result = new String();
        }
        public function buildPartA(aString:String):Void{
                result += “ :: ” + aString + “ :: “;
        }
        public function buildPartB(aNumber:Number):Void{
                result += “ :: ” + aNumber.toString() + “ :: “;
        }
        public function buildPartC(aBoolean:Boolean):Void{
                result += “ :: ” + aBoolean.toString() + “ :: “;
        }
}

// :: ConcreteBuilder :: //
class ConcreteBuilder extends Builder{
        public function buildPartB(aNumber:Number):Void{
                switch(aNumber){
                        case 1:
                        result += “ :: one :: “;
                        break;
                        case 2:
                        result += “ :: two :: “;
                        break;
                        case 3:
                        result += “ :: three :: “;
                        break;
                        default:
                        result += “ :: ” + aNumber.toString() + “ :: “;
                }
        }
        public function getResult():String{
                return result;
        }
}

// :: Director :: //
class Director{
        private var builder;

        public function Director(aConcreteBuilder:Builder){
                builder = aConcreteBuilder;
        }
        public function construct(anArray:Array):Void{
                for(var i=0; i< anArray.length; i++){
                        switch(typeof(anArray[i])){
                                case “string“:
                                builder.buildPartA(anArray[i]);
                                break;
                                case “number“:
                                builder.buildPartB(anArray[i]);
                                break;
                                case “boolean“:
                                builder.buildPartC(anArray[i]);
                                break;
                        }
                }
        }
}

// usage
var aBuilder:ConcreteBuilder = new ConcreteBuilder();
var aDirector:Director = new Director(aBuilder);
aDirector.construct([”name“, “age“, 2, true]);

trace(aBuilder.getResult());

// Output:
// :: name ::  :: age ::  :: two ::  :: true ::

Basic implementation:

// :: AbstractFactory :: //
class AbstractFactory{
        private var productA:ProductA;
        private var productB:ProductB;

        private function AbstractFactory(){
        }
        private function createProductA():Void{
                productA = new ProductA();
        }
        private function createProductB():Void{
                productB = new ProductB();
        }
}

// :: ConcreteFactory1 :: //
class ConcreteFactory1 extends AbstractFactory{
        public function ConcreteFactory1(){
                trace(”:: ConcreteFactory1 :: created“);

                createProductA();
                createProductB();
        }
        private function createProductA():Void{
                super.createProductA();
                productA.setSpecificValue(”specificValue1“);
        }
        private function createProductB():Void{
                super.createProductB();
                productB.setSpecificValue(”specificValue1“);
        }
}

// :: ConcreteFactory2 :: //
class ConcreteFactory2 extends AbstractFactory{
        public function ConcreteFactory2(){
                trace(”:: ConcreteFactory2 :: created“);

                createProductA();
                createProductB();
        }
        private function createProductA():Void{
                super.createProductA();
                productA.setSpecificValue(”specificValue2“);
        }
        private function createProductB():Void{
                super.createProductB();
                productB.setSpecificValue(”specificValue2“);
        }
}

// :: ProductA :: //
class ProductA{
        private var specificValue:String;

        public function setSpecificValue(aSpecificValue:String):Void{
                trace(aSpecificValue);

                specificValue = aSpecificValue;
        }
        public function getSpecificValue():String{
                return specificValue;
        }
}

// :: ProductB :: //
class ProductB{
        private var specificValue:String;

        public function setSpecificValue(aSpecificValue:String):Void{
                trace(aSpecificValue);

                specificValue = aSpecificValue;
        }
        public function getSpecificValue():String{
                return specificValue;
        }
}

// usage
var factory1:ConcreteFactory1 = new ConcreteFactory1();

trace(”———————————–“);

var factory2:ConcreteFactory2 = new ConcreteFactory2();

// Output:

// :: ConcreteFactory1 :: created
// specificValue1
// specificValue1
// ———————————–
// :: ConcreteFactory2 :: created
// specificValue2
// specificValue2