c++ & python 工厂模式

简单工厂模式

简单工厂模式有一个工厂，可以生产多个产品，包含两个接口，一个是产品类的，一个是工厂类的。
产品类需要有一个基类，基类中的具体产品实现需要是个纯虚函数，这样一来，产品的子类必须要重写具体的产品实现，实现不同的功能。
产品类封装完成后，还需要一个工厂类，工厂类对产品类再次封装，最终实现由一个工厂对象决定创建出哪一种产品类的实例。

1、c++版本

//简单工厂模式
#include<iostream>
using namespace std;

//产品的基类
class Product{
public:
   //基类中的纯虚函数
	virtual int operation(int a, int b) = 0;
};

//产品的子类Add
class Product_Add : public Product{
public:
	int operation(int a, int b){
		return a + b;
	}
};

//产品的子类Mul
class Product_Mul : public Product{
public:
	int operation(int a, int b){
		return a * b;
	}
};
//工厂
class Factory{
public:
	Product* Create(int i){
		switch (i){
		case 1:
			return new Product_Add;
			break;
		case 2:
			return new Product_Mul;
			break;
		default:
			break;
		}
	}
};

int main()
{
	Factory *factory = new Factory();
	int add_result = factory->Create(1)->operation(1, 2);
	int mul_result = factory->Create(2)->operation(1, 2);
	cout <<"op_add：" <<add_result << endl;
	cout <<"op_multiply：" << mul_result << endl;
		getchar();
	return 0;
}

上面的代码中实现了两个产品，一个“加”，一个“乘”，选择哪一种操作完全由工厂类封装的Create()来决定。
但是简单工厂模式违背开放-封闭原则，即对扩展开放，对修改封闭。因为要添加第三个产品“减”时，需要修改工厂类的代码。

2、python版本

#产品类
class Person:
   def __init__(self):
       self.name = None
       self.gender = None
       
   def getName(self):
       return self.name
   
   def getGender(self):
       return self.gender

#产品子类
class Male(Person):
   def __init__(self, name):
       print "Hello Mr." + name
       
#产品子类
class Female(Person):
   def __init__(self, name):
       print "Hello Miss." + name

#工厂类
class Factory:
   def getPerson(self, name, gender):
       if gender == ‘M':
               return Male(name)
           if gender == 'F':
               return Female(name)

if __name__ == '__main__':
   factory = Factory()
   person = factory.getPerson("Chetan", "M")

例子2

##这里没有产品基类
# 产品子类
class YilanteCar(object):
   def move(self):
       print("---车在移动---")
   def stop(self):
       print("---停车---")
       
#产品子类
class SuonataCar(object):
   def move(self):
       print("---车在移动---")
   def stop(self):
       print("---停车---")
       
#工厂类
class CarFactory(object):
   def createCar(self,typeName):
       self.typeName = typeName
       if self.typeName == "伊兰特":
           self.car = YilanteCar()
       elif self.typeName == "索纳塔":
           self.car = SuonataCar()
       return self.car
       
#调用工厂类，接口，基类；相当于对工厂类进行更高一层的封装
class CarStore(object):
  #类似虚函数
   def createCar(self, typeName):
       pass

   def order(self, typeName):
       # 让工厂根据类型，生产一辆汽车
       self.car = self.createCar(typeName)
       self.car.move()
       self.car.stop()

#继承接口基类
class XiandaiCarStore(CarStore):
   def createCar(self, typeName):
       self.carFactory = CarFactory()
       return self.carFactory.createCar(typeName)
       
if __name__ == '__main__':
   suonata = XiandaiCarStore()
   suonata.order("索纳塔")