设计模式六大原则（一）

单一职责原则（Single Responsibility Principle，缩写SRP）

• 定义：应该有且仅有一个原因引起类的变更（There should never be more than one reason for a class to change），一个类应该是一组高度相关的函数、数据的封装
  

实例

calculateArea($param);
        $squareArea = (new SingleSquareClass())->calculateArea($param);

        // 返回圆形和正方形的面积，不关心内部实现逻辑
        return compact('roundnessArea', 'squareArea');
    }
}

开闭原则（Open Close Principle，缩写OCP）

设计模式的总纲

integral;
    }
}

/**
 * Class VipCalculatePrice
 * @package Factory\SimpleFactory
 */
class VipCalculatePrice extends CalculatePrice
{
    /**
     * @var VipUser
     */
    protected $vipUser;

    /**
     * VipCalculatePrice constructor.
     * @param VipUser $vipUser
     */
    public function __construct(VipUser $vipUser)
    {
        $this->vipUser = $vipUser;
    }

    /**
     * 实现计算
     * @param $count
     * @return float|int|mixed
     */
    function calculate($count)
    {
        if ($this->vipUser->getIntegral() > 0 && $this->vipUser->getIntegral() < 40) {
            return $count * 10;
        } else {
            return $count * 8;
        }
    }
}

/**
 * Class SvipCalculatePrice
 * @package Factory\SimpleFactory
 */
class SvipCalculatePrice extends CalculatePrice
{
    /**
     * 可以看到，不同子类都需要实现计算方法，但是内部实现逻辑可以不同，且没有耦合
     * @param $count
     * @return float|int|mixed
     */
    function calculate($count)
    {
        return $count * 5;
    }
}

/**
 * Class commonCalculatePrice
 * @package Factory\SimpleFactory
 */
class commonCalculatePrice extends CalculatePrice
{
    /**
     * @param $count
     * @return float|int|mixed
     */
    function calculate($count)
    {
        return $count * 20;
    }
}

里氏替换原则（Liskov Substitution Principle，缩写LSP）

integral;
    }
}

/**
 * Class CalculatePrice
 * @package Factory\SimpleFactory
 */
abstract class CalculatePrice
{
    /**
     * @var User
     */
    protected $user;

    /**
     * CalculatePrice constructor.
     * @param User $user
     */
    public function __construct(User $user)
    {
        $this->user = $user;
    }

    /**
     * 定义实现方法
     * @param $count
     * @return mixed
     */
    abstract function calculate($count);
}


/**
 * Class VipCalculatePrice
 * @package Factory\SimpleFactory
 */
class VipCalculatePrice extends CalculatePrice
{
    /**
     * 实现计算
     * @param $count
     * @return float|int|mixed
     */
    function calculate($count)
    {
        // 有子类出现的地方父类未必就可以出现
        if ($this->user->getIntegral() > 0 && $this->user->getIntegral() < 40) {
            return $count * 10;
        } else {
            return $count * 8;
        }
    }
}

// 任何父类出现的地方，子类都能实现
$vipCalculatePrice = new VipCalculatePrice(new VipUser());
$vipCalculatePrice->calculate(12);