Simon Wacker

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

The Abstract Factory Pattern is the first Pattern I learned about. I think it’s one of the patterns you can use in almost all projects. The idea behind it is “to provide an interface for creating families of related of dependent objects without specifying their concrete classes”. If you search in google for “Abstract Factory Pattern” you’ll find a picture that demonstrates the relationships between the objects. Click on “read more” to see the example code I wrote. If I interpreted or impemented the design pattern in a wrong way let me know it.
(more…)