首页 > 代码库 > 简单工厂模式与Strategy模式

简单工厂模式与Strategy模式

2024-07-03 21:25:57   224人阅读

参考资料：《大话设计模式》

简单工厂模式：

///
///简单工厂模式实验，2014.05.07---通过工厂类实例化对象
///
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ds
{
    class Program
    {
        static void Main(string[] args)
        {
            Operation oper = OperationFactory.OperationProduct("/");          
            oper.OperationNum(100,25);
            Console.WriteLine(oper.Result());
        }
    }


    class OperationFactory
    {
        /// <summary>
        /// 实例化一个具体类
        /// </summary>
        /// <param name="oper"></param>
        /// <returns></returns>
        public static Operation OperationProduct(string oper)
        {
            Operation Oper = null;
            switch (oper)
            {
                case "+":
                    Oper = new Operation_add();
                    break;
                case "-":
                    Oper = new Operation_sub();
                    break;
                case "*":
                    Oper = new Operation_mul();
                    break;
                case "/":
                    Oper = new Operation_div();
                    break;
            }
            return Oper;
        }
    }

    abstract class Operation
    {
        protected int numA;
        protected int numB;
        /// <summary>
        /// 传入操作数
        /// </summary>
        /// <param name="numA"></param>
        /// <param name="numB"></param>
        public void OperationNum(int numA, int numB)
        {
            this.numA = numA;
            this.numB = numB;
        }
        /// <summary>
        /// 返回操作数结果
        /// </summary>
        /// <returns></returns>
        public abstract int Result();
    }

    class Operation_add : Operation
    {
        public override int Result()
        {
            return numA + numB;
        }
    }
    class Operation_sub : Operation
    {
        public override int Result()
        {
            return numA - numB;
        }
    }
    class Operation_mul : Operation
    {
        public override int Result()
        {
            return numA * numB;
        }
    }
    class Operation_div : Operation
    {
        public override int Result()
        {
            if (numB > 0)
            {
                return numA / numB;
            }
            else
            {
                Console.WriteLine("除数必须为正数");
                return 0;
            }
        }
    }
}

Strategy（策略）模式：

///
///简单工厂模式---工厂类只返回实例化的对象，策略模式在Context类中，把方法（变化点）也封装了。
///
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ds_Strategy
{
    class Program
    {
        static void Main(string[] args)
        {
            Context con = new Context("/");
            Console.WriteLine(con.ContextInterface(88,11));
        }
    }
    class Context
    {
        Operation operation = null;
        public Context(string oper) //根据字符串，实例化策略
        {
            switch (oper)
            {
                case "+":
                    this.operation = new Operation_add();
                    break;
                case "-":
                    this.operation = new Operation_sub();
                    break;
                case "*":
                    this.operation = new Operation_mul();
                    break;
                case "/":
                    this.operation = new Operation_div();
                    break;
            }
        }
        public int ContextInterface(int NumA, int NumB)
        {
            return operation.Result(NumA, NumB);//调用具体的算法
        }
    }
    /// <summary>
    /// 抽象类
    /// </summary>
    abstract class Operation
    {
        /// <summary>
        /// 返回操作数结果
        /// </summary>
        /// <returns></returns>
        public abstract int Result(int numA, int numB);
    }

    class Operation_add : Operation
    {
        public override int Result(int numA, int numB)
        {
            return numA + numB;
        }
    }
    class Operation_sub : Operation
    {
        public override int Result(int numA, int numB)
        {
            return numA - numB;
        }
    }
    class Operation_mul : Operation
    {
        public override int Result(int numA, int numB)
        {
            return numA * numB;
        }
    }
    class Operation_div : Operation
    {
        public override int Result(int numA, int numB)
        {
            if (numB > 0)
            {
                return numA / numB;
            }
            else
            {
                Console.WriteLine("除数必须为正数");
                return 0;
            }
        }
    }

}//namespace

 

：

1.简单工厂模式只是解决对象的创建问题;

2.Strategy:定义了算法家族，分别封装起来，让他们之间可以互相替换，让算法的变化，不会影响到使用者--不懂？？？。

3.说实话，这两个模式的区别不是很清楚；记录在此只是为了方便今后的学习。


联系
我们