Geirr Winnem's Blog » Design Patterns

Factory method design pattern as3 example

gwinnem — Wed, 30 Dec 2009 11:40:54 +0000

The Factory method pattern belongs to the group of creational patterns,
it deals with the problem of creating objects (products) without specifying the exact class of object that will be created.

The factory method design pattern handles this problem by defining a separate method for creating the objects.

Subclasses can then override to specify the derived type of product that will be created.
More generally,the term factory method is often used to refer to any method whose main purpose is creation of objects.

The Factory Method pattern is a simplified version of Abstract Factory pattern.

Factory Method pattern is responsible of creating products that belong to one family, while Abstract Factory pattern deals with multiple families of products.

Factory method UML diagram

Participants:

IProduct Defines the interface of the objects the factory method creates.
ConcreteProduct1 Implements the IProduct interface.
ConcreteProduct2 Implements the IProduct interface.
AbstractCreator Declares the factory method, which returns an object of type IProduct. Creator may also define a default implementation of the factory method that returns a default ConcreteProduct object.
ConcreteCreator1 Overrides the factoryMethod to return an instance of ConcreteProduct1.
ConcreteCreator2 Overrides the factoryMethod to return an instance of ConcreteProduct2.

For more details about how an abstract class is defined in actionscript, see AbstractClass

Benefits:

Eliminates the needs to bind application classes into your code. The code deals with interfaces so it can work with any classes that implement a certain interface.
Enables the subclasses to provide an extended version of an object, because creating an object inside a class is more flexible than creating an object directly in the client.

Usage:

When a class cannot anticipate the objects it must create.
When a class want subclasses to specify the objects it creates.
Classes delegate responsability to one of several helper subclasses, and you want to localize the knowledge of which helper subclasses is the delegate.

Live example:

Source code:

DesignPatternFactoryMethod

#Abstract class example in #as3(#actionscript)

gwinnem — Tue, 29 Dec 2009 23:17:19 +0000

Some of the design patterns rely on the implementation of abstract classes. Actionscript unfortunately do not support this.

Some facts about abstract classes:

Abstract classes cannot be instantiated. They have to be extended by subclasses.
They can contain abstract methods or unimplemented method declarations that subclasses need to implement. The methods implemented in an abstract class will in most cases be default behaviors, and much of the class will be unimplemented.
Before a class derived from an abstract class can be instantiated, it must implement all unimplemented methods. The advantage of deriving from an abstract class is that the subclass does not have to implement a method if the default behavior implemented in the abstract class is what it needs.

Its quite easy to mimic this in actionscript, but there will be no compiler error checking, so its up to the developer to make sure that it is being implemented correctly.

Sample Abstract Class:

package winnemconsulting.examples.abstract
{
import flash.errors.IllegalOperationError;
import flash.utils.getQualifiedClassName;
/**
* Simple example of a abstract class implementation
* @author Geirr Winnem
*/
public class AbstractClass
{
/**
* Constructor.
* Since this is a abstract class it is not allowed to instanciate this class.
*/
public function AbstractClass()
{
//Checking if this class is being instanciated directly
if (getQualifiedClassName(this) == "winnemconsulting.examples.abstract::AbstractClass")
{
throw new IllegalOperationError("Abstract class can not be instanciated");
}
}
/**
* Normal function which is implemented in the abstract class
*/
public function implementedFunction():void
{
trace("implementedFunction");
}
/**
* Abstract function which must be overriden in all classes derived from this class
*/
public function abstractFunction():void
{
throw new IllegalOperationError("Abstract function must be ovverriden in subclass");
}
}
}

Design patterns tutorial(#as3 #actionscript) overview

gwinnem — Wed, 16 Dec 2009 10:05:29 +0000

Ive been working with design patterns for a long time, and have had some really good experiences in the past when im refactoring code and enforcing the use of patterns.

In the following tutorials i plan to give brief explanations on each pattern, how to use it and example code where the pattern is being used.

Im not going to divide the patterns into the normal categories(Creational,Behavioral or Structural).

Rather im planning to present the patterns in a way which gives the audience a progressive understanding on patterns and their interlinking between each other.

Pattern list for these tutorials:

Factory Method
Strategy
Decorator
Composite
Iterator
Template Method
Abstract Factory
Builder
Singleton
Proxy
Adapter
Bridge
Mediator
Observer
Chain of Responsibillity
Memento
Command
Prototype
State
Visitor
Flyweight
Interpreter
Facade

So stay tuned for the first part where i will walk through the Factory method pattern.

Please feel free to comment and share thoughts as these tutorials are progressing.

#Actionscript(#as3) #Command #pattern with source code

gwinnem — Mon, 14 Dec 2009 10:47:20 +0000

The command pattern is a design pattern in which an object is used to represent and encapsulate all the information needed to call a method at a later time.

This information includes the method name, the object that owns the method and values for the method parameters.

Three terms always associated with the command pattern are client, invoker and receiver.

The client instantiates the command object and provides the information required to call the method at a later time. The invoker decides when the method should be called. The receiver is an instance of the class that contains the method's code.

Using command objects makes it easier to construct general components that need to delegate, sequence or execute method calls at a time of their choosing without the need to know the owner of the method or the method parameters.

The example app uses one single command class to generate 3 canvas DisplayObjects to the stage.

In the DesignPatternCommand.mxml file im using the CreationComplete event to kick of the Command sequence.

private function onCreationComplete():void
{
var commandCanvas:Command=new Command();
commandCanvas.execute(Command.RED, this);
commandCanvas=new Command();
commandCanvas.execute(Command.GREEN, this);
commandCanvas=new Command();
commandCanvas.execute(Command.BLUE, this);
}

Since its good practice in OOP i also created a interface to program the Command class.

ICommand.as

import flash.display.DisplayObjectContainer;
/**
* The interface of command implementation
* @author Geirr Winnem
*/
public interface ICommand
{
/**
* Execute the ICommand logic.
* @param canvasColor the canvas color to generate
* @param stage DisplayObjectContainer which the canvas is added to.
*/
function execute(canvasColor:String, stage: DisplayObjectContainer):void;
}

Finally we have the command class itself which implements the ICommand interface

import flash.display.DisplayObjectContainer;
import mx.containers.Canvas;
/**
* Class implementing the Command pattern
* @author Geirr Winnem
*/
public class Command extends Canvas implements ICommand
{
/**
* Constant value for a red canvas
*/
public static const RED:String="redCanvas";
/**
* Constant value for a green canvas
*/
public static const GREEN:String="greenCanvas";
/**
* Constant value for a blue canvas
*/
public static const BLUE:String="blueCanvas";
/**
* Constructor
*/
public function Command()
{
super();
}
/**
* Execute the ICommand logic.
* @param canvasColor the canvas color to generate
* @param stage DisplayObjectContainer which the canvas is added to.
*/
public function execute(canvasColor:String, mainStage:DisplayObjectContainer):void
{
switch (canvasColor)
{
case RED:
super.setStyle("backgroundColor", 0xff0000);
break;
case GREEN:
super.setStyle("backgroundColor", 0×00ff00);
break;
case BLUE:
super.setStyle("backgroundColor", 0×0000ff);
break;
}
this.width=100;
this.height=100;
mainStage.addChild(this);
}
}

Example App..

DesignPatternCommand flex project

#Actionscript(#as3) #Facade #Pattern

gwinnem — Mon, 07 Dec 2009 16:58:15 +0000

A facade is an object that provides a simplified interface to a larger body of code, such as a class library.

A facade can:

make a software library easier to use and understand, since the facade has convenient methods for common tasks;
make code that uses the library more readable, for the same reason;
reduce dependencies of outside code on the inner workings of a library, since most code uses the facade, thus allowing more flexibility in developing the system;
wrap a poorly-designed collection of APIs with a single well-designed API (as per task needs).

You read more about design patterns at http://www.as3dp.com/category/design-patterns/

You can find the source code here: DesignpatternFacade.zip flex project.

#Actionscript(#as3) #Observer #pattern

gwinnem — Wed, 02 Dec 2009 15:55:57 +0000

Any good software developer should know about design patterns. I have been using them since i started programming. Now im doing most of my work in java and actionscript and in one of my opensource projects i had to avoid using the actionscript event model.

The Observer pattern is a subset of the Publish/subscribe pattern. and belongs to the Behavioral group of patterns.

Basically when implementing this pattern you have two actors:

Producer/Publisher
Subscriber/Consumer

The Producer/Publisher is responsible for broadcasting the message to all Subscriber/Consumer objects that subscribe/consume for a specific message/event.

In the actionscript event model this is handled by adding a eventlistener of a specific type(Subscriber/Consumer) and by dispacthing an event(Producer/Publisher)

Psoudo code Producer/Publisher:

import flash.events.Event;
import flash.events.EventDispatcher;
public class Producer extends EventDispatcher
{
/**
* Empty contructor
*/
public function Producer()
{
}
/**
* Event dispatcher.
* Responsible for notifying all the subscribers
* @param eventType
*
*/
public function notifyConsumer(eventType:String):void
{
dispatchEvent(new Event(eventType));
}
}

Psoudo code Subscriber/Consumer:

import flash.events.Event;
public class Consumer
{
private var producer:Producer;
/**
* Constructor
* Adding the eventlistener
*/
public function Consumer()
{
producer.addEventListener("MyListenerEvent", onEvent);
}
/**
* Handling the event
* @param event Event object dispatched from producer
* @private
*/
private function onEvent(event:Event=null):void
{
//Handle the event here
}
}

The above code is a example.

Observer Class Diagram:

Observer Sequence Diagram:

References: