工作模式是由面向对象语言特性得来的固定模式,也就是套路。
其设计原则主要有:
OCP-开放封闭原则:开放扩展,封装更改;
LSP-里氏代换原则:子类必须能够替换其父类;
DIP-依赖倒转原则:抽象不应依赖细节,细节应依赖抽象(面向接口);
ISP-接口隔离原则:一个类对另外一个类的依赖应当建立在最小的接口上;
CARP-合成/聚合复用原则:尽量使用合成/聚合,尽量不要使用继承(因继承是强偶合);
LoD-迪米特法则:若两个类不必直接通信,则不应直接交互。成员该私有要私有;
SRP-单一职责原则:就一个类而言,应该仅有一个引起它变化的原因;
工作模式可以分为三大类,即:创建型模式,结构性模式和行为型模式;
这篇主要实现创建型模式中的工厂模式:
简单工厂模式:
#include <iostream>
using namespace std;
class Car //产品模板类;
{
public:
virtual void show() = 0; //虚函数;
};
class BMW:public Car //具体产品类,继承于产品模板;
{
public:
void show()
{
cout << "BWM" << endl; //具体实现函数;
}
};
class SLK:public Car
{
public:
void show()
{
cout << "SLK" << endl;
}
};
class MINI:public Car
{
public:
void show()
{
cout << "MINI" << endl;
}
};
class Factory //工厂类
{
public:
Car *GreatBMW() //产品生产函数;
{
return new BMW; //返回值为创建的产品对象;
}
Car *GreatSLK()
{
return new SLK;
}
Car *GreatMINI()
{
return new MINI;
}
};
int main()
{
Car *car = NULL; //模板产品指针;
Factory *f = new Factory; //构造一个工厂指针指向工厂类,即创建一个工厂对象;
car = f->GreatBMW(); //产品指针指向产品生产函数创建的具体产品对象;
car->show();
delete car; //释放产品指针
car = f->GreatSLK();
car->show();
delete car;
car = f->GreatMINI();
car->show();
delete car;
delete f; //释放工厂指针;
return 0;
}
简单工厂模式是由一个工程对象决定创建出哪种实例,即只有一个工厂,由工厂指针指向具体产品生产函数;
工厂方法模式:
#include <iostream>
using namespace std;
class Car
{
public:
virtual void show() = 0;
};
class BMW:public Car
{
public:
void show()
{
cout << "BWM" << endl;
}
};
class SLK:public Car
{
public:
void show()
{
cout << "SLK" << endl;
}
};
class MINI:public Car
{
public:
void show()
{
cout << "MINI" << endl;
}
};
class Factory //生产工厂模板类;
{
public:
virtual Car * Great() = 0; //产品生产虚函数;
};
class BMWFactory:public Factory //具体产品工厂类;
{
public:
Car *Great()
{
return new BMW; //具体产品生产函数;
}
};
class SLKFactory:public Factory
{
public:
Car *Great()
{
return new SLK;
}
};
class MINIFactory:public Factory
{
public:
Car *Great()
{
return new MINI;
}
};
int main()
{
Car *car = NULL;
Factory *f = NULL;
f = new BMWFactory; //工厂指针指向创建的具体的产品工厂;
car = f->Great(); //产品指针指向产品生产函数;
car->show();
delete car;
delete f;
f = new SLKFactory;
car = f->Great();
car->show();
delete car;
delete f;
f = new MINIFactory;
car = f->Great();
car->show();
delete car;
delete f;
return 0;
}
工厂方法模式将原本的工厂类变成模板生产工厂类,具体的产品生产函数扩展为具体的产品生产工厂类便于,调用更加方便,增加产品时也不需要修改工厂类;
抽象工厂模式:
#include <iostream>
using namespace std;
class Fruit
{
public:
virtual void show() = 0;
};
class Northapple:public Fruit
{
public:
void show()
{
cout << "Northapple" << endl;
}
};
class Northpeach:public Fruit
{
public:
void show()
{
cout << "Northpeach" << endl;
}
};
class Southapple:public Fruit
{
public:
void show()
{
cout << "Southapple" << endl;
}
};
class Southpeach:public Fruit
{
public:
void show()
{
cout << "Southpeach" << endl;
}
};
class Manor //模板工厂类;
{
public:
virtual Fruit *Greatapple() = 0; //产品生产虚函数;
virtual Fruit *Greatpeach() = 0;
};
class Northmanor:public Manor //北方工厂类;
{
public:
Fruit *Greatapple()
{
return new Northapple;
}
Fruit *Greatpeach()
{
return new Northpeach;
}
};
class Southmanor:public Manor //南方工厂类;
{
public:
Fruit *Greatapple()
{
return new Southapple;
}
Fruit *Greatpeach()
{
return new Southpeach;
}
};
int main()
{
Fruit *f = NULL;
Manor *m = NULL;
m = new Southmanor;
f = m->Greatapple();
f->show();
f = m->Greatpeach();
f->show();
delete f;
delete m;
m = new Northmanor;
f = m->Greatapple();
f->show();
f = m->Greatpeach();
f->show();
delete f;
delete m;
return 0;
}
抽象工厂模式是在工厂模式上再进行抽象的工厂模式,将具有相同属性的产品归属于此属性的工厂,满足依据属性调用生产工厂的需求。