Unity设计模式之简单工厂模式、工厂方法模式和抽象工厂模式

╰+攻爆jí腚メ 2023-02-26 12:29 53阅读 0赞

## 实例说明 ##

某软件公司要基于C\#语言开发一套图表库，该图表库可以为应用系统提供多种不同外观的图表，例如柱状图(HistogramChart)、饼状图(PieChart)、折线图(LineChart)等。该软件公司图表库设计人员希望为应用系统开发人员提供一套灵活易用的**图表库**，**通过设置不同的参数即可得到不同类型的图表**，而且可以较为方便地对图表库进行扩展，以便能够在将来增加一些新类型的图表。   
现使用**简单工厂模式**来设计该图表库。   
![这里写图片描述][SouthEast]   
(1) Chart：抽象图表接口，充当抽象产品类   
(2) HistogramChart：柱状图类，充当具体产品类   
(3) PieChart：饼状图类，充当具体产品类   
(4) LineChart：折线图类，充当具体产品类   
(5) ChartFactory：图表工厂类，充当工厂类   
(6) Program：客户端测试类

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

## 模式优点 ##

实现了对象创建和使用的分离   
客户端无须知道所创建的具体产品类的类名，只需要知道具体产品类所对应的参数即可   
通过引入配置文件，可以在不修改任何客户端代码的情况下更换和增加新的具体产品类，在一定程度上提高了系统的灵活性

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

## 模式缺点 ##

模式缺点   
工厂类集中了所有产品的创建逻辑，职责过重，一旦不能正常工作，整个系统都要受到影响   
增加系统中类的个数（引入了新的工厂类），增加了系统的复杂度和理解难度   
系统扩展困难，一旦添加新产品不得不修改工厂逻辑   
由于使用了静态工厂方法，造成工厂角色无法形成基于继承的等级结构，工厂类不能得到很好地扩展

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

## 工厂模式适用环境 ##

工厂类负责创建的对象比较少，由于创建的对象较少，不会造成工厂方法中的业务逻辑太过复杂   
客户端只知道传入工厂类的参数，对于如何创建对象并不关心

工厂模式也是封装的思想，把需要频繁创建实例的对象单独封装起来，用的时候可以简单的传给封装函数（工厂）一个标识符参数即可以（生产）得到一个需要的对象实例；

适应的场景：需要频繁复用到一个对象的实例时，可以创建一个生产此实例的工厂。（比如，车厂批量生产汽车，注意是批量，如果仅仅需要一辆车，则没必须搞个工厂，直接手动打造好了）

## 简单工厂模式 ##

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。\*

### 使用举例： ###

一个产品父类（接口）：IWeapons

n个产品子类: WeaponFisrt,  WeaponSecond ...

一个静态工厂类: Factory, 返回一个产品类实例

public class Product : MonoBehaviour {
        /// <summary>
        /// 简单工厂模式
        /// 定义一个共同接口，创建不同的对象，简化创建过程，创建与表示分离
        /// </summary>
        // Use this for initialization
        void Start () {
              //根据不同的条件选择不同的攻击方式
            SimpleFactory.CreateAttack(2).Attack();    
           
        }
    
        // Update is called once per frame
        void Update () {
            
        }

/// <summary>
        /// 举例：游戏中根据不同的攻击范围选择不同的攻击武器
        /// </summary>
        public interface IWeapons//武器接口
        {
            void Attack();
        }

public class WeaponsFirst : IWeapons
        {      
            public virtual void Attack()
            {
                Debug.Log("刀");
            }
        }

public class WeaponsSecond : IWeapons
        {
            public virtual void Attack()
            {
                Debug.Log("机枪");
            }
        }

///简单工厂管理
    
        public class SimpleFactory
        {
            public static IWeapons CreateAttack(int idx)
            {          
                switch (idx)
                {
                    case 1:
                        return new WeaponsFirst();
                    case 2:
                        return new WeaponsSecond();
                    default:
                        return null;
                }
            }
        }
    }

比如我们想生产两种饮料(农夫山泉和脉动)，在不使用任何设计模式时是这样的：

using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
     
    public class Test : MonoBehaviour
    {
     
        void Start()
        {
            Drink drink1 = Instantiate("农夫山泉");
            Drink drink2 = Instantiate("脉动");
        }
        private Drink Instantiate(string type)
        {
            Drink Drink = null;
            if (type.Equals("农夫山泉"))
            {
                Drink = new NongFuShanQuan();
            }
            else if (type.Equals("脉动"))
            {
                Drink = new MaiDong();
            }
            return Drink;
        }
    }

public class Drink
    {
        public int Id;
        public string content;
        /// <summary>
        /// 构造函数创建饮料实体
        /// </summary>
        public Drink()
        {
            GameObject g = new GameObject(this.GetType().FullName);
        }
     
    }

public class NongFuShanQuan : Drink
    {
        public NongFuShanQuan()
        {
            Id = 1;
            content = "500mL";
        }
    }

public class MaiDong : Drink
    {
        public MaiDong()
        {
            Id = 2;
            content = "450mL";
        }
    }

我们把饮料对象的创建工作放在了Instantiate方法中，通过传入的参数来确定要创建的饮料对象。

# 简单工厂模式 #

简单工厂模式将Instantiate方法中的内容封装到一个新的简单工厂类中。

如此我们便可以通过简单工厂类来创建各种饮料。

当需要增加饮料品种时，只需要在简单工厂类里面做修改。（加上新的具体饮料类是都要处理的）

一个产品父类：Drink

N个产品子类：DrinkType1, DrinkType2 ...

public class NongFuShanQuan : Drink
    {
        public NongFuShanQuan()
        {
            Id = 1;
            content = "500mL";
        }
    }
    
    public class MaiDong : Drink
    {
        public MaiDong()
        {
            Id = 2;
            content = "450mL";
        }
    }

一个工厂类：Factory, 返回一个产品类实例

public class DrinkFactory
    {
        public Drink Instantiate(string type)
        {
            Drink Drink = null;
            if (type.Equals("农夫山泉"))
            {
                Drink = new NongFuShanQuan();
            }
            else if (type.Equals("脉动"))
            {
                Drink = new MaiDong();
            }
            return Drink;
        }
    }

测试调用类

using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
     
    public class Test : MonoBehaviour
    {
     
        void Start()
        {
            DrinkFactory factory = new DrinkFactory();
            factory.Instantiate("农夫山泉");
            factory.Instantiate("脉动");
        }
    }

# 工厂方法模式（单厂单品） #

但是增加新的饮料品种我们觉得要修改的地方还是太多了，这样可拓展性比较差，于是工厂方法模式来了

一个产品父类：

N个产品子类：

public class NongFuShanQuan : Drink
    {
        public NongFuShanQuan()
        {
            Id = 1;
            content = "500mL";
        }
    }
    public class MaiDong : Drink
    {
        public MaiDong()
        {
            Id = 2;
            content = "450mL";
        }
    }

一个生产产品父类的工厂父类：

public abstract class DrinkFactory
    {
        public abstract Drink Instantiate();
     
    }

N个对应产品子类的工厂子类

public class NongFuShanQuanFactory : DrinkFactory
    {
        public override Drink Instantiate()
        {
            return new NongFuShanQuan();
        }
    }
    public class MaiDongnFactory : DrinkFactory
    {
        public override Drink Instantiate()
        {
            return new MaiDong();
        }
    }

测试调用类：

using System;
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
     
    public class Test : MonoBehaviour
    {
     
        void Start()
        {
            DrinkFactory nongfushanquanfactory = new NongFuShanQuanFactory();
            DrinkFactory maidongfactory = new MaiDongnFactory();
     
            Drink nongfushanqaun = nongfushanquanfactory.Instantiate();
            Drink maidong = maidongfactory.Instantiate();
     
        }
    }

工厂方法模式核心是专业的工厂生产专业的饮料，简单来讲就是脉动厂只生产脉动饮料，农夫山泉厂只生产农夫山泉。因此我们需要加入新的具体工厂类，并且各自实现父类工厂的生产方法。

但是一个工厂只生产一种饮料太奢侈了，我要生产两个或多个，而且我要开放生产每种饮料的方法，让客户自己选择。于是抽象工厂模式来了：

# 抽象工厂模式（单厂多品） #

一个产品父类：

public class Drink
    {
        public int Id;
        public string content;
        public Drink()
        {
            GameObject g = new GameObject(this.GetType().FullName);
        }
    }

N个产品子类：

public class NongFuShanQuan : Drink
    {
        public NongFuShanQuan()
        {
            Id = 1;
            content = "500mL";
        }
    }
    public class MaiDong : Drink
    {
        public MaiDong()
        {
            Id = 2;
            content = "450mL";
        }
    }
    public class NongFuShanQuan_1000 : Drink
    {
        public NongFuShanQuan_1000()
        {
            Id = 3;
            content = "1000mL";
        }
    }
    public class MaiDong_600 : Drink
    {
        public MaiDong_600()
        {
            Id = 4;
            content = "600mL";
        }
    }

一个能生产多种产品的超级工厂父类：

public abstract class Factory
    {
        public abstract Drink CreateMaiDong();
        public abstract Drink CreateNongFuShanQuan();
    }

N个超级子工厂

public class DrinkFactory : Factory
    {
        public override Drink CreateMaiDong()
        {
            return new MaiDong();
        }
    
        public override Drink CreateNongFuShanQuan()
        {
            return new NongFuShanQuan();
        }
    }

public class OtherDrinkFactory : Factory
    {
        public override Drink CreateMaiDong()
        {
            return new MaiDong_600();
        }
     
        public override Drink CreateNongFuShanQuan()
        {
            return new NongFuShanQuan_1000();
        }
    }

测试调用类：

using System;
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using System.Reflection;
     
    public class Test : MonoBehaviour
    {
     
        void Start()
        {
            Factory factory = new DrinkFactory();
            Drink maidong = factory.CreateMaiDong();
            Drink nongfushanquan = factory.CreateNongFuShanQuan();
            Factory otherfactory = new OtherDrinkFactory();
            Drink coco = otherfactory.CreateMaiDong();
            Drink bear = otherfactory.CreateNongFuShanQuan();
        }
    }

**例二：**

# 简单工厂模式 #

结果

![20200423213956200.png][]

缺点  
没遵从开放封闭原则，每次增加新功能都要修改工厂类。

# 工厂方法模式 #

**UML**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjI3NTYxMQ_size_16_color_FFFFFF_t_70]  
**代码**

**结果**  
![在这里插入图片描述][20200423220723514.png]  
**note：**  
在设计时就考虑到后期会有扩展的情况下，可以使用工厂方法模式；  
产品结构较复杂的情况下，可以使用工厂方法模式；

# 抽象工厂模式 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjI3NTYxMQ_size_16_color_FFFFFF_t_70 1]  
**代码**

#include <iostream>
    using namespace std;
    
    enum PigType{PAIGE, ZHUBAJIE};
    
    class Pig   //猪
    {
    public:
        virtual void getAbility(void) = 0;
    };
    
    class Paige : public Pig //佩奇
    {
    public:
        Paige()
        {
            cout<<"Paige::Paige()"<<endl;
        }
        virtual void getAbility(void)
        {
            cout<<"Paige::toy"<<endl;
        }
        ~Paige()
        {
    
        }
    };
    
    class ZhuBaJie : public Pig //猪八戒
    {
    public:
        ZhuBaJie()
        {
            cout<<"ZhuBaJie::ZhuBaJie()"<<endl;
        }
        virtual void getAbility(void)
        {
            cout<<"ZhuBaJie::三十六变"<<endl;
        }
         ~ZhuBaJie()
        {
            
        }
    };
    
    class LittlePig
    {
    public:
        virtual void getAbility(void) = 0;
    };
    
    class LittlePaige : public LittlePig
    {
    public:
        LittlePaige()
        {
            cout<<"LittlePaige::LittlePaige()"<<endl;
        }
        virtual void getAbility(void)
        {
            cout<<"LittlePaige::toy"<<endl;
        }
        ~LittlePaige()
        {
    
        }
    };
    
    class LittleZhuBaJie : public LittlePig
    {
    public:
        LittleZhuBaJie()
        {
            cout<<"LittleZhuBaJie::LittleZhuBaJie()"<<endl;
        }
        virtual void getAbility(void)
        {
            cout<<"LittleZhuBaJie::三十六变"<<endl;
        }
        ~LittleZhuBaJie()
        {
            
        }
    };
    
    class Factory
    {
    public:
        virtual Pig* createPig(void) = 0;
        virtual LittlePig* createLittlePig(void) = 0;
    };
    
    class PaigeFactory : public Factory //猪厂
    {
    public:
        Pig* createPig(void)
        {
             return new Paige();
        }
        LittlePig* createLittlePig(void)
        {
             return new LittlePaige();
        }
    };
    
    class ZBJFactory : public Factory //猪厂
    {
    public:
        Pig* createPig(void)
        {
             return new ZhuBaJie();
        }
        LittlePig* createLittlePig(void)
        {
             return new LittlePaige();
        }
    };
    
    int main(int argc, char** argv)
    {
        Factory* paigefac = new PaigeFactory();
        Factory* zBJgefac = new ZBJFactory();
        Pig* createPig1 = paigefac->createPig();
        Pig* createPig2 = zBJgefac->createPig();
        LittlePig* createLitPig1 = paigefac->createLittlePig();
        LittlePig* createLitPig2 = zBJgefac->createLittlePig();
        createPig1->getAbility();
        createPig2->getAbility();
        createLitPig1->getAbility();
        createLitPig2->getAbility();
    
        //释放。。delete
        
        return 0;
    }

结果

![在这里插入图片描述][20200423222236269.png]

优缺点

优点：

分离接口和实现  
客户端使用抽象工厂来创建需要的对象，而客户端根本就不知道具体的实现是谁，客户端只是面向产品的接口编程而已。也就是说，客户端从具体的产品实现中解耦。  
使切换产品族变得容易  
因为一个具体的工厂实现代表的是一个产品族，比如上面例子的从戴尔系列到惠普系列只需要切换一下具体工厂  
缺点：  
如果需要给整个产品族添加一个新的产品，那么就需要修改抽象工厂，这样就会导致修改所有的工厂实现类。  
   
  
工厂方法和抽象工厂非常相似，主要区别在于**抽象工厂在具体工厂类中封装的是多个实例的创建方法**，**新增的工厂类可以重写这些方法并且可以在这些方法中自由选择产品**。  
如果用**工厂方法模式 **：

一个脉动厂和农夫山泉厂，脉动厂只负责创建脉动对象，农夫山泉厂只负责创建农夫山泉对象：**单厂单品**

一个佩奇猪厂负责生产佩奇，一个八戒猪厂负责生产八戒：单厂单品

而使用**抽象工厂模式 ：**

一个饮料厂，该饮料厂既负责创建脉动，也负责创建农夫山泉，当然也可以负责创建需要的其他饮料：**单厂多品**

**    一个猪厂，能生产多种类型的猪：单厂多品，多厂多品**

note  
模式策略是一种定义一系列算法的方法，从概念上看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。实践中只要在分析过程出现需要在不同时间应用不同的业务规则，就可以考虑使用策略模式。  
优点：  
Strategy类为Context定义了一系列可供重用的算法或行为，继承有助于取出这些算法中的公共功能；  
简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。

异同  
两者结构类似  
使用方向不同  
工厂是创建型模式,它的作用就是创建并返回对象，由客户自己做动作；  
策略是行为型模式,它的作用是让一个对象在许多行为中选择一种行为，并执行;  
关注点不一样  
一个关注对象创建  
一个关注行为的封装  
解决不同的问题  
工厂模式是创建型的设计模式，它接受指令，创建出符合要求的实例；它主要解决的是资源的统一分发，将对象的创建完全独立出来，让对象的创建和具体的使用客户无关。主要应用在多数据库选择，类库文件加载等。  
策略模式是为了解决的是策略的切换与扩展，更简洁的说是定义策略族，分别封装起来，让他们之间可以相互替换，策略模式让策略的变化独立于使用策略的客户。

工厂相当于黑盒子，策略相当于白盒子；

引用：https://blog.csdn.net/qq\_34980278/article/details/89377870

https://blog.csdn.net/weixin\_42275611/article/details/105717228

[https://blog.csdn.net/lxt610/article/details/80646670][https_blog.csdn.net_lxt610_article_details_80646670]

[SouthEast]: /images/20230209/b0186de81d1246dea594026467cff0c0.png
[20200423213956200.png]: /images/20230209/45c3ac157d464eaf9fae8d528dfdd28c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjI3NTYxMQ_size_16_color_FFFFFF_t_70]: /images/20230209/df3c865707f44407a829c84a707034b9.png
[20200423220723514.png]: /images/20230209/eb47f0e9efc448bcbc5fb12dbf7dc0c3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjI3NTYxMQ_size_16_color_FFFFFF_t_70 1]: /images/20230209/246cc9a256ee4b6e8b7d6069cd6e8349.png
[20200423222236269.png]: /images/20230209/98c7e9a828aa4db68c19ebbbe67467ef.png
[https_blog.csdn.net_lxt610_article_details_80646670]: https://blog.csdn.net/lxt610/article/details/80646670