2021-01-31

一、定义

一个工厂类封装了所有的类的实例化。

  

 

二、优点

1.业务与客户端分开；客户端只需要知道你要传的参数就可了，不需要知道具体的对象如何创建的。

2.工厂类包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，使代码更容易维护。

 

三、缺点：

1.每增加一个新功能，就需要增加相应的子类，在简单工厂类里面更改工厂方法，使用“Case“语句来做判断。违背开闭原则（对扩展开发、对修改关闭）

2.如果有100个需求，就要增加一个100个子类，太复杂。

 

四、实现

场景：利用面向对象语言实现一个计算器控制台程序，要求输入两个数和运算符号，得到结果

//运算类
public class Operation
{
    private double _numberA = 0;          //声明double类型变量，第一个数
    private double _numberB = 0;          //声明double类型变量，第二个数

    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;                     //声明double类型变量，运算结果初始值为0
        result = NumberA - NumberB;            //result=第一个数-第二个数
        return result;                         //返回运算结果
    }
}


//乘法
class OperationMul : Operation              //乘法类，继承运算类
{
    public override double GetResult()      //重写父类方法
    {
        double result = 0;                  //声明double类型变量，并赋初始值
        result = NumberA * NumberB;         //计算结果
        return result;                      //返回结果
    }
}


//除法
class OperationDiv : Operation            //除法类，继承运算类
{
    public override double GetResult()    //重写父类方法
    {
        double result = 0;                //声明double类型变量，并赋初始值
        if (0 == NumberB)
        {
            throw new Exception("除数不能为零");
        }
        else
        {
            result = NumberA / NumberB;       //计算结果
            return result;                    //返回结果
        }
    }
}

简单运算工厂类

 public 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;
    }
}

客户端

Operation oper;                             //实例化运算类
oper = OperationFactory.createOperate("+"); //调用工厂类，并传入参数
oper.NumberA = 1;                           //给属性赋值
oper.NumberB = 2;                           //给属性赋值                      
Console.WriteLine(oper.GetResult());        //调用运算类计算方法，并输出结果result
Console.ReadKey();

 

类图及代码对应关系：