设计模式-工厂模式

概述

工厂模式是一种创建对象的设计模式，主要的是将对象的创建和使用分离的一种方法，可以在不知道实现的情况下创建具体的对象，举个例子，比如一个工厂是做包装的，我不需要知道工厂内部是怎么实现的，我只需要传入产品，返回给我一个包装好的物品就行。工厂模式有三种变体，简单工厂模式，工厂方法模式，抽象工厂模式，如下。（以下环境不是unity，是C#的控制台程序）

需求：

有一个工厂做包装生意，现有苹果，香蕉，桃子，请将各个水果包装好运出来。

---

简单工厂模式

internal class Program
{
    private static void Main(string[] args)
    {
        IPack pack = FruitFactory.FactorPack("Peach");
        pack.PackFruit();
    }
}
public interface IPack//打包接口
{
    void PackFruit();
}
public class Apple : IPack//苹果
{
    public void PackFruit()
    {
        Console.WriteLine("Pack Appple!");
    }
}
public class Banana : IPack//香蕉
{
    public void PackFruit()
    {
        Console.WriteLine("Pack Banana!");
    }
}
public class Peach : IPack//桃子
{
    public void PackFruit()
    {
        Console.WriteLine("Pack Peach!");
    }
}
public class FruitFactory//水果工厂
{
    public static IPack FactorPack(string type)
    {
        switch (type)
        {
            case "Appple":
                return new Apple();
            case "Banana":
                return new Banana();
            case "Peach":
                return new Peach();
            default:
                throw new Exception("无效类型");
        }
    }
}

输出结果：Pack Peach!

简单工厂：简单来说就是通过继承接口，实现各种类型的扩展，然后通过一个统一的工厂方法管理起来，但是修改的话需要修改工厂方法（如上FactorPack），不满足开闭原则。

扩展的话需要加入新的类，然后在工厂方法中添加具体的类型。具体的实现可以放在对应的方法类，当然也可以带入参数，具体业务逻辑的扩展，按实际的需求来。

---

工厂方法模式

internal class Program
{
    private static void Main(string[] args)
    {
        CreatorFactor pack = new PeachFactory();
        IPack peach = pack.FactoryMethod();
        peach.PackFruit();
    }
}
public interface IPack//打包接口
{
    void PackFruit();
}
public class Apple : IPack//苹果
{
    public void PackFruit()
    {
        Console.WriteLine("Pack Appple!");
    }
}
public class Banana : IPack//香蕉
{
    public void PackFruit()
    {
        Console.WriteLine("Pack Banana!");
    }
}
public class Peach : IPack//桃子
{
    public void PackFruit()
    {
        Console.WriteLine("Pack Peach!");
    }
}
public abstract class CreatorFactor//工厂抽象类
{
    public abstract IPack FactoryMethod();
}

public class AppleFactory : CreatorFactor//苹果工厂
{
    public override IPack FactoryMethod()
    {
        return new Apple();
    }
}
public class BananaFactory : CreatorFactor//香蕉工厂
{
    public override IPack FactoryMethod()
    {
        return new Banana();
    }
}
public class PeachFactory : CreatorFactor//桃子工厂
{
    public override IPack FactoryMethod()
    {
        return new Peach();
    }
}

输出结果：Pack Peach!

工厂方法模式：这个办法解决了上述的简单工厂的问题，不满足设计模式原则的开闭原则，工厂方法模式可以在不修改原来代码的情况下扩展新的工厂。简单来说，就是将工厂方法做成了一个抽象类，然后有新的工厂的时候继承自这个抽象类，实现对应的方法。

扩展的话，只需要扩展新的类型，然后继承CreatorFactor再实现对应的方法，不用修改原来的方法，缺点就是增加了代码的复杂性，要管理很多的工厂。

---

抽象工厂模式

这里扩展一下复杂度，现在苹果，香蕉，桃子，现在有两种不同的包装，普通和精美

internal class Program
{
    private static void Main(string[] args)
    {
        IFactory factory = new PeachFactory();
        IOrdinaryPack ordinaryPack = factory.PackOridinary();
        IExquisitePack exquisitePack = factory.PackExquisite();
        ordinaryPack.PackOrdinaryFruit();
        exquisitePack.PackExquisiteFruit();
    }
}
public interface IOrdinaryPack//普通包装接口
{
    void PackOrdinaryFruit();//包装普通水果
}
public class OrdinaryApple : IOrdinaryPack//普通包装苹果
{
    public void PackOrdinaryFruit()
    {
        Console.WriteLine("Pack OrdinaryApple!");
    }
}
public class OrdinaryBanana : IOrdinaryPack//普通包装香蕉
{
    public void PackOrdinaryFruit()
    {
        Console.WriteLine("Pack OrdinaryBanana!");
    }
}
public class OrdinaryPeach : IOrdinaryPack//普通包装桃子
{
    public void PackOrdinaryFruit()
    {
        Console.WriteLine("Pack OrdinaryPeach!");
    }
}
//----------------------------------------------------------------------------
public interface IExquisitePack//精美包装接口
{
    void PackExquisiteFruit();//包装精美水果
}
public class ExquisiteApple : IExquisitePack//精美包装苹果
{
    public void PackExquisiteFruit()
    {
        Console.WriteLine("Pack ExquisiteApple!");
    }
}
public class ExquisiteBanana : IExquisitePack//精美包装香蕉
{
    public void PackExquisiteFruit()
    {
        Console.WriteLine("Pack ExquisiteBanana!");
    }
}
public class ExquisitePeach : IExquisitePack//精美包装桃子
{
    public void PackExquisiteFruit()
    {
        Console.WriteLine("Pack ExquisitePeach!");
    }
}
//----------------------------------------------------------------------------
public interface IFactory//工厂接口
{
    IOrdinaryPack PackOridinary();
    IExquisitePack PackExquisite();
}
public class AppleFactory : IFactory//苹果工厂
{
    public IExquisitePack PackExquisite()
    {
        return new ExquisiteApple();
    }

    public IOrdinaryPack PackOridinary()
    {
        return new OrdinaryApple();
    }
}
public class BananaFactory : IFactory//香蕉工厂
{
    public IExquisitePack PackExquisite()
    {
        return new ExquisiteBanana();
    }

    public IOrdinaryPack PackOridinary()
    {
        return new OrdinaryBanana();
    }
}
public class PeachFactory : IFactory//桃子工厂
{
    public IExquisitePack PackExquisite()
    {
        return new ExquisitePeach();
    }

    public IOrdinaryPack PackOridinary()
    {
        return new OrdinaryPeach();
    }
}

输出结果：

Pack OrdinaryPeach!
Pack ExquisitePeach!

抽象工厂模式：抽象工厂模式是工厂方法模式的一种扩展，仔细看两者相识度是很高的，各有各适用的场景，实际适用按照需求来。