设计模式学习记录

简单工厂模式：
- 创建型模式
- 基本实现：所有产品类继承自产品接口/父类，工厂类根据输入创建产品实例
- 全部的创建逻辑都在工厂类中实现，客户端只需要了解创建参数，而无需关心创建实例的具体细节

简单工厂模式

//父类
public abstract class Operation
{
    public int num1;
    public int num2;
    public abstract int GetResult();
}

//产品类1
public class AddOperation : Operation
{
    public override int GetResult()
    {
        return num1 + num2;
    }
}

//产品类2
public class MinusOperation : Operation
{
    public override int GetResult()
    {
        return num1 - num2;
    }
}

//产品工厂
public class OperationFatory
{
    public static Operation CreatOperation(string op)
    {
        Operation operation = null;
        if (op == "+")
        {
            operation = new AddOperation();
        }
        else if (op == "-")
        {
            operation = new MinusOperation();
        }

        return operation;
    }
}

//客户端调用
Operation operation=OperationFatory.CreatOperation("+");

策略模式
- 定义了算法家族，分别封装起来，让彼此之间可以相互替换
- 基本实现：所有的具体算法都继承自算法父类/接口，在上下文中包含了对算法类的引用
- 与工厂方法的区别：工厂方法是创建了具体的产品，策略模式是通过在创建上下文对象实现对不同算法的引用。工厂方法侧重于创建，策略模式侧重于对某一具体方法的引用

策略模式

//算法父类
public abstract class Strategy
{
    public abstract void AlgorithmInterface();
}

//A类算法
public class ConcrateStrategyA : Strategy
{
    public override void AlgorithmInterface()
    {
        //A类算法实现
    }
}

//B类算法
public class ConcrateStrategyB : Strategy
{
    public override void AlgorithmInterface()
    {
        //B类算法实现
    }
}

 //C类算法
public class ConcrateStrategyC : Strategy
{
    public override void AlgorithmInterface()
    {
        //C类算法实现
    }
}

//上下文类
public class Context
{
    Strategy strategy;

    public Context(Strategy strategy)
    {
        this.strategy = strategy;
    }

    public void ContextInterface()
    {
        this.strategy.AlgorithmInterface();
    }
}

//客户端调用
Context context=new Context(new ConcrateStrategyA ());
context.ContextInterface();

装饰模式
- 解释：动态的给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更灵活
- 即通过创建装饰者类来包裹另一对象并同时添加自身特有的功能
- ConcrateComponent根据实际情况添加或删除
  
  装饰模式

public abstract class Component
{
    public abstract void Operation();
}

public abstract class Decorator : Component
{
    protected Component component;

    public void SetComponent(Component c)
    {
        component = c;
    }

    public override void Operation()
    {
        if (component != null)
        {
            component.Operation();
        }
    }
}

public class ConcrateDecoratorA : Decorator
{
    public void AOperation()
    {
        //A特有的功能
    }

    public override void Operation()
    {
        base.Operation();
        AOperation();
    }
}

public class ConcrateDecoratorB : Decorator
{
    public void BOperation()
    {
        //B特有的功能
    }

    public override void Operation()
    {
        base.Operation();
        BOperation();
    }
}

//客户端调用
        ConcrateDecoratorA ca = new ConcrateDecoratorA();
        ConcrateDecoratorB cb = new ConcrateDecoratorB();
        //ConcrateDecoratorC cc = new ConcrateDecoratorC();
        cb.SetComponent(ca);
        //cc.SetComponent(cb);
        cb.Operation();
        //cc.Operation();  //最终产生链式关系

代理模式
- 解释：为其他对象提供一个代理以控制对这个对象的访问
- 代理类和真实请求类同继承于请求接口（或抽象类），代理类包裹真实请求类
- 该模式一般用于远程代理、虚拟代理、安全代理
  
  代理模式

public abstract class Subject
{
    public abstract void Request();
}

public class RealSubject : Subject
{
    public override void Request()
    {
        //真实请求
    }
}

public class Proxy : Subject
{
    RealSubject realSubject;
    public override void Request()
    {
        if (realSubject == null)
        {
            realSubject = new RealSubject();
        }
        realSubject.Request();
    }
}

工厂方法模式
原型模式：解决结构复杂的对象的创建工作

public object Clone()
{
  return this.MemberwiseClone();
}

模板方法模式：在父类中定义抽象方法以及算法骨架，通过在不同的子类中重写抽象方法，借助多态实现不同的行为（即：将父类中可变的行为延迟到子类中实现）
外观模式：有多个类，每个类有自己的行为，在外观类中实例化这些类，并定义方法对这些类的行为进行组合。调用者只需要调用外观类中的方法即可
建造者模式：主要用于构建复杂的对象，这些对象内部构建间的建造顺序通常时未定的，但对象内部的构建通常面临着复杂的变化

在抽象父类中定义对象的构建顺序，在不同的子类中实现不同的构建方法。通过在指挥者类中使用里氏替换法则声明父类对象实现不同的构建

抽象工厂模式：数据库案例
状态模式：
- 消除庞大的分支语句
- 当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，可以使用状态模式
适配器模式：
- 主要应用于希望复用一些现存的类，但是接口又与复用环境要求不一致
- 适配器模式分为：类适配器模式，对象适配器模式
  
  类适配器模式
  
  对象适配器
备忘录模式：
- 应用：保存信息并还原
- 使用Caretaker保存备忘录并用于还原
  
  备忘录模式

14 组合模式：
- 即创建xml文档的方式，所有的元素都可以看作xmlNode，通过对xmlNode组合获得xml文档
- 当需求中体现的是部分与整体层次结构时可以使用组合模式

组合模式

单例模式
桥接模式
- 将抽象部分与它的实现部分分离，使它们都可以独立地变化
  
  桥接模式

abstract class Abstractor
{
    protected Implementor implementor;

    public void SetImplementor(Implementor implementor)
    {
        this.implementor = implementor;
    }

    public virtual void Operation()
    {
        implementor.Operation();
    }
}

abstract class Implementor
{
    public abstract void Operation();
}

命令模式
- 将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作。
- Receiver可以是任意类，只要它知道如何真正执行一个命令
  
  命令模式

public abstract class Command
{
    public Receiver receiver;

    public Command(Receiver rcv)
    {
        receiver = rcv;
    }

    public abstract void Excute();
}

public class ConcrateCommand : Command
{
    public ConcrateCommand(Receiver rcv) : base(rcv)
    { }

    public override void Excute()
    {
        receiver.Action();
    }
}

public class Invoker
{
    public List commands;

    public void AddCommand(Command cmd)
    { }

    public void RemoveCommand(Command cmd)
    { }

    public void Notify()
    {
        for (int i = 0; i < commands.Count; i++)
        {
            commands[i].Excute();
        }
    }
}

public class Receiver
{
    public void Action()
    {
        //真正执行命令
    }
}

职责链模式
- 当用户提交一个请求时，请求按职责链传递直至有一个ConcrateHandler处理
- 可方便添加、修改处理者
  
  职责链模式

public abstract class Manager
{
    public Manager nextHandler;
    public void SetNextHandler(Manager nth)
    {
        nextHandler = nth;
    }

    public abstract void Handle(Request res);
}

public class JingLi : Manager
{
    public override void Handle(Request res)
    {
        if (res.num<2)
        {
            Debug.Log("经理处理");
        }
        else
        {
            nextHandler.Handle(res);
        }
    }
}

public class ZongJian : Manager
{
    public override void Handle(Request res)
    {
        if (res.num < 5)
        {
            Debug.Log("总监处理");
        }
        else
        {
            nextHandler.Handle(res);
        }
    }
}

public class ZongJingLi : Manager
{
    public override void Handle(Request res)
    {
        Debug.Log("总经理处理，" + res.num);
    }
}

public class Request
{
    public int num;
}

中介者模式
- 多个同事类通过中介者交互，即中介者了解所有的同事类
- 同事类不需要了解其他同事类，只需要了解中介者类，处理逻辑在中介者类中实现
  
  中介者模式

public abstract class Mediator
{
    public Colleague colleagueA;
    public Colleague colleagueB;

    public abstract void TransformMessage(Colleague colleague, string str);
}

public abstract class Colleague
{
    public Mediator mediator;

    public Colleague(Mediator mediator)
    {
        this.mediator = mediator;
    }

    public abstract void SendMessage(string str);
    public abstract void GetMessage(string str);
}

public class ConcrateMediator : Mediator
{
    public override void TransformMessage(Colleague colleague, string str)
    {
        if (colleague == colleagueA)
        {
            colleagueB.GetMessage(str);
        }
        else if (colleague == colleagueB)
        {
            colleagueA.GetMessage(str);
        }
    }
}

public class ConcrateColleagueA : Colleague
{
    public ConcrateColleagueA(Mediator mediator) : base(mediator)
    { }

    public override void GetMessage(string str)
    {
        Debug.Log("A获得信息：" + str);
    }

    public override void SendMessage(string str)
    {
        mediator.TransformMessage(this,str);
    }
}

public class ConcrateColleagueB : Colleague
{
    public ConcrateColleagueB(Mediator mediator) : base(mediator)
    { }

    public override void GetMessage(string str)
    {
        Debug.Log("B获得信息：" + str);
    }

    public override void SendMessage(string str)
    {
        mediator.TransformMessage(this, str);
    }
}

享元模式
解释器模式

设计模式学习记录

你可能感兴趣的:(设计模式学习记录)