简单工厂模式

简单工厂模式的定义：

专门定义一个类来负责创建其它类的实例，被创建的实例通常都具有共同的父类。

（Simple Factory）模式又称为静态工厂方法（Static Factory Method）模式，属于类的创建型模式，通常他根据自变量的不同返回不同类的实例。

简单工厂模式实质是由一个工厂类根据传入的参量动态决定应该创建出哪一个产品类的实例。

简单工厂模式实际上不属于23个GOF模式，但他可以作为工厂方法模式（Factory Method）的一个引导。

简单工厂模式设计的角色：

工厂角色：是简单工厂的核心，它负责实现创建所有实例内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

抽象产品角色：是简单工厂模式所创建的所有父对象类，它负责描述所有实例所有的公共接口。

具体产品角色：是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

下面给出示例程序：

抽象产品类

class Calculator
{
        private double num1;
        private double num2;

        public double Num1
        {
            get { return num1; }
            set { num1 = value; }
        }
        public double Num2 
        {
            get { return num2; }
            set { num2 = value; }
        }

        public virtual double Calculate()
        {
            double result = 0;
            return result;
        }
 }

具体产品类

class OperationAdd : Calculator
{
        public override double Calculate()
        {
            double result = 0;
            result = Num1 + Num2;
            return result;
        }
}

class OperationSubtract : Calculator
{
        public override double Calculate()
        {
            double result = 0;
            result = Num1 - Num2;
            return result;
        }
}

class OperationMultiply : Calculator
{
        public override double Calculate()
        {
            double result = 0;
            result = Num1 * Num2;
            return result;
        }
}

class OperationDivide : Calculator
{
        public override double Calculate()
        {
            double result = 0;
            try
            {
                result = Num1 / Num2;
                return result;
            }
            catch (System.Exception ex)
            {
                throw ex;
            }
        }
}

简单工厂类

class OperationFactory
{
        public static Calculator CreateOperation(String operate)
        {
            Calculator calculator = null;
            switch(operate)
            {
                case "+":
                    calculator = new OperationAdd();
                    break;
                case "-":
                    calculator = new OperationSubtract();
                    break;
                case "*":
                    calculator = new OperationMultiply();
                    break;
                case "/":
                    calculator = new OperationDivide();
                    break;
            }
            return calculator;
        }
}

测试代码

class SimpleFactory
{
        static void Main()
        {
            Console.Write("请输入第一个数：");
            double num1 = Convert.ToDouble(Console.ReadLine());
            Console.Write("请输入运算符：");
            String operate = Console.ReadLine();
            Console.Write("请输入第二个数：");
            double num2 = Convert.ToDouble(Console.ReadLine());
            Calculator calculator = OperationFactory.CreateOperation(operate);
            calculator.Num1 = num1;
            calculator.Num2 = num2;
            double result = calculator.Calculate();
            Console.WriteLine(result);
        }
}

简单工厂应用场景：

工厂类负责创建的对象比较少；

客户只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心；

由于简单工厂很容易违反高内聚责任分配原则，因此一般只在很简单的情况下应用。