简单工厂|工厂方法|抽象工厂模式

设计模式的分类

 

总体来说设计模式分为三大类：

 

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

 

六大原则

http://www.2cto.com/kf/201606/520418.html

 

 

(一)简单工厂模式

http://blog.csdn.net/dwb1015/article/details/18094583

在不确定会有多少个处理操作时应该考虑使用简单工厂模式，如针对同样的接收到的数据，处理的逻辑可能会不同，可能以后还会增加新的操作。

案例：

例如如果实现计算器的功能时，对于同样的输入数据，可能执行加、减、乘、除，甚至其他的功能。因此可以抽象出一个操作的抽象类或是接口，提供一个统一的处理方法(此处为process)，然后每种操作创建出一个子类出来。而判断具体使用哪个具体的实现类是在工厂类中进行判断的(将存放操作的变量传递给工厂的生产方法)。工厂类始终返回的是这个抽象类，这样如果对原有功能进行更改或是新添加新的功能，也不会对原来的其他类做修改，只编译修改的那个类或是新的类就可以了。

这样就做到了把耦合降到最低，同时也便于维护。

注意：如果客户提出要再添加一个功能来处理这些数据，实现起来就灰常方便了

项目结合：

       计算某区域的形状因子，，平均亮度，等效圆半径，最大最小Frete直径，等，输入是这个区域的坐标的集合，输出是对应的数据。

      

      产品有自己的基类和派生类，分别定义不同的操作。工厂类只是负责创建一个统一的处理方法，返回一个具体方法的基类引用。根据不同的参数返回一个指向子类的指针。

工厂对象的工厂函数根据用户输入,自动new出一个子类对象并返回其父类的指针,这样利用父类的指针执行父类的虚函数,就可以动态绑定子类的重写函数,从而实现多态

 

class _operation1{
 
 
 
public:
         int a, b;
         char c;
 
         virtual double Getresult(){ return 0; };
};
 
class add :public _operation1{
         virtual double Getresult(){ return a + b; };
 
};
 
class mul :public _operation1{
         virtual double Getresult(){ return a * b; };
 
};
class sub :public _operation1{
         virtual double Getresult(){ return a - b; };
 
};
class jian :public _operation1{
         virtual double Getresult()
         {
                   if (-0.000001 < b&&b < 0.000001)
                   {
                            //cout << "shabi" << endl;
                            throw b;
 
                   }
 
                   return a / b;
         }
 
};
 
class Factory{
public:
         static _operation1 *  createoperation(char ch){
 
 
                   switch (ch)
                   {
                   default:
                            throw exception("非法操作符");
                   case'+':
                            return new add();
                   case '-':
                            return new sub();
                   case'*':
                            return new mul();
                   case '/':
                            return new jian();
 
                   }
         }
};
 
 
int _tmain(int argc, _TCHAR* argv[])
{
 
         int a = 0;
         int b = 0;
         char ch = '\0';
         cin >> a >> ch>> b;
 
         try{
                   shared_ptr <_operation1> p(Factory::createoperation(ch));
                   try{
                            p->a = a;
                            p->b = b;
                            cout << p->Getresult()<< endl;
                   }
                   catch (int)
                   {
 
                            cout << "除数不能为0000" << endl;
                            exit(1);
                   }
         }
         catch (exception& e)
         {
                   cout << e.what() << endl;
         }
 
 
         return 0;
}
return 0;
}

try catch：

http://jingyan.baidu.com/article/358570f64128c6ce4624fc55.html

 

 

(二)工厂方法模式

 

简单工厂模式在工厂类里面不仅定义了方法，还指明了根据输入的不同调用哪个产品的生产子类。这样的缺点就是：每次增加一种产品，除了增加产品生产线（产品子类），还要在工厂类里面去增加，这样违背了封闭原则。

开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。于是，工厂方法模式出现了。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

只在工厂类内声明方法，而具体实例化哪一个产品生产线由工厂的子类决定，这样，在客户端用的时候，需要实例化哪个产品就直接在客户端代码里面增加工厂对应的子类，实现增删减改。不用再到工厂类里面去增加case语句了。

class Factory{
public:
         virtual _operation1* createoperation(char ch) {
                   throw exception("非法操作符");
 
         }
};
 
class Factory_add :public  Factory{
public:
         virtual _operation1* createoperation(char ch)
         {
                   return new add();
         }
};
class Factory_sub :public Factory{
public:
         virtual _operation1* createoperation(char ch)
         {
                   return new sub();
         }
};
class Factory_mul :public Factory{
public:
         virtual _operation1* createoperation(char ch)
         {
                   return new mul();
         }
};
class Factory_jian :public Factory{
public:
         virtual _operation1* createoperation(char ch)
         {
                   return new jian();
         }
};
/*工厂方法模式*/
 
 
int _tmain(int argc, _TCHAR* argv[])
{
         int a = 0;
         int b = 0;
         char ch = '\0';
         cin >> a >> ch>> b;
 
         Factory * fac;   
        
         try{
 
                   switch (ch)
                   {
                   default:
                            fac = new Factory;
                            break;
                   case'+':
                            fac = new Factory_add;
                            break;
                   case '-':
                            fac = new Factory_sub;
                            break;
                   case'*':
                            fac = new Factory_mul;
                            break;
                   case '/':
                            fac = new Factory_jian;
                            break;
 
                   }
                   shared_ptr<_operation1> p(fac->createoperation(ch));
                   try{
                            p->a = a;
                            p->b = b;
                            cout << p->Getresult()<< endl;
                   }
                   catch (int)
                   {
 
                            cout << "除数不能为0000" << endl;
                            exit(1);
                   }
         }
         catch (exception& e)
         {
                   cout << e.what() << endl;
         }
 
 
         return 0;
 
}

用到哪个运算，就在客户端（main）代码里面new一个工厂子类就可以了。

 

(三)抽象工厂模式

这个好抽象的感觉。

http://blog.csdn.net/wuzhekai1985/article/details/6660462

抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

什么j8玩意。

我理解的就是工厂模式下工厂类只定义了一种方法，而抽象模式下工厂类可以定义多个方法，生产多个产品。

http://ichennan.com/2016/08/09/DesignPattern.html