设计模式：一.前言以及工厂模式

其实在写设计模式之前应该还有一个前言的，我就在这里写了吧。这次改用Markdown来写。
首先什么是设计模式：
在软件领域，“四人帮”首次系统地提出了三大类(创建模式，行为模式，组合模式)共23种经典的可以解决常见软件设计问题的可复用设计方案，为可复用软件设计奠定了一定的理论基础。
其中三大类如下：
创建模式(共5种)：工厂模式，抽象工厂模式，单例模式，建造者模式，原型模式。
组合模式(共7种):适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
行为型模式(共11种):策略模式，模板方法模式，观察者模式，迭代器模式，责任链模式，命令模式，备忘录模式，状态模式，访问者模式，中介者模式，解释器模式。
还有两类：并发型模式和线程池模式。
什么王下七五海有八个，四大天王有五个的早已习惯了。我先把这23种屡一下，基本格式是这样：
1.意图，主要是解决什么问题。
2.何时使用：什么情况下使用该模式
3.UML图：看图比看代码更加形象。
4.关键代码：如何在代码层面识别就是该模式。
5.实例：这部分我会根据自己的经验不断添加，包括上面所写的3个部分我也会修改的，毕竟面向对象是一个内功活。这是一个长期要修改和添加的系列，当然，现在就是要把第一版写出来。感觉和菜鸟教程的差不多，但是我也会加入一些自己的私货，算作一个笔记+半原创。有些东西，只有自己认真思考，认真整理归纳，最后才能变成自己的东西。

---

工厂模式(Factor Mode)

1.意图：把对象的创建集中在一个地方(工厂中),在增加新的对象类型的时候,只需要改变工厂方法;否则在应用中四处散布对象创建逻辑,如果创建方法改变时则需要四处修改，维护量增加.

2.如何使用：定义一个创建对象的接口，让子类决定实例化哪个一个类。工厂方法使一个类的实例化延迟到其子类。

3.UML图：

4.关键代码：

IFactory concretefactory=new ConcreteFactory();
IProduct product=concretefactory.CreateProduct()；

5.实例：
(1)大话设计模式上的关于计算器设计的实例
UML图:

代码:

运算类，以及派生出的加法运算类，减法运算类，乘法运算类，除法运算类

public class Operation
{
    private double _numberA = 0;
    private double _numberB = 0;

    public double NumberA
    {
        get { return _numberA; }
        set { _numberA = value; }
    }
    public double NumberB
    {
        get { return _numberB; }
        set { _numberB = value; }
    }
    public virtual double GetResult()
    {
        double result = 0;
        return result;
    }
}
//加法
class OperationAdd : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA + NumberB;
        return result;
    }
}
//减法
class OperationSub : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA - NumberB;
        return result;
    }
}
//乘法
class OperationMul : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA * NumberB;
        return result;
    }
}
//除法
class OperationDiv : Operation
{
    public override double GetResult()
    {
        double result = 0;
        if (NumberB == 0)
        {
            Debug.LogError("除数不能为0");
            return 0;
        }
        result = NumberA / NumberB;
        return result;
    }
}

运算工厂IFactory，该接口返回一个运算类，实现该接口派生出加法，减法，乘法，除法的工厂类

interface IFactory
{
    Operation CreateOperation();
}
class AddFactory : IFactory
{
    public Operation CreateOperation()
    {
        return new OperationAdd();
    }
}
class SubFactory : IFactory
{
    public Operation CreateOperation()
    {
        return new OperationSub();
    }
}
class MulFactory : IFactory
{
    public Operation CreateOperation()
    {
        return new OperationMul();
    }
}
class DivFactory : IFactory
{
    public Operation CreateOperation()
    {
        return new OperationDiv();
    }
}

客户端使用：

   public class FactorPattern : MonoBehaviour
  {

    void Start()
    {
        //关键代码，运算工厂接口new出实现该接口的的加法工厂
        IFactory operFactory = new AddFactory();
        //里面的方法return出加法运算类，没错子类可以赋值给父类。
        Operation oper = operFactory.CreateOperation();
        oper.NumberA = 1;
        oper.NumberB = 2;
        double result = oper.GetResult();//使用加法运算类得出结果
    }
  }

---

看了下感觉对新手不太友好，不管设计模式就需要一定的代码量。就当成一个笔记吧。当然最后我也会分析实际工作中碰到的一些问题，以及为何要用到工厂模式。写到这里，我好想漏了什么，没错，就是简单工厂模式。我把简单工厂模式也写在后面吧。

---

简单工厂模式

1.意图：实例化对象不需要了解这个对象是哪个对象的子类，可以将简单工厂模式理解
为参数化的工厂模式。

2.如何使用：简单工厂实例化的类具有相同的接口，种类有限并且不需要扩展时，可以使用简单工厂。

3.UML图：

4.关键代码：

//简单工厂类一般设置为静态，根据参数new不同的子类
IProduct product=ProductFactory.CreateFactory("Concrete");

5.实例
(1)还是大话设计模式上的关于计算器设计的实例。
UML图：

代码：
客户端调用

public class EasyFactorPattern : MonoBehaviour
{
    void Start()
    {
        Operation oper;
        oper = OperationFactory.CreateOperate("+");
        oper.NumberA = 1;
        oper.NumberB = 2;
        double result = oper.GetResult();
        Debug.Log("计算结果为:" + result);
    }
}

工厂管理类：

class OperationFactory
{
    public static Operation CreateOperate(string operate)
    {
        Operation oper = null;
        switch (operate)
        {
            case "+":
                oper = new OperationAdd();
                break;
            case "-":
                oper = new OperationSub();
                break;
            case "*":
                oper = new OperationMul();
                break;
            case "/":
                oper = new OperationDiv();
                break;
        }
        return oper;
    }
}

运算类和他的子类

public class Operation
{
    private double _numberA = 0;
    private double _numberB = 0;

    public double NumberA
    {
        get { return _numberA; }
        set { _numberA = value; }
    }
    public double NumberB
    {
        get { return _numberB; }
        set { _numberB = value; }
    }
    public virtual double GetResult()
    {
        double result = 0;
        return result;
    }
}
//加法
class OperationAdd : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA + NumberB;
        return result;
    }
}
//减法
class OperationSub : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA - NumberB;
        return result;
    }
}
//乘法
class OperationMul : Operation
{
    public override double GetResult()
    {
        double result = 0;
        result = NumberA * NumberB;
        return result;
    }
}
//除法
class OperationDiv : Operation
{
    public override double GetResult()
    {
        double result = 0;
        if (NumberB == 0)
        {
            Debug.LogError("除数不能为0");
            return 0;
        }
        result = NumberA / NumberB;
        return result;
    }
}

---

最后就是简单工厂模式和工厂模式它们之间的区别，其实在UML图上就能很容易地看出区别。
简单工厂实例化的类具有相同的接口，种类有限并且不需要扩展时，可以使用简单工厂，当其种类不在可控范围类，比如说创建天气，天气有情天，雨天，阴天，下雨天这几个，种类有限使用简单工厂模式，比较方便。如果说要创建鸟，鸟的种类多达上千种，这就要用工厂模式，现将常用的创建好，要用其他的在加就好了，不用修改工厂类。对扩展开放，对修改关闭。
优点：工厂模式客服了简单工厂模式违背开放关闭原则的缺点，又保持了封装对象创建过程的优点。
缺点：每加一个产品，就需要一个产品工厂的类，增加了额外的开发量。