定义

• 定义一系列相同算法的方法
• 将一系列完成相同工作的不同组织起来，用相同的方法调用全部的方法
• 可以以相同的方式调用所有算法，减少各种算法类与使用算法类之间的耦合

核心

1. 组织同类型方法
2. 创建基类实例，统一方法调用基类方法

如何使用

1. 有一个需求，需要以不同的方式 A B C 完成。创建基类Super，需要实现方法Method，子类A B C ，都需要实现方法
2. 创建上下文类 SuperContext，完成两件事，创建实例，创建一个方法调用方法Method
3. 创建上下文 SuperContext 实例，调用统一方法Method

abstract Super
{
   abstract void Method();
}

class A:Super
{
    public void Method(){}
}

class B:Super
{
   public void Method(){}
}

class SuperContext
{
    private Super su;

    //策略，实现基类实例
    public SuperContext(Super super)
    {
        su = super;
    }
    
    //策略 + 简单工厂
    public SuperContext(int index)
    {
        switch(index)
        {
            case 1:
                su = new A();
                break;
            case 2:
                su = new B();
                break;
        }
    }
    
    //公共调用方法
    public void GetMethod()
    {
        su.Method();
    }

}

void Main()
{
    SuperContext sc = new SuperContext(1);
    sc.GetMethod();
    SuperContext sc = new SuperContext(2);
    sc.GetMethod();
}

使用场景

存在多种同系列的算法，用统一的方法去调用

策略模式与工厂模式的比较

• 工厂模式是将一系列方法组织到一起，然后提供一个方法去返回这些方法的实例，供外部调用实例的方法。
• 策略模式是将一系列方法组织在一起，然后提供上下文对象，不返回这些方法的实例，而是实现实例。
• 然后通过一个方法，去调用这系列的方法，然后该方法供外部调用

策略 + 简单工厂

• 策略模式缺少需要调用哪一个基类方法的判断，这部分判断需要调用者自己去判断。
• 而简单工厂是通过判断传参，来创建不同基类的实例，调用者只用传参，不用自己判断。
• 所以将策略模式的上下文构造改为参数判断，通过判断来实例，减少了调用者判断的麻烦