【设计模式】Unity3D 简单工厂、工厂(方法)、抽象工厂模式

创建型模式—工厂三兄弟

提示：个人学习总结，如有错误，敬请指正

---

---

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、简单工厂模式

1.简单工厂模式是什么？

简单工厂的核心是：创建一个专门创建实例的类，一般来说创建的实例都拥有相同的父类或接口。

要点在于：当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节。

---

2.UML图

//TODO

---

3.实现方式

代码案例：客户端根据需求去创建大的cube或者小的cube

抽象产品:抽象类或者接口

public abstract class CubeBase 
{
    public abstract void GenerateCube();
}

具体产品：继承抽象产品，自定义实现

using UnityEngine;
public class BigCube : CubeBase
{
    public override void GenerateCube()
    {
        var gameobj =  GameObject.CreatePrimitive(PrimitiveType.Cube);
        gameobj.transform.localScale *= 2;
    }
}

using UnityEngine;
public class SmallCube : CubeBase
{
    public override void GenerateCube()
    {
        var gameobj = GameObject.CreatePrimitive(PrimitiveType.Cube);
        gameobj.transform.localScale *= 0.5f;
    }
}

工厂类：通过工厂类直接创建实例

using UnityEngine;
public class CubeFactory : MonoBehaviour
{
    public static CubeBase CubeGenerate(CubeCategory type)
    {
        CubeBase cube = null;
        switch (type)
        {
            case CubeCategory.big:
                cube = new BigCube();
                break;
            case CubeCategory.small:
                cube = new SmallCube();
                break;
            default:
                cube = null;
                break;
        }
        return cube;
    }
    public enum CubeCategory
    {
        big,
        small,
    }
}

客户端

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SimpleFactoryEntary : MonoBehaviour
{
    CubeBase cubeBase;
    private void Start()
    {
        cubeBase = CubeFactory.CubeGenerate(CubeFactory.CubeCategory.big);
        cubeBase.GenerateCube();
    }
}

---

二、工厂（方法）模式

1.工厂（方法）模式是什么？

工厂（方法）模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例欧化延迟到其子类。

与简单工厂相比：不再提供一个统一的工厂类来创建所有的产品对象，而是针对不同的产品提供不同的工厂，系统提供一个与产品等级结构对应的工厂等级结构。

---

2.UML图

//TODO

---

3.实现方式

代码案例：在简单工厂下客户端不仅仅需要创建cube，还要创建Sphere,创建两个工厂子类，让具体工厂去决定生成大还是小。

工厂接口:

interface IFactory
{
    CubeBase CreateCube();
}

具象工厂:

public class SpheresFactory : IFactory
{
    public ShapeBase CreateFactory()
    {
        return new Spheres();
    }
}

public class CubesFactory : IFactory
{
    public ShapeBase CreateFactory()
    {
        return new Cubes();
    }
}

抽象产品

public abstract class ShapeBase 
{
    public abstract void GenerateShape();
}

具体产品

using UnityEngine;
public class Cubes : ShapeBase
{
    public override void GenerateShape()
    {
        GameObject.CreatePrimitive(PrimitiveType.Cube);
    }
}

using UnityEngine;
public class Spheres : ShapeBase
{
    public override void GenerateShape()
    {
        GameObject.CreatePrimitive(PrimitiveType.Sphere);
    }
}

客户端：

using UnityEngine;
public class FactoryEntary : MonoBehaviour
{
    void Start()
    {
        //修改 CubesFactory 即可
        IFactory factory = new CubesFactory();
        var cube =  factory.CreateFactory();
        cube.GenerateShape();
    }
}

---

三.抽象工厂模式

1.抽象工厂模式是什么？

抽象工厂模式（AbstrucFactory）:提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。

工厂方法模式相比，抽象工厂模式中的具体工厂不只是创建一种产品，它负责创建一族产品。它只是工厂模式的一个扩展，若其只有一个产品体系则变成工厂模式

---

2.UML图

//TODO

---

3.实现方式

代码案例：在工厂模式下，客户端不在是简单生成一个cube或者sphere,而是cube和sphere的自由组合。

产品接口：抽象产品

//抽象Cube产品
interface IACube 
{
    void Generate();
}

//抽象Sphere产品
interface IASphere
{
    void Generate();
}

具体产品

public class ABigCube : IACube
{
    public void Generate()
    {
        var gameobj = GameObject.CreatePrimitive(PrimitiveType.Cube);
        gameobj.transform.localScale *= 2f;
    }
}

using UnityEngine;
public class ASmallCube : IACube
{
    public void Generate()
    {
        var gameobj = GameObject.CreatePrimitive(PrimitiveType.Cube);
        gameobj.transform.localScale *= 0.5f;
    }
}

using UnityEngine;
public class ASmallSphere : IASphere
{
    public void Generate()
    {
        var gameobj = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        gameobj.transform.localScale *= 0.5f;
    }
}

using UnityEngine;
public class ABigSphere : IASphere
{
    public void Generate()
    {
        var gameobj = GameObject.CreatePrimitive(PrimitiveType.Sphere);
        gameobj.transform.localScale *= 2f;
    }
}

抽象工厂

interface AbstructFactory 
{
    IACube CreateCube();
    IASphere CreateSphere();
}

具体工厂

class AFactoryOne : AbstructFactory
{
    public IACube CreateCube()
    {
        return new ABigCube();
    }

    public IASphere CreateSphere()
    {
        return new ABigSphere();
    }
}

class AFactoryTwo : AbstructFactory
{
    public IACube CreateCube()
    {
        return new ASmallCube();
    }

    public IASphere CreateSphere()
    {
        return new ASmallSphere();
    }
}

客户端

using UnityEngine;

public class AbstructFactoryEntary : MonoBehaviour
{
    private void Start()
    {
        AbstructFactory factory = new AFactoryOne();
        var a = factory.CreateCube();
        var b = factory.CreateSphere();
        a.Generate();
        b.Generate();
    }
}

---

四、三者的异同

工厂模式是简单工厂模式的升级，满足了开闭原则（对扩展开放，对修改关闭），解决了简单工厂模式的灵活性差的缺点。工厂模式将创建对象的工作交给了工厂的子类（延迟创建对象），自己只提供需要子类实现的方法。这样，在需要新增的时候就可以不破坏原来的结构也就是说工厂方法把简单工厂的内部逻辑判断转移到了客户端，你要加功能，本来是改工厂类，现在是修改客户端

抽象工厂是工厂模式的升级。
工厂模式的侧重点在于把实例化延迟到子类，是利用继承的方式来拓展某一功能的。
抽象工厂的侧重点在于创建相关或依赖对象的家族，与工厂模式不同，抽象工厂是通过组合(实例化对象)的方式实现的。（工厂模式很多时候是隐藏在抽象工厂里面的。）

---

五、三者的优缺点

1.1简单工厂模式优点

1. 简单工厂模式实现了对象创建和使用的分离，客户端不需要使用复杂的创建过程（只管调用这个方法就行了）

1.2简单工厂模式缺点

1. 设计模式通病，会增加系统中类的个数，增加了系统的复杂度和理解难度。
2. 简单工厂模式中工厂类集中了所有产品的创建逻辑，一旦添加新产品就不得不修改工厂逻辑，这样就违反了开放封闭原则，不利于系统的扩展和维护。

---

2.1工厂模式优点

1. 工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。（多态性：所有的具体工厂类都具有同一抽象父类）
2. 弥补了简单工厂模式的缺点，满足了“开闭原则”，在添加新产品时，无须修改抽象工厂和抽象产品提供的接口，无须修改客户端，也无须修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了，

2.2工厂模式缺点

1. 设计模式的通病，不写了
2. 可能会引入反射，DOM，增加系统的抽象性和理解性，仁者见仁，智者见智吧

---

3.1抽象工厂模式优点

2. 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象

3.2抽象工厂模式缺点：

1. 增加新的产品等级结构麻烦，需要对原有系统进行较大的修改，甚至需要修改抽象层代码，这显然会带来较大的不便，违背了“开闭原则”。

---

六、三者的适用场景

简单工厂模式适用场景：

• 系统足够简单，满足需求：客户端只知道传入工厂类的参数，对于如何创建对象并不关心。

---

工厂模式适用场景：

• 系统较为复杂，单一工厂的责任太重，而且扩展较为复杂。

---

抽象工厂模式适用场景：

• //TODO

---

附：

1.大话设计模式
2.B站课程
3.设计模式