策略模式啊

将一组特定的行为和算法封装成类，以适应某些特定的上下文环境，这种模式就是策略模式。也就是说策略模式定义了一系列的算法，并将每一个算法封装起来，而且使他们可以相互替换，策略模式让算法独立于使用它们的客户而独立变化，即封装变化的算法。

适用场景：
1：多个类只区别在表现行为不同，可以使用Strategy模式，在运行时动态选择具体要执行的行为。
2：需要在不同情况下使用不同的策略。
3：对客户隐藏具体策略的实现细节，彼此完全独立。

/**
 * 抽象策略角色--算法接口
 * Interface Strategy
 * @package Phinex\DesignMode\Strategy
 */
interface Strategy
{
    public function AlgorithmInterface();
}

/**
 * 具体策略角色--算法实现者A
 * Class ConcreteStrategyA
 * @package Phinex\DesignMode\Strategy
 */
class ConcreteStrategyA implements Strategy
{
    public function AlgorithmInterface()
    {
        echo '算法A' . PHP_EOL;
    }
}

/**
 * 具体策略角色--具体算法B
 * Class ConcreteStrategyB
 * @package Phinex\DesignMode\Strategy
 */
class ConcreteStrategyB implements Strategy
{
    public function AlgorithmInterface()
    {
        echo '算法B' . PHP_EOL;
    }
}

/**
 * 具体策略角色--算法实现者C
 * Class ConcreteStrategyC
 * @package Phinex\DesignMode\Strategy
 */
class ConcreteStrategyC implements Strategy
{
    public function AlgorithmInterface()
    {
        echo '算法C' . PHP_EOL;
    }
}

/**
 * 环境角色--定义算法抽象及实现
 * Class Context
 * @package Phinex\DesignMode\Strategy
 */
class Context
{
    private $strategy;

    public function __construct(Strategy $strategy)
    {
        $this->strategy = $strategy;
    }

    public function contextInterface()
    {
        $this->strategy->AlgorithmInterface();
    }
}

class StrategyController extends SiteControllerBase
{
    public function testAction()
    {
        $context = new Context(new ConcreteStrategyA());
        $context->contextInterface();

        $context = new Context(new ConcreteStrategyB());
        $context->contextInterface();

        $context = new Context(new ConcreteStrategyC());
        $context->contextInterface();
    }
}

最后，在客户端按需调用合适的算法。

是不是非常简单的一个设计模式。大家有没有发现这个模式和我们最早讲过的简单工厂非常类似
那么他们的区别呢？
工厂相关的模式属于创建型模式，顾名思义，这种模式是用来创建对象的，返回的是new出来的对象。要调用对象的什么方法是由客户端来决定的
而策略模式属性行为型模式，通过执行上下文，将要调用的函数方法封装了起来，客户端只需要调用执行上下文的方法就可以了
在这里，我们会发现，需要客户端来实例化具体的算法类，貌似还不如简单工厂好用，既然这样的话，大家何不尝试一下结合工厂和策略模式一起来实现一个模式呢？
作为思考题将这个实现留给大家，提示：将Context类的__construct变成一个简单工厂方法

既然和简单工厂如此的相像，那么我们也按照简单工厂的方式来说：我们是一个手机厂商（Client），想找某工厂（ConcreteStrategy）来做一批手机，通过渠道商（Context）向这个工厂下单制造手机，渠道商直接去联系代工厂（Strategy），并且直接将生产完成的手机发货给我（ContextInterface()）。同样的，我不用关心他们的具体实现，我只要监督那个和我们联系的渠道商就可以啦，是不是很省心！

抽象策略角色：定义所有支持算法的公共接口，通常是以一个接口或抽象来实现，Context使用这个接口来调用其定义的算法。
具体策略角色：以抽象策略接口实现某具体算法。
环境角色：持有一个策略类的引用，最终给客户端调用。

模式的动机：完成一项任务，往往可以有多种不同的方式，每一种方式称为一个策略，我们可以根据环境或者条件的不同选择不同的策略来完成该项任务。

//抽象策略接口
abstract class Strategy{
    abstract function wayToSchool();
}

//具体策略角色
class BikeStrategy extends Strategy{
    function wayToSchool(){
         echo "骑自行车去上学";
    }
}
class BusStrategy extends Strategy{
    function wayToSchool(){
         echo "乘公共汽车去上学";
    }
}
class TaxiStrategy extends Strategy{
    function wayToSchool(){
         echo "骑出租车去上学";
    }
}

//环境角色
class Context
{
    private $strategy;
    
    //获取具体策略
    public function getStrategy($strategyName)
    {
        try{
            $strategyReflection = new ReflectionClass($strategyName);
            $this->strategy = $strategyReflection->newInstance();
        }catch(ReflectionException $e){
            $this->strategy = ""; 
        }
    }
    
    function goToSchool()
    {
        $this->strategy->wayToSchool();
    }
}

//测试
$context = new Context();
$context->getStrategy("BusStrategy");
$context->goToSchool();

优点：
1：策略模式提供了管理相关算法族的办法，可以把公共的代码转移到父类里面，从而避免重复的代码。
2：策略模式可以处理多种算法或行为。如果不用策略模式，那么使用算法或行为的环境类就可能会有一些子类，每一个子类提供一个不同的算法或行为。但是这样一来算法或行为的使用者就和算法或行为本身混在一起，决定使用哪一种算法或采取哪一种行为的逻辑就和算法或行为的逻辑混合在一起，从而不可能再独立演化。
3：使用策略模式可以避免使用多重条件转移语句。多重条件要写很多if、elseif等语句。

缺点：
1：客户端必须知道所有的策略类，并自行决定使用哪一个策略类。这就意味着客户端必须要理解这些算法的区别，以便适时的选择恰当的算法类，换言之，策略模式只适用于客户端知道所有的算法或行为的情况。
2：策略模式会造成很多的策略类，每个具体策略类都会产生一个新类。

案例：依然还是短信功能，具体的需求可以参看简单工厂模式中的讲解，但是这回我们使用策略模式来实现！

interface Message
{
    public function send();
}

class BaiduYunMessage implements Message
{
    public function send()
    {
        echo '百度云发送信息' . PHP_EOL;
    }
}

class AliYunMessage implements Message
{
    public function send()
    {
        echo '阿里云发送信息！' . PHP_EOL;
    }
}

class JiguangMessage implements Message
{
    public function send()
    {
        echo '极光云发送信息！' . PHP_EOL;
    }
}

class MessageContext
{
    private $message;

    public function __construct(Message $msg)
    {
        $this->message = $msg;
    }

    public function sendMessage()
    {
        $this->message->send();
    }
}

$msgCtx = new MessageContext(new BaiduYunMessage());
 $msgCtx->sendMessage();

 $msgCtx = new MessageContext(new AliYunMessage());
 $msgCtx->sendMessage();

 $msgCtx = new MessageContext(new JiguangMessage());
 $msgCtx->sendMessage();