设计模式总结(一)

• 通过封装，继承，多态把程序的耦合度降低，使程序更加灵活，容易修改，易于复用

  简单工厂

  public class Operation {
        public double NumberA { get; set; }
        public double NumberB { get; set; }
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }
    public class OperationAdd:Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = NumberA + NumberB;
            return result;
        }
    }
    public class OperationFactory
    {
        public static Operation createOperate(string operate)
        {
            Operation oper = null;
            switch (operate)
            {
                case "+":oper = new OperationAdd(); break;
                default:
                    break;
            }
            return oper;
        }
    }
  
            Operation oper;
            oper = OperationFactory.createOperate("+");
            oper.NumberA = 3;
            oper.NumberB = 5;
            double result = oper.GetResult();

  策略模式-基本代码

• 策略模式是一种定义了一系列算法的方法，以相同的方式调用所有的方法，减少了各种算法类与使用算法之间的耦合。

  class Program
   {
       static void Main(string[] args)
       {
           Context context;
  
           context = new Context(new ConcreteStrategyA());
           context.ContextInterface();
  
           context = new Context(new ConcreteStrategyB());
           context.ContextInterface();
  
           context = new Context(new ConcreteStrategyC());
           context.ContextInterface();
  
           Console.Read();
       }
   }
  
   //抽象算法类
   abstract class Strategy
   {
       //算法方法
       public abstract void AlgorithmInterface();
   }
   //具体算法A
   class ConcreteStrategyA : Strategy
   {
       //算法A实现方法
       public override void AlgorithmInterface()
       {
           Console.WriteLine("算法A实现");
       }
   }
   //具体算法B
   class ConcreteStrategyB : Strategy
   {
       //算法B实现方法
       public override void AlgorithmInterface()
       {
           Console.WriteLine("算法B实现");
       }
   }
   //具体算法C
   class ConcreteStrategyC : Strategy
   {
       //算法C实现方法
       public override void AlgorithmInterface()
       {
           Console.WriteLine("算法C实现");
       }
   }
   //上下文
   class Context
   {
       Strategy strategy;
  
       public Context(Strategy strategy)
       {
           this.strategy = strategy;
       }
       //上下文接口
       public void ContextInterface()
       {
           strategy.AlgorithmInterface();
       }
   }

1. 单一职责原则
2. 开放-封闭原则
3. 依赖倒转原则
   • 高层模块不应该依赖低层模块，两个都依赖抽象
   • 抽象不应该依赖细节，细节应该依赖抽象

• 里氏代换原则：子类必须能哆替换掉它们的父类 *父类才能真正被复用，而子类也能够在父类的基础上增加新的行为。

• 依赖倒转其实可以说是面向对象的标志，针对抽象编程而不是针对细节编程，所有的依赖关系都终止于抽象类或者接口，反之就是过程化的设计。

  装饰模式

  class Program
    {
        static void Main(string[] args)
        {
            Person xc = new Person("小菜");
  
            Console.WriteLine("\n第一种装扮：");
  
            Sneakers pqx = new Sneakers();
            BigTrouser kk = new BigTrouser();
            TShirts dtx = new TShirts();