创建型模式-工厂模式

淡淡的烟草味﹌ 2022-05-06 23:36 244阅读 0赞

## 简单工厂模式 ##

*  又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
 *  简单工厂UML类图：  
    ![在这里插入图片描述][20181014144444181]

水果抽象类

class Fruit
    { 
    public:
          virtual void GetName()=0;
    }

具体水果实现：

class Apple : public Fruit
    { 
    public:
           virtual void GetName()
           { 
               cout << "我是苹果"<< endl;
           }
    }
    
    class Banana: public Fruit
    { 
    public:
           virtual void GetName()
           { 
               cout << "我是香蕉"<< endl;
           }
    }
    
    
    再有葡萄，直接添加 葡萄类 实现 水果抽象 即可

简单工厂

class Factory
    { 
    public:
    	  Fruit* CreatFruit(string name)
    	  { 
    			if(name == "apple")
    			  return new apple;
    			  
    			if(name == "banana")
    			  return new banana;
     	  }
    }
    
    当我们再多了一个葡萄的时候，需要更改源代码去添加，这样违背了开闭原则

调用

int main(void)
    { 
    	Factory* factory =new Factory;
    	Fruit* fruit=factory->CreatFruit("apple");
    	fruit->GetName();
    	delete fruit;
        fruit = NULL;
    	
    	fruit = factory->CreatFruit("banana");
    	fruit->GetName();
    	delete fruit;
    	fruit = NULL;
    
    	return 0;
    }

*  优点：  
       （1）实现对象创建和使用的分离  
       （2）不需要记住具体类名，记住工厂给出接口的参数即可
 *  缺点：  
       （1）如果类很多，工厂职责过重，一旦不能工作，系统瘫痪  
       （2）违背了开闭原则，增加类，需要修改工厂源代码  
      
    
 *  使用场景：  
        （1）工厂负责创建的类对象比较少，这样不会造成业务逻辑复杂  
        （2）调用者只需要知道传入工厂的参数即可，对于具体如何创建对象并不关心

--------------------

## 工厂方法模式 ##

*  工厂方法UML类图：调用者想创建一种水果，调用具体工厂  
    ![在这里插入图片描述][20181014153850642]

水果抽象类

class Fruit
    { 
    public:
          virtual void GetName()=0;
    }

具体水果实现：

class Apple : public Fruit
    { 
    public:
           virtual void GetName()
           { 
               cout << "我是苹果"<< endl;
           }
    }
    
    class Banana: public Fruit
    { 
    public:
           virtual void GetName()
           { 
               cout << "我是香蕉"<< endl;
           }
    }
    
    
    再加一个梨水果
    
    class Pear: public Fruit
    { 
    public:
           virtual void GetName()
           { 
               cout << "我是梨"<< endl;
           }
    }

抽象工厂

class Factory
    { 
    public:
    		virtual Fruit* CreatFruit() =0;
    }

水果工厂

class AppleFactory
    { 
    public:
    		virtual Fruit* CreatFruit()
    		{ 
    			return new Apple;
    		}	
    }
    
    class BananaFactory
    { 
    public:
    		virtual Fruit* CreatFruit()
    		{ 
    			return new Banana;
    		}	
    }
    
    如果添加了个梨
    
    classPearFactory
    { 
    public:
    		virtual Fruit* CreatFruit()
    		{ 
    			return new Pear;
    		}	
    }

调用

int main(void)
    { 
    	Factory* factory=NULL;
    	Fruit*   fruit=NULL;
    	
    	factory = new AppleFactory;
        fruit= app_factory->CreatFruit();
        fruit->GetName();
        delete app_factory;
        delete fruit;
    
    
    	factory = new BananaFactory;
        fruit= factory->CreatFruit();
        fruit->GetName();
        delete Bana_Factory;
        delete fruit;
        
    	return 0;
    }

*  优点：  
       （1）实现对象创建和使用的分离  
       （2）不需要记住具体类名，记住工厂给出接口的参数即可  
       （3）系统扩展性变得很好，不需要修改源代码，符合开闭原则
 *  缺点：  
       （1）增加系统类的个数，复杂度提高

*  使用场景：  
        （1）具体工厂来创建对象  
        （2）调用者只需要知道传入工厂的参数即可，对于具体如何创建对象并不关心

[20181014144444181]: /images/20220506/103d41e677bb45c69df454486a67fae9.png
[20181014153850642]: /images/20220506/ace3a73751d84b9d8a8e46e05da792a8.png