设计模式-创建型-工厂模式

工厂设计模式：

　　顾名思义，该模式是用来生产对象的。在面向对象的设计模式中，万物皆对象，若使用new来创建对象，就会对该对象产生强耦合，假如我们需要更换该对象，那么使用该对象的对象都需要进行修改，这显然违背了开闭原则（OCP）。如果我们使用工厂来产生对象，我们只需要与这个工厂打交道就可以了，无需关心具体的对象，达到解耦的目的。

　　接下来我们从实际的案例出发，从无工厂到有工厂的区别。

　　去披萨店订购披萨，首先披萨的种类很多(CheesePizza、GreekPizza、DurianPizza等)，披萨的制作流程有prepare、bake、cut、box。

传统模式：

　　 

internal class Program
{
    private static void Main(string[] args)
    {
        new OrderPizza();
    }
}

internal class OrderPizza
{
    public OrderPizza()
    {
        Pizza pizza = null;
        string orderType = "";
        do
        {
            orderType = Console.ReadLine();
            if (orderType == "cheese")
            {
                pizza = new CheesePizza();
                pizza.setName("芝士披萨");
            }
            else if (orderType == "greek")
            {
                pizza = new GreekPizza();
                pizza.setName("希腊披萨");
            }
            else
            {
                Console.WriteLine("订购失败");
                break;
            }
            //开始制作
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }
}

internal abstract class Pizza
{
    private string name;

    public abstract void prepare();

    public void bake()
    {
        Console.WriteLine($"{this.name} 烘培");
    }

    public void cut()
    {
        Console.WriteLine($"{this.name} 修剪");
    }

    public void box()
    {
        Console.WriteLine($"{this.name} 打包");
    }

    public void setName(string name)
    {
        this.name = name;
    }
}

internal class CheesePizza : Pizza
{
    public override void prepare()
    {
        Console.WriteLine("芝士披萨准备中");
    }
}

internal class GreekPizza : Pizza
{
    public override void prepare()
    {
        Console.WriteLine("希腊披萨准备中");
    }
}

　　传统模式的优缺点：

　　　　1、比较好理解，易于操作

　　　　2、违反OCP原则，即对扩展开放，对修改关闭。

　　　　3、这里只订购了两种pizza，若现在又新增了品种DurianPizza，这个时候就需要添加该类以及修改OrderPizza中的代码。从上图中可以看出，OrderPizza依赖抽象类及具体实现类的，那怎样才能切断OrderPizza与类之间的依赖关系呢。于是我们想到，可以定义一个工厂，订购者不需要知道具体pizza的制作流程，只要直到我需要订购什么类型的pizza就行了。

简单工厂模式：

　　 

internal class Program
{
    private static void Main(string[] args)
    {
        new OrderPizza();
    }
}

internal class OrderPizza
{
    public OrderPizza()
    {
        Pizza pizza = null;
        string orderType = "";
        do
        {
            Console.Write("请输入订购类型：");
            orderType = Console.ReadLine();
            pizza = SimpleFactory.createPizza(orderType);
            if (pizza == null)
            {
                Console.WriteLine("订购失败");
                break;
            }
            //开始制作
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }
}

internal static class SimpleFactory
{
    public static Pizza createPizza(string orderType)
    {
        Pizza pizza = null;
        do
        {
            if (orderType == "cheese")
            {
                pizza = new CheesePizza();
                pizza.setName("芝士披萨");
            }
            else if (orderType == "greek")
            {
                pizza = new GreekPizza();
                pizza.setName("希腊披萨");
            }
            else if (orderType == "durian")
            {
                pizza = new DurianPizza();
                pizza.setName("榴莲披萨");
            }
            return pizza;
        } while (true);
    }
}

internal abstract class Pizza
{
    private string name;

    public abstract void prepare();

    public void bake()
    {
        Console.WriteLine($"{this.name} 烘培");
    }

    public void cut()
    {
        Console.WriteLine($"{this.name} 修剪");
    }

    public void box()
    {
        Console.WriteLine($"{this.name} 打包");
    }

    public void setName(string name)
    {
        this.name = name;
    }
}

internal class CheesePizza : Pizza
{
    public override void prepare()
    {
        Console.WriteLine("芝士披萨准备中");
    }
}

internal class GreekPizza : Pizza
{
    public override void prepare()
    {
        Console.WriteLine("希腊披萨准备中");
    }
}

internal class DurianPizza : Pizza
{
    public override void prepare()
    {
        Console.WriteLine("榴莲披萨准备中");
    }
}

　　简单工厂模式优缺点：

　　　　1、由代码可以看出，虽然简单工厂模式一定程度上减少了因需求变更而导致的代码更改，但是实际仍违背了OCP原则。

　　　　2、所以简单工厂模式只适合产品对象相对较少，且产品固定的需求，对产品变化无常的需求来说显然不适合。

 

工厂方法设计模式：

　　披萨项目需求变更，客户点披萨时可以点不同口味的披萨。 

　　 

internal class Program
{
    private static void Main(string[] args)
    {
        new BJOrderPizza();
    }
}

internal abstract class OrderPizza
{
    public OrderPizza()
    {
        Pizza pizza = null;
        string orderType = "";
        do
        {
            Console.Write("请输入订购类型：");
            orderType = Console.ReadLine();
            pizza = createPizza(orderType);
            if (pizza == null)
            {
                Console.WriteLine("订购失败");
                break;
            }
            //开始制作
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }

    public abstract Pizza createPizza(string orderType);
}

internal class BJOrderPizza : OrderPizza
{
    public override Pizza createPizza(string orderType)
    {
        Pizza pizza = null;
        if (orderType == "cheese")
        {
            pizza = new BJCheesePizza();
        }
        else if (orderType == "greek")
        {
            pizza = new BJGreekPizza();
        }
        return pizza;
    }
}

internal class LDOrderPizza : OrderPizza
{
    public override Pizza createPizza(string orderType)
    {
        Pizza pizza = null;
        if (orderType == "cheese")
        {
            pizza = new LDCheesePizza();
        }
        else if (orderType == "greek")
        {
            pizza = new LDGreekPizza();
        }
        return pizza;
    }
}

internal abstract class Pizza
{
    private string name;

    public abstract void prepare();

    public void bake()
    {
        Console.WriteLine($"{this.name} 烘培");
    }

    public void cut()
    {
        Console.WriteLine($"{this.name} 修剪");
    }

    public void box()
    {
        Console.WriteLine($"{this.name} 打包");
    }

    public void setName(string name)
    {
        this.name = name;
    }
}

internal class BJCheesePizza : Pizza
{
    public override void prepare()
    {
        Console.WriteLine("北京的芝士披萨准备中");
    }
}

internal class BJGreekPizza : Pizza
{
    public override void prepare()
    {
        Console.WriteLine("北京的希腊披萨准备中");
    }
}

internal class LDCheesePizza : Pizza
{
    public override void prepare()
    {
        Console.WriteLine("伦敦的芝士披萨准备中");
    }
}

internal class LDGreekPizza : Pizza
{
    public override void prepare()
    {
        Console.WriteLine("伦敦的希腊披萨准备中");
    }
}

　　工厂方法模式的优缺点：

　　　　1、让父类的实现延迟到子类中去，减少判断。

　　　　2、换汤不换药，和简单工厂模式类似，一般适用于产品对象相对较少，且产品固定的需求。

　　　　3、工厂方法一定程度上减轻了工厂的职责，将职责细化，避免工厂类无法正常运行而导致程序崩溃。

参考：https://www.jianshu.com/p/38493eb4ffbd