终于放假了!!!

经过三周课设学到不少东西,,今天是放假第一天,看了大话设计模式两章,,记录一下.. 免得白看了

 

简单工厂模式

namespace 简单工厂模式
{
    public class Operation
    {
        private double _numberA = 0;
        private double _numberB = 0;

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


        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }
    class OperatinAdd : Operation //加法
    {
        public override double GetResult() //重写GetResult方法
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    class OperatinSub : Operation //减法
    {
        public override double GetResult() //重写GetResult方法
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    class OperatinMul : Operation //乘法
    {
        public override double GetResult() //重写GetResult方法
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    class OperatinDiv : Operation //除法
    {
        public override double GetResult() //重写GetResult方法
        {  double result = 0;
        if (NumberB == 0)
            throw new Exception("除数不能为0");
            result = NumberA / NumberB;
            return result;
        }
    }
    public class operationFactory//选择符号类
    {
        public static Operation createOperate(string operate)
         //实例化一个model类型,返回一个结果(结果是operation类型)通过符号类选择实例化的算法类
        {
            Operation oper = null;
            switch (operate)//选择符号
            {//通过选择符号对算法类进行实例化
                case "+":
                    oper = new OperatinAdd();
                    break;
                case "-":
                    oper = new OperatinSub();
                    break;
                case "*":
                    oper = new OperatinMul();
                    break;
                case "/":
                    oper = new OperatinDiv();
                    break;

            }
            return oper;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Operation oper;
            oper = operationFactory.createOperate("+");
            oper.NumberA=100;
            oper.NumberB = 100;
            double result = oper.GetResult();
            Console.Write(result);
        }
    }
}
//一个实体类(含一个虚方法,用于被覆盖)
// 数个方法类(操作实体)(继承实例类,并含一个方法覆盖虚方法)
//一个选择方法类(含一个静态方法,,可选择操作数个方法)
//用户操作类  实例化实体类,实例化选择方法类
//简单工厂模式和三层架构类似 (简单工厂模式利用虚方法的覆盖实现被多个类覆盖)

namespace 策略模式
{
    public class Operation
    {
        private double _numberA = 0;
        private double _numberB = 0;

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


        public double NumberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }
    class OperatinAdd : Operation //加法
    {
        public override double GetResult() //重写GetResult方法
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    class OperatinSub : Operation //减法
    {
        public override double GetResult() //重写GetResult方法
        {
            double result = 0;
            result = NumberA - NumberB;
            return result;
        }
    }
    class OperatinMul : Operation //乘法
    {
        public override double GetResult() //重写GetResult方法
        {
            double result = 0;
            result = NumberA * NumberB;
            return result;
        }
    }
    class OperatinDiv : Operation //除法
    {
        public override double GetResult() //重写GetResult方法
        {
            double result = 0;
            if (NumberB == 0)
                throw new Exception("除数不能为0");
            result = NumberA / NumberB;
            return result;
        }
    }
 
    class cashcontext //策略模式封装方法
    {
        Operation oner;
        
        public  cashcontext(string type)
        {
            switch(type)//分支中实例化类
            
           {case "+" :
             OperatinAdd oo = new OperatinAdd();
            oner = oo;
            oner.NumberA = 100;
            oner.NumberB = 100;
            break;
       
           case "-":


            OperatinSub o1 = new OperatinSub();
            oner = o1;
            oner.NumberA = 100;
            oner.NumberB = 100;
            break;
        
            case "*":
            OperatinMul o2 = new OperatinMul();
            oner = o2;
            oner.NumberA = 100;
            oner.NumberB = 100;
            break;
        
            case "/" :
            OperatinDiv o3 = new OperatinDiv();
            oner = o3;
            oner.NumberA = 700;
            oner.NumberB = 100;
            break;
        }
}
        public double result()
        {
            return oner.GetResult();//调用相同方法
        }
        
}
    class Program
    {
        static void Main(string[] args)
        {
           cashcontext csah = new cashcontext("/");          
            double ss = csah.result();
            Console.Write(ss);
        }
    }}

策略模式是一种定义一系列算法的方法,从概念上来看所有算法完成相同工作,只是实现不同,都是以相同方式调用所有算法.