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

别偷喝船长的朗姆酒

已于 2022-05-01 12:35:00 修改

阅读量3.6k

点赞数 28

分类专栏：设计模式文章标签： c# unity 简单工厂模式工厂方法模式抽象工厂模式

于 2022-04-26 23:06:55 首次发布

本文链接：https://blog.csdn.net/qq_36674053/article/details/124437241

版权

设计模式专栏收录该内容

9 篇文章 0 订阅

订阅专栏

创建型模式—工厂三兄弟

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

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

一、简单工厂模式

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.2简单工厂模式缺点

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

2.1工厂模式优点

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