关于设计模式,勿必参考《设计模式——可复用面向对象软件的基础》一书中关于提及设计模式的结构UML图!!!
一、单例模式
保证一个类仅有一个实例,提供一个全局的访问点。
《殿堂之路》说构造函数不能用private控制访问符,但是可以考虑使用包外类实现!!!!!
package zjh
{
public class Singleton
{
private static var singleton:Singleton;
private function Singleton()
{
}
public static function getInstance():Singleton
{
if(singleton==null)
{
singleton=new Singleton();
}else{
return singleton;
}
}
}
}
二、工厂方法
定义一个用于创建对象的接口,让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。
参与者
1.Product(抽象产品)
定义工厂方法所创建的对象的接口。(产品)
package zjh
{
public interface IWork
{
function doWork():void;//抽象产品
}
}
2.ConcreteProduct(实现产品)
实现Product接口。
package zjh
{
public class StudentWork implements IWork//具体产品1
{
public function StudentWork()
{
}
public function doWork():void
{
trace("学生做作业!");
}
}
}
package zjh
{
public class TeacherWork implements IWork//具体产品2
{
public function TeacherWork()
{
}
public function doWork():void
{
trace("老师改作业!");
}
}
}
......等n多产品
3.Creator(抽象工厂,声明工厂方法)
声明工厂方法,该方法返回一个Product类型的对象
Creator也可以定义一个工厂方法的缺省实现,它返回一个缺省的ConcreteProduct对象。
可以调用工厂方法以创建一个Product对象。
package zjh
{
public interface IFactory//抽象工厂
{
function getWork():IWork;//获得产品
}
}
4.ConcreteCreator(具体工厂,重定义工厂方法)
重定义工厂方法以返回一个ConcreteProduct实例。
package zjh
{
public class StudentFactory implements IFactory//具体工厂1
{
public function StudentFactory()
{
}
public function getWork():IWork
{
return new StudentWork();
}
}
}
package zjh
{
public class TeacherFactory implements IFactory//具体工厂2
{
public function TeacherFactory()
{
}
public function getWork():IWork
{
return new TeacherWork();
}
}
}
......等n多具体工厂
Test:
var f:IFactory=new StudentFactory();
f.getWork().doWork();
f=new TeacherFactory();
f.getWork().doWork();
输出:
学生做作业!
老师改作业!
备注:
Actionscript3.0接口与类的不同:摘自《殿堂之路》
定义接口要使用关键字interface
接口只定义方法,不定义属性。定义的方法包括实例方法、静态方法、getter和setter方法。
所以定义的方法不可以加访问控制符。接口中定义的方法都是public类型。
定义的方法没有任何实现,直接以“;”号结尾
按照编程惯例,一般接口名称以大写字母I开头
三、抽象工厂
提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。参与者
1. AbstractFactory
声明一个创建抽象产品对象的操作接口。
package zjh
{
public interface IAnimalFactory
{
function createCat():ICat;
function createDog():IDog;
}
}
2.ConcreteFactory
实现创建具体产品对象的操作。
package zjh
{
public class BlackAnimalFactory implements IAnimalFactory
{
public function BlackAnimalFactory()
{
}
public function createCat():ICat
{
return new BlackCat();
}
public function createDog():IDog
{
return new BlackDog;
}
}
}
package zjh
{
public class WhiteAnimalFactory implements IAnimalFactory
{
public function WhiteAnimalFactory()
{
}
public function createCat():ICat
{
return new WhiteCat();
}
public function createDog():IDog
{
return new WhiteDog();
}
}
}
3.AbstractProduct
为一类产品对象声明一个接口。
package zjh
{
public interface ICat
{
function eat():void;
}
}
package zjh
{
public interface IDog
{
function eat():void;
}
}
4.ConcreteProduct
定义一个将被相应的具体工厂创建的产品对象。
实现abstractProduct接口。
package zjh
{
public class BlackDog implements IDog
{
public function BlackDog()
{
}
public function eat():void
{
trace("Black Dog is eat");
}
}
}
package zjh
{
public class WhiteDog implements IDog
{
public function WhiteDog()
{
}
public function eat():void
{
trace("White Dog is eat");
}
}
}
5.Client
仅使用由AbstractFactory和AbstractProduct类声明的接口
var a:IAnimalFactory=new BlackAnimalFactory();
a.createCat().eat();
a.createDog().eat();
a=new WhiteAnimalFactory();
a.createCat().eat();
a.createDog().eat();
输出:
Black Cat is eat
Black Dog is eat
White Cat is eat
White Dog is eat
备注:
工厂方法模式:
一个抽象产品类,可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式:
多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别:
工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。