常用设计模式整理

简单工厂模式：

• 用一个单独的类完成创建实例的过程

// Example
// 创建基类
public class Father{...}
// 根据情况创建对应的子类，并覆写必要的方法
public class Son1 : Father {...}
public class Son2 : Father {...}
// 创建工厂类，工厂类根据情况创建需要的实例
public class Factroy
{
  Father father = null;
  swith(operate)
  {
    case "Son1":
      father = new Son1();
    case "...":
      father = ...
  }
  // 后续操作
}

策略模式：

• 分别定义和封装算法家族，这些算法完成相同的工作，只是实现不同
• 由一个Context类来负责维护需要使用的算法类，而减少客户端的影响，简化了单元测试

// Example
// 创建抽象类
pulic abstract class Father
{
  //定义需要实现的方法
}
// 创建不同算法的类继承抽象类，实现对应的方法
public class Son1 : Father{...}
public class Son2 : Father{...}
// 创建维护类，有维护类保持对算法类的控制，根据情况创建需要的算法
public class Context
{
  // 保有对算法的引用
  Father father;
  // 创建的时候传入需要的实例
  public Context(Father father)
  {
    this.father = father;
  }
} 

装饰模式：

• 动态的给某对象添加额外的职责的模式
• 将类中的装饰功能分离，留下核心的功能
• 在根据需要动态的改变类所需要的装饰功能，去除重复的逻辑
• 主体维持一个装饰（或为空），装饰维持一个装饰（或为空）

// Example
// 抽象类定义操作方法
abstract class Component
{
  public abstract void Operation();
}

// MainObject类定义被装饰对象并添加职责
class MainObject : Component 
{
  public overrive void Operation()
  {
    ......
  }
}
// Decorator类用来装饰抽象类，继承Component
abstract class Decorator : Component
{
  protected Component component;
  
  public void SetComponent(Component component)
  {
    this.component = component;
  }
  
  public override void Operation()
  {
    if(component != null)
    {
      component.Operation();
    }
  }
}

代理模式：

• 为其他对象提供一种代理以控制对这个对象的访问
• 为一个对象在不同的地址空间提供局部代表
• 可以隐藏一个对象存在于不同地址空间的事实
• 用来控制真是对象访问时候的权限
• 当调用真实对象的时候，代理可以处理另外I的事情

// Example
// 定义代理和引用对象的共同接口
abstact class Subject
{
  public abstract void Request();
}
// 真实调用的类
class RealSubject : Subject
{
  public override void Request()
  {
    ...
  }
}
// 代理类
class Proxy : Subject
{
  RealSubject realSubject;
  public override void Request()
  {
    if(realSubject == null)
    {
      realSubject = new RealSubject();
      ...
    }
    realSubject.Request();
  }
}

工厂方法模式