设计模式学习6——工厂方法模式

定义

工厂方法模式（Factory Method），定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

结构图

代码实例

对以前的计算器的简单工厂模式进行修改。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication6
{

    //抽象产品角色product
    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;
        }
    }

    //具体产品角色 Concrete Product
    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)
                throw new Exception("除数不能为0.");
            result = numberA / numberB;
            return result;
        }
    }

    //工厂接口
    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();
        }
    }


    class Program
    {
        static void Main()
        {
            IFactory operFactory = new AddFactory();
            Operation oper = operFactory.CreateOperation();
            oper.numberA = 1;
            oper.numberB = 2;
            double result = oper.GetResult();
            Console.WriteLine("结果为：{0}", result);
            Console.ReadLine();
        }
    }
}

与简单工厂进行对比

简单工厂模式的最大优点是工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖，然而如果我们想添加一种新的运算，那么我们必须修改工厂类，在工厂类中添加Case的分支条件，这是违反开放—封闭原则的。而在工厂模式中，如果我们想添加新的运算，只需要添加运算类和其相应的工厂类就可以了。这样就不会违反开放封闭原则。然而这样的话，判断分支就需要写在客户端中了，这一点无法解决。且每添加一种运算类，都要添加相应的工厂类，这无疑增加了额外的开放量。