最近打算总结一下设计模式（希望可以坚持写完...)。
设计模式大体上可以分为三种：
1）创建型（5种）
具体包括：工厂方法（包括简单工厂），抽象工厂，单例，建造者，原型
2）结构型模式（7种）
具体包括：适配器，桥接，组合，装饰器，代理，外观，享元
3）行为型模式（11种）
具体包括：策略模式，模版方法，命令，职责链，状态，观察者，中介者，迭代器，访问者，备忘录，解释器
创建型模式的技巧主要应用于创建对象的方式上。
结构性模式的技巧主要在于对不同类之间的组合以实现代码复用。
行为型模式的技巧在于不同类之间的相互作用及相互影响。
创建型模式
1）简单工厂模式
简单工厂一般只包含一个工厂，以及产品抽象类及其子类。
优点：实现了对象的创建与使用的分离。
缺点： 每增加一个产品都要修改原来的代码，且需要不断增加新的逻辑。
enum fruits{
APPLE,
GRAPE
}
//果汁抽象类
class Juice{
public:
virtual void show() = 0;
}
//果汁具体类，苹果汁
class AppleJuice : public Juice{
public:
void show(){
cout<<"AppleJuice"<<endl;
}
}
//果汁具体类，葡萄汁
class GrapeJuice : public Juice{
public:
void show(){
cout<<"GrapeJuice"<<endl;
}
}
//工厂类
class Factory{
public:
Juice* getJuice(int type){
switch (type){
case APPLE:
return new AppleJuice();
case GRAPE:
return new GrapeJuice();
default:
break;
}
return NULL;
}
}
//主函数的使用
int main()
{
Factory* fac = new Factory();
Juice* applejuice1 = fac.getJuice(APPLE);
Juice* grapejuice1 = fac.getJuice(GRAPE);
delete fac;
delete applejuice1;
delete grapejuice1;
}
2）工厂方法
工厂方法在于为每一种产品建立一个工厂。一个工厂只生产一种产品。
因此需要同时包含产品抽象类和工厂抽象类。
优点：增加新的产品不需要修改原来的代码。
//果汁抽象类
class Juice{
public:
virtual void show() = 0;
}
//果汁具体类，苹果汁
class AppleJuice : public Juice{
public:
void show(){
cout<<"AppleJuice"<<endl;
}
}
//果汁具体类，葡萄汁
class GrapeJuice : public Juice{
public:
void show(){
cout<<"GrapeJuice"<<endl;
}
}
//工厂抽象类
class Factory{
public:
virtual Juice* createJuice() = 0
}
//苹果汁工厂类
class AppleJuiceFactory{
public:
Juice* createJuice(){
return new AppleJuice();
}
}
class GrapeJuiceFactor{
public:
Juice* createJuice(){
return new GrapeJuice();
}
}
int main(){
Factory* fac1 = new AppleJuiceFactory();
Factory* fac2 = new GrapeJuiceFactory();
Juice* applejuice1 = fac1.createJuice();
Juice* grapeJuice1 = fac2.createJuice();
//delete...
}
3）抽象工厂模式
让一个工厂拥有好几条产品线。
优点：方便扩展新的产品系列
缺点：增加新的产品时，需要修改所有工厂
//果汁抽象类
class Juice{
public:
virtual void show() = 0;
}
class Jam{
public:
virtual void show() = 0;
}
//果汁具体类，苹果汁
class AppleJuice : public Juice{
public:
void show(){
cout<<"AppleJuice"<<endl;
}
}
//果汁具体类，葡萄汁
class GrapeJuice : public Juice{
public:
void show(){
cout<<"GrapeJuice"<<endl;
}
}
//果酱具体类，苹果酱
class AppleJam: public Jam{
public:
void show(){
cout<<"AppleJam"<<endl;
}
}
//果酱具体类，葡萄酱
class GrapeJam: public Jam{
public:
void show(){
cout<<"GrapeJam"<<endl;
}
}
//工厂抽象类
class Factory{
public:
virtual Juice* createJuice() = 0;
virtual Jam* createJam() = 0;
}
//工厂具体类，苹果工厂
class AppleFactory{
public:
Juice* createJuice(){
return new AppleJuice();
}
Jam* createJame(){
return new AppleJam();
}
}
//工厂具体类，葡萄工厂
class GrapeFactory{
public:
Juice* createJuice(){
return new GrapeJuice();
}
Jam* createJame(){
return new GrapeJam();
}
}
int main(){
Factory* fac1 = new AppleFactory();
Juice* applejuice1 = fac1.createJuice();
Jam* applejam1 = fac1.createJam();
Factory* fac2 = new GrapeFactory();
Juice* grapeJuice2 = fac2.createJuice();
Jam* grapejam2 = fac2.createJam()''
}