Unity设计模式之工厂模式

什么是工厂模式？

        工厂是一种创建型设计模式。通俗来讲就是提供一种封装对象创建的方式，将对象的创建和使用区分开。就是Unity里面通常用到的创建和管理对象。

工厂模式有什么优点？

        1、封装对象的创建方式，使其更加灵活、易于管理、可扩展、可维护，降低代码的耦合性。

        2、提供一种统一的对象创建方式，代码解读更加容易懂、逻辑更加清晰。

        3、可以根据不同的需求创建不同的对象。

工厂模式有什么缺点？

        1、违反了单一职责原则；添加新类型时需要修改工厂类。（不包含抽象工厂模式）

        2、增加了前期代码的复杂度，需要创建更多的类（基类、管理类、派生类等）

        感觉这也不算缺点吧。。。

工厂模式中的分类：

        普通工厂模式、工厂方法模式、抽象工厂模式。

普通工厂模式

1、创建一个类作为其他派生类的基类

public class FactoryBase : MonoBehaviour
{
    protected string name;

    public virtual void OnUse()
    {
        Debug.LogError(name);
    }
}

2、再创建两个派生类 Derive1、Derive2

public class Derive1 : FactoryBase
{
    public Derive1()
    {
        name = "Derive1";
    }
    
    public override void OnUse()
    {
        base.OnUse();
        GameObject o = new GameObject(name);
        o.AddComponent<Derive1>();
    }
}




public class Derive2 : FactoryBase
{
    public Derive2()
    {
        name = "Derive2";
    }
    
    public override void OnUse()
    {
        base.OnUse();
        GameObject o = new GameObject(name);
        o.AddComponent<Derive1>();
    }
}

3、最后创建一个对象管理类

public class FactoryMgr : MonoBehaviour
{
    public static FactoryBase CreateItem(string deriveName)
    {
        FactoryBase item = null;

        if (deriveName == "1")
        {
            item = new Derive1();
        }

        if (deriveName == "2")
        {
            item = new Derive2();
        }
        
        return item;
    }
}

应用普通工厂模式

这就是普通的工厂模式的应用

public class FactoryApply : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        FactoryMgr.CreateItem("1").OnUse();

        FactoryMgr.CreateItem("2").OnUse();
    }
}

工厂方法模式

1、定义派生类接口和派生类

public interface IDevive
{
    void Use();
}



public class Devive1 : IDevive
{
    public void Use()
    {
        Debug.LogError("Devive1");
    }
}



public class Devive2 : IDevive
{
    public void Use()
    {
        Debug.LogError("Devive2");
    }
}

2、再定义派生工厂接口和派生工厂类

public interface IFactory
{
    IDevive CreateDevive();
}



public class Devive1Item : IFactory
{
    public IDevive CreateDevive()
    {
        return new Devive1();
    }
}



public class Devive2Item : IFactory
{
    public IDevive CreateDevive()
    {
        return new Devive2();
    }
}

应用工厂方法模式

public class FactoryApply : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        var i1 = new Devive1Item().CreateDevive();
        i1.Use();
        
        var i2 = new Devive2Item().CreateDevive();
        i2.Use();
    }
}

抽象工厂模式

1、定义派生类接口和派生类

public interface IDevive
{
    void Use();
}



public class Devive1 : IDevive
{
    public void Use()
    {
        Debug.LogError("Devive1");
    }
}



public class Devive2 : IDevive
{
    public void Use()
    {
        Debug.LogError("Devive2");
    }
}

2、再定义派生工厂接口和派生工厂类

public interface IFactory
{
    IDevive CreateDevive();
}



public class Devive1Item : IFactory
{
    public IDevive CreateDevive()
    {
        return new Devive1();
    }
}



public class Devive2Item : IFactory
{
    public IDevive CreateDevive()
    {
        return new Devive2();
    }
}

3、抽象派生类管理器接口和派生类管理器

public interface IDeviveManager
{
    IFactory CreateDevive1Item();
    IFactory CreateDevive2Item();
}



public class DeviveManager : IDeviveManager
{
    public IFactory CreateDevive1Item()
    {
        return new Devive1Item();
    }

    public IFactory CreateDevive2Item()
    {
        return new Devive2Item();
    }
}

应用抽象工厂模式

public class FactoryApply : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        IDeviveManager deviveManager = new DeviveManager();

        IFactory item1 = deviveManager.CreateDevive1Item();
        IDevive devive1 = item1.CreateDevive();
        devive1.Use();

        IFactory item2 = deviveManager.CreateDevive2Item();
        IDevive devive2 = item2.CreateDevive();
        devive2.Use();
    }
}

总结：

        工厂模式定义了一个创建对象的接口，但由子类决定实例化哪个类。它使一个类的实例化延迟到其子类。

        工厂模式通过将客户端代码与具体类的实例化过程解耦，使得系统更灵活。

        但是，每增加一个子模块就需要增加一个子类和工厂类，导致类的数量增加。