简单工厂模式总结

最新推荐文章于 2022-12-13 12:18:48 发布

锋璠

最新推荐文章于 2022-12-13 12:18:48 发布

阅读量413

点赞数

CC 4.0 BY-SA版权

分类专栏：设计模式学习

本文链接：https://blog.youkuaiyun.com/weixin_42263618/article/details/89764721

设计模式学习专栏收录该内容

18 篇文章

订阅专栏

本文介绍简单工厂模式，将其分为三步：先确定工厂模型总父类，如服装加工厂抽象出服装大类；再确定产品子类，像服装分女装、男装等；最后根据参数确定调用的子类。还以设计计算器为例进行说明。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

简单工厂模式

工厂模式，说简单点就是用工厂的思维模式建造软件。
工厂的定义：就是各类产品的制造场所；
所以工厂主要分为产品和工厂本身两部分；
所以我就将简单工厂模式在我看来分为三步走；

第一步确定工厂模型的总父类

第一步就是确定我们的产品的总的类别，在日常生活中每个工厂都是有特定功能的，而他们的功能从大的方面都归属一个类。比如服装加工厂，机械加工厂，食品加工厂等等。从这些工厂中都可以抽象出一个总类。服装加工厂抽象出来的就是服装大类，机械加工厂抽象出来的就是机械大类；食品加工厂抽象出来的就是食品大类；
所以我们在使用工厂模型的时候，要确定一个总的大类，也是我们工厂模型中的总的父类；

第二步确定工厂产品的各个子类

第二部就是确定总的父类之后，确定工厂的各个生产线的种类。比如生活中服装厂不可能只生产一类产品，服装下面又分为女装，男装，儿童装，老年装等等分类。这些就是各个子类。

第三步确定工厂加工的子类

众所周知工厂不是什么时候都是有活的，工厂只有接到订单的时候才能确定生产什么服装。所以这时候就需要根据订单的不同来确定生产什么服装。放到代码中就是根据参数的不同来确定调用那个子类的方法。

例子：设计一个计算器：

第一步

计算器其实就是各种运算方法的运用，从中可以抽象出“运算”这个总类，所以建立父类Operation；

 public class Operation
    {
        public Operation()
        {

        }
        public Operation(double numberA, double numberB)
        {
            this.NumberA = numberA;
            this.NumberB = numberB;
        }

        private double _numberA;
        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }

        private double _numberB;
        public double NumberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }

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

第二步

确定各个运算方法如“+”——“OperationAdd”； “-”——“OperationSub”
建立两个子类来实现这两种运算方法。

//加法类
class OperationAdd : Operation
    {


        public OperationAdd(double numberA, double numberB ) : base(numberA, numberB)
        {

        }

        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }


    //减法类
    public class OperationSub:Operation 

    {
        public OperationSub (double numberA,double numberB):base(numberA,numberB )
        {

        }
        public override double GetResult()
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }

第三步

最后根据运算符确定要用什么运算方法，然后调用该子类；

class OperationFactory
    {
        public static Operation createOperation(string operate)
        {

            double numberA = 0;
            double numberB = 0;
            Console.WriteLine("请您输入第一个数字");
            int num = 0;
            while (num==0)
            {
                try
                {
                     numberA = Convert.ToDouble(Console.ReadLine());
                    break;
                }
                catch (Exception)
                {
                    Console.WriteLine("请您输入数字");

                }
            }
            Console.WriteLine("请您输入第二个数字");
           
            while (num == 0)
            {
                try
                {
                     numberB = Convert.ToDouble(Console.ReadLine());
                    break;
                }
                catch (Exception)
                {
                    Console.WriteLine("请您输入数字");

                }
            }

            Operation oper = null;
            switch (operate)
            {
                case "+":
                    oper = new OperationAdd(numberA,numberB ); break;

                case "-":
                    oper = new OperationSub(numberA,numberB ); break;
            }
            return oper;
        }
    }

客户端代码

            Operation oper;
            Console.WriteLine("请输入您要进行的运算，‘+’或‘-’");
			//这里缺一个判断就不写了
            string sainOfOperation = Console.ReadLine();
            oper = OperationFactory.createOperation(sainOfOperation);
            double sesult = oper.GetResult();
            Console.WriteLine(sesult);
            Console.ReadKey();