第二章 商场促销——策略模式

2.3简单工厂实现

面向对象编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类。
代码结构图： 代码实现：

/**
 * Class CashSuper
 */
abstract class CashSuper
{
    public function acceptCash($money) {}
}
/**
 * Class CashNormal
 */
class CashNormal extends CashSuper
{
    public function acceptCash($money)
    {
        return $money;
    }
}
/**
 * Class CashRebate
 */
class CashRebate extends CashSuper
{
    private $moneyRebate = 1;
    public function __construct($money_rebate)
    {
        $this->moneyRebate = $money_rebate;
    }
    public function acceptCash($money)
    {
        return bcmul($money, $this->moneyRebate, 2);
    }
}
/**
 * Class CashReturn
 */
class CashReturn extends CashSuper
{
    private $moneyCondition = '0.00';
    private $moneyReturn = '0.00';
    public function __construct($money_condition,$money_return)
    {
        $this->moneyCondition = $money_condition;
        $this->moneyReturn = $money_return;
    }
    public function acceptCash($money)
    {
        $result = $money;
        if ($money >= $this->moneyCondition) {
            $result = bcsub($money, bcmul(bcdiv($money, $this->moneyCondition), $this->moneyReturn, 2), 2);
        }
        return $result;
    }
}

工厂类及客户端代码：

/**
 * Class CashFactory
 */
class CashFactory
{
    public static function createCashAccept($type)
    {
        switch ($type) {
            case '正常收费':
                $cs = new CashNormal();
                break;
            case '满300返100':
                $cs = new CashReturn('300', '100');
                break;
            case '打8折':
                $cs = new CashRebate('0.8');
                break;
        }
        return $cs;
    }
}
$params = $_GET;
$cs = CashFactory::createCashAccept($params['type']);
$total_price = '0.00';
$amount = bcmul($params['price'], $params['num'],2);
$total_price = $cs->acceptCash($amount);
echo '单价：' . $params['price'] . '；数量：' . $params['num'] . '；优惠价格：' . $total_price;

2.4策略模式

策略模式（Strategy）：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。
策略模式（Strategy）结构图 代码示例：
Strategy类，定义所有支持的算法的公共接口

//抽象算法类
abstract class Strategy
{
    //算法方法
    abstract function AlgorithmInterface();
}

ConcreteStrategy，封装了具体的算法或行为，继承于Strategy

//具体算法A
class ConcreteStrategyA extends Strategy
{
    //算法A实现方法
    public function AlgorithmInterface()
    {
        echo '算法A实现<br>';
    }
}
//具体算法B
class ConcreteStrategyB extends Strategy
{
    //算法B实现方法
    public function AlgorithmInterface()
    {
        echo '算法B实现<br>';
    }
}

Context，用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用。

//上下文
class Context
{
    protected $strategy = null;
    public function __construct($strategy) //初始化时，传入具体的策略对象
    {
        $this->strategy = $strategy;
    }
    //上下文接口
    public function contextInterface() //根据具体的策略对象，调用其算法的方法
    {
        $this->strategy->AlgorithmInterface();
    }
}

客户端代码

//由于实例化不同的策略，所以最终在调用$context->contextInterface();时，
//所获得的结果就不尽相同
$context = new Context(new ConcreteStrategyA());
$context->contextInterface();
$context = new Context(new ConcreteStrategyB());
$context->contextInterface();

2.5策略模式实现

代码结构图： CashContext类代码实现：

/**
 * Class CashContext
 */
class CashContext
{
    private $cs_obj;
    public function __construct($cs)
    {
        $this->cs_obj = $cs;
    }
    public function getResult($money)
    {
        return $this->cs_obj->acceptCash($money);
    }
}

客户端代码：

$params = $_GET;
$cc = null;
switch ($params['type']) {
    case '正常收费':
            $cc = new CashContext(new CashNormal());
            break;
    case '满300返100':
            $cc = new CashContext(new CashReturn('300', '100'));
            break;
    case '打8折':
            $cc = new CashContext(new CashRebate('0.8'));
            break;
}
$total_price = '0.00';
$amount = bcmul($params['price'], $params['num'],2);
$total_price = $cc->getResult($amount);
echo '单价：' . $params['price'] . '；数量：' . $params['num'] . '；优惠价格：' . $total_price;

2.6策略与简单工厂结合

改造后的CashContext代码：

class CashContext
{
    protected $cs = null;
    public function __construct($type)
    {
        switch ($type) {
            case '正常收费':
                $this->cs = new CashNormal();
                break;
            case '满300返100':
                $this->cs = new CashReturn('300', '100');
                break;
            case '打8折':
                $this->cs = new CashRebate('0.8');
                break;
        }
    }
    public function getResult($money)
    {
        return $this->cs->acceptCash($money);
    }
}

客户端代码：

$params = $_GET;
$total_price = '0.00';
$cs = new CashContext($params['type']);
$amount = bcmul($params['price'], $params['num'],2);
$total_price = $cs->getResult($amount);
echo '单价：' . $params['price'] . '；数量：' . $params['num'] . '；优惠价格：' . $total_price;

2.7策略模式解析

• 策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。
• 策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能。
• 策略模式的优点是简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。
• 当不同的行为堆砌在一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句。
• 策略模式就是用来封装算法的，但在实践中，我们发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策略模式处理这种变化的可能性。
• 在基本的策略模式中，选择所用具体实现的职责由客户端对象承担，并转给策略模式的Context对象。这本身并没有解除客户端需要选择判断的压力，而策略模式与简单工厂模式结合后，选择具体实现的职责也可以由Context来承担，这就最大化地减轻了客户端的职责。

任何需求的变更都是需要成本的。