本篇开始记录实现设计模式在工作中的两种常见语言上的实现。
本篇介绍最简单的工厂模式。
工厂模式有一种非常形象的描述，建立对象的类就如一个工厂，而需要被建立的对象就是一个个产品；在工厂中加工产品，使用产品的人，不用在乎产品是如何生产出来的。从软件开发的角度来说，这样就有效的降低了模块之间的耦合。
使用情景：
在不确定会有多少个处理操作时应该考虑使用简单工厂模式，如针对同样的接收到的数据，处理的逻辑可能会不同，可能以后还会增加新的操作。
案例：
如果实现计算器的功能时，对于同样的输入数据，可能执行加、减、乘、除，甚至其他的功能。因此可以抽象出一个操作的抽象类或是接口，提供一个统一的处理方法(此处为process)，然后每种操作创建出一个子类出来。而判断具体使用哪个具体的实现类是在工厂类中进行判断的(将存放操作的变量传递给工厂的生产方法)。工厂类始终返回的是这个抽象类，这样如果对原有功能进行更改或是新添加新的功能，也不会对原来的其他类做修改，只编译修改的那个类或是新的类就可以了。
这样就做到了把耦合降到最低，同时也便于维护。
简单工厂：针对同样的数据，不同的操作用同一个接口
工厂方法：针对同样的数据，不同的操作用不同的接口
抽象工厂：针对不同的数据，不同的操作用不同的接口
一：简单工厂模式
1.简单工厂C++中的实现：
#include <iostream>
using namespace std;
class ICarFactory{
public:
ICarFactory(){}
virtual ~ICarFactory(){}
virtual void produceCar() = ;
};
class CarFactoryBenz:public ICarFactory{
public:
void produceCar(){
cout<<"Produce a car of Benz"<<endl;
}
};
class CarFactoryVolkswagen: public ICarFactory{
public:
void produceCar(){
cout<<"Produce a car of Volkswagen"<<endl;
}
};
int main()
{
ICarFactory *car1 = new CarFactoryBenz();
ICarFactory *car2 = new CarFactoryVolkswagen();
car1->produceCar();
car2->produceCar();
return ;
}
2.简单工厂Java中的实现：
public interface ICarFactory {
public void produceCar();
}
public class FactoryBenz implements ICarFactory{
public void produceCar() {
System.out.println("Produce a car of Benz");
}
}
public class FactoryToyota implements ICarFactory{
public void produceCar() {
System.out.println("Produce a car of Toyota");
}
}
public class Main {
public static void main(String[] args){
FactoryBenz factoryBenz = new FactoryBenz();
FactoryToyota factoryToyota = new FactoryToyota();
factoryBenz.produceCar();
factoryToyota.produceCar();
}
}
二：工厂方法模式
1.工厂方法模式在C++中的实现
核心思想：将工厂抽象出来，将产品抽象出来，子工厂负责new 子产品指针，返回抽象产品类指针，外面调用时只需要生成基类工厂指针，调用创建产品函数，就可以对该产品进行具体的操作，优点是能够将添加产品完全独立出来不再修改内部代码。
与简单工厂比较：修正了简单工厂模式中不遵循开放---封闭原则，例如添加新产品时仍需要修改工厂基类内容，工厂方法模式将判断移动到客户端实现。
#include <iostream>
using namespace std;
class ICar{
public:
ICar(void){}
~ICar(void){}
virtual void printInfo() = ;
};
class CarBenz:public ICar{
public:
CarBenz(){}
~CarBenz(){}
void printInfo(){
cout<<"The brand is Benz"<<endl;
}
};
class CarToyota:public ICar{
public:
CarToyota(){}
~CarToyota(){}
void printInfo(){
cout<<"The brand is Toyota"<<endl;
}
};
class IFactory{
public:
IFactory(void){}
~IFactory(void){}
virtual ICar* produceCar() = ;
};
class FactoryBenz:public IFactory{
public:
FactoryBenz(){}
~FactoryBenz(){}
ICar* produceCar(){
cout<<"Produce a car of Benz"<<endl;
ICar* car = new CarBenz();
return car;
}
};
class FactoryToyota:public IFactory{
public:
FactoryToyota(){}
~FactoryToyota(){}
ICar* produceCar(){
cout<<"Produce a car of Toyota"<<endl;
ICar* car = new CarToyota();
return car;
}
};
int main()
{
IFactory* factory = new FactoryBenz();
ICar* car = factory->produceCar();
car->printInfo();
IFactory* factory2 = new FactoryToyota();
ICar* car2 = factory2 ->produceCar();
car2->printInfo();
return ;
}
输出：
Produce a car of Benz
The brand is Benz
Produce a car of Toyota
The brand is Toyota
2.工厂方法模式在Java中的实现
public interface ICar {
void printInfo();
}
public class CarBenz implements ICar {
public void printInfo(){
System.out.println("The brand is Benz");
}
}
public class CarToyota implements ICar{
public void printInfo(){
System.out.println("The brand is toyota");
}
}
public interface ICarFactory {
ICar produceCar();
}
public class FactoryBenz implements ICarFactory{
public ICar produceCar(){
System.out.println("Produce a Benz car");
return new CarBenz();
}
}
public class FactoryToyota implements ICarFactory{
public ICar produceCar(){
System.out.println("Produce a Toyota car");
return new CarToyota();
}
}
public class Main {
public static void main(String[] args){
ICarFactory factoryBenz = new FactoryBenz();
ICarFactory factoryToyota = new FactoryToyota();
ICar benz = factoryBenz.produceCar();
ICar toyota = factoryToyota.produceCar();
benz.printInfo();
toyota.printInfo();
}
}
输出：
Produce a Benz car
Produce a Toyota car
The brand is Benz
The brand is toyota
三：抽象工厂模式
1.C++实现抽象工厂
#include <iostream>
using namespace std;
class ICarToyota{
public:
ICarToyota(){}
~ICarToyota(){}
virtual void printInfo() = ;
};
class CarToyotaChr:public ICarToyota{
public:
CarToyotaChr(){}
~CarToyotaChr(){}
void printInfo(){
cout<< "The car is Toyota C-HR"<<endl;
}
};
class CarToyotaCarolla:public ICarToyota{
public:
CarToyotaCarolla(){}
~CarToyotaCarolla(){}
void printInfo(){
cout<< "The car is Toyota Carolla"<<endl;
}
};
class ICarAudi{
public:
ICarAudi(){}
~ICarAudi(){}
virtual void printInfo()=;
};
class CarAudiA3:public ICarAudi{
public:
CarAudiA3(){}
~CarAudiA3(){}
void printInfo(){
cout<< "The car is audi a3"<<endl;
}
};
class CarAudiQ5:public ICarAudi{
public:
CarAudiQ5(){}
~CarAudiQ5(){}
void printInfo(){
cout<< "The car is audi q5"<<endl;
}
};
class IFactory{
public:
IFactory(){}
~IFactory(){}
virtual ICarToyota* produceCarToyota()=;
virtual ICarAudi* produceCarAudi()=;
};
class FactoryCompact:public IFactory{
public:
FactoryCompact(){}
~FactoryCompact(){}
ICarAudi* produceCarAudi(){
cout<<"Produce a audi compact car"<<endl;
return new CarAudiA3;
}
ICarToyota* produceCarToyota(){
cout<<"Produce a toyota compact car"<<endl;
return new CarToyotaCarolla;
}
};
class FactorySuv:public IFactory{
public:
FactorySuv(){}
~FactorySuv(){}
ICarAudi* produceCarAudi(){
cout<<"Produce a audi suv"<<endl;
return new CarAudiQ5;
}
ICarToyota* produceCarToyota(){
cout<<"Produce a toyota suv"<<endl;
return new CarToyotaChr;
}
};
int main()
{
FactoryCompact factory1;
FactorySuv factory2;
ICarAudi* audi1;
ICarAudi* audi2;
ICarToyota* toyota1;
ICarToyota* toyota2;
audi1 = factory1.produceCarAudi();
audi1->printInfo();
audi2 = factory2.produceCarAudi();
audi2->printInfo();
toyota1 = factory1.produceCarToyota();
toyota1->printInfo();
toyota2 = factory2.produceCarToyota();
toyota2->printInfo();
}
输出：
Produce a audi compact car
The car is audi a3
Produce a audi suv
The car is audi q5
Produce a toyota compact car
The car is Toyota Carolla
Produce a toyota suv
The car is Toyota C-HR
2.Java实现抽象工厂
public interface ICarAudi {
void printInfo();
}
public class CarAudiA3 implements ICarAudi {
public void printInfo() {
System.out.println("The car is Audi A3");
}
}
public class CarAudiQ5 implements ICarAudi {
public void printInfo() {
System.out.println("The car is Audi Q5");
}
}
public interface ICarToyota {
void printInfo();
}
public class CarToyotaCarolla implements ICarToyota {
public void printInfo() {
System.out.println("The car is Toyota Carolla");
}
}
public class CarToyotaChr implements ICarToyota {
public void printInfo() {
System.out.println("The vehicle is toyota C-HR");
}
}
public interface IFactory {
ICarAudi produceAudi();
ICarToyota produceToyota();
}
public class FactoryCompact implements IFactory {
public ICarAudi produceAudi() {
System.out.println("Produce an audi compact");
return new CarAudiA3();
}
public ICarToyota produceToyota() {
System.out.println("Produce a toyota compact");
return new CarToyotaCarolla();
}
}
public class FactoryCompact implements IFactory {
public ICarAudi produceAudi() {
System.out.println("Produce an audi compact");
return new CarAudiA3();
}
public ICarToyota produceToyota() {
System.out.println("Produce a toyota compact");
return new CarToyotaCarolla();
}
}
public class Main {
public static void main(String[] args){
FactoryCompact factoryCompact = new FactoryCompact();
FactorySuv factorySuv = new FactorySuv();
ICarAudi c1 = factoryCompact.produceAudi();
c1.printInfo();
ICarAudi c2 = factorySuv.produceAudi();
c2.printInfo();
ICarToyota c3 = factoryCompact.produceToyota();
c3.printInfo();
ICarToyota c4 = factorySuv.produceToyota();
c4.printInfo();
}
}
输出：
Produce an audi compact
The car is Audi A3
Produce an audi suv
The car is Audi Q5
Produce a toyota compact
The car is Toyota Carolla
Produce an Toyota suv
The vehicle is toyota C-HR