工厂模式(静态工厂模、工厂方法模式、抽象工厂模式) //代码用C++实现  部分是从大神们那里学来的

简单工厂模式 组成：1 工厂类角色 2抽象产品角色 3具体产品角色

//简单工厂模式
//抽象产品角色
class Car{
  virtual void drive() = 0;
};
//具体产品角色
class Benz:public Car{
 void drive(){
  cout<<"Driving Benz"<<endl;
}
};

class Bmw:public Car{
 void drive(){
 cout<<"Driving Bmw"<<endl;
}
};
.....

//工厂类角色
class Driver{
 static Car DriverCar(string s)
{
   if("Benz“ == s)
      return new Benz();
   if("Bmw" == s)
      return new Bmw();
 }
};

//具体产品角色
void main()
{
 Car *car = Driver.DriverCar("benz");
 car.drive();
 }


二、工厂方法模式
 工厂方法去掉了简单工厂模式中工厂方法的静态属性，使得它可以被子类继承。
结构如下：
1 抽象工厂角色
2 具体工厂解难
3 抽象产品角色
4 具体产品角色
//抽象产品角色
//抽象产品角色
class Car{
public: 
virtual void drive() = 0;
};
//具体产品角色
class Benz:public Car{
public: 
void drive(){
  cout<<"Driving Benz"<<endl;
}
};
//抽象工厂角色
class  Driver{
public: 
virtual Car driveCar() = 0;
};
class BenzDriver:public Driver{
 private:
 public:
 Car driverCar(){
  return new Benz();
}
};

class BmwDriver:public Driver{
private:
public:
 Car driverCar(){
 return new Bmw();
}
};
//爆发户上场
void main()
{
  Driver *pDriver = new BenzDriver();
  Car car =  driver.driverCar();
  car.drive();
}

小结：也许在下面情况你可以考虑使用工厂方法模式：
1.当客户程序不需要知道要使用对象的创建过程。
2.客户程序使用的对象存在变动的可能，或者根本就不知道哪一个具体的对象。


三：抽象工厂模式
抽象工厂模式的用意为：给客户提供一个接口，可以创建多个族中的产品对象而且使用抽象工厂模式还要满足下列条件：
1）系统中有多个产品族，而系统一次只可能消费消费基中一族产品
2）同属于同一个产品族的产品以其使用。

1.抽象工厂角色
2.具体工厂角色
3.抽象产品角色
4.具体产品角色

//抽象基类
class AbstractProduct{
private:
public:
  virtual void fun() = 0;
};

class Product1:public AbstractProduct{
 void fun()
 {
  cout<<"product1"<<endl;
 }
};

class Product2:public AbstractProduct{
  void fun()
{ 
 cout<<"product2"<<endl;
}
};


class AbstractProductnew{
  virtual void fun1() = 0;
};
class Productnew1:public AbstractProductnew{
  void fun1()
{
 cout<<"cproductnew 1"<<endl;
}
};

class productnew2:public AbstractProductnew{
 void fun1()
{
 cout<<"productnew2"<<endl;
}
};
// 抽象基类AbstractFactory,工厂的抽象类,生产产品A和产品B
class AbstractFactory{
 public:
 virtual AsbtractProduct* CreateProduct() = 0;
 virtual AsbtractProductnew* Createproductnew() = 0;
};
   
// 派生类ConcreateFactory1,继承自AbstractFactory
// 生产产品A和产品B的第一种实现
class ConcreateFactory1:public AbstractFactory{
   AsbtractProduct* CreateProduct()
{
 cout<<"ConcrateFactory1"<<endl;
}
AsbtractProductnew* Createproductnew()
{
  cout<<"ConcteateFactory11"<<endl;
}
};

// 派生类ConcreateFactory2,继承自AbstractFactory
// 生产产品A和产品B的第2种实现
class ConcreateFactory1:public AbstractFactory{
   AsbtractProduct* CreateProduct()
{
 cout<<"ConcrateFactory2"<<endl;
}
AsbtractProductnew* Createproductnew()
{
  cout<<"ConcteateFactory22"<<endl;
}
};//代码只是伪代码 想运行需要自行修改