第 11 章 桥梁模式

<?php
header("Content-type: text/html; charset=UTF-8");

/**
 * 桥梁模式
 *
 * 今天我要说说我自己，梦想中的我自己，我身价过亿，有两个大公司，一个是房地产公司，一个是服装制造
 * 业，这两个公司都很赚钱，天天帮我在累加财富，其实是什么公司我倒是不关心，我关心的是是不是在赚钱，赚
 * 了多少，这才是我关心的，我是商人呀，唯利是图是我的本性，偷税漏税是我的方法，欺上瞒下、压榨员工血汗
 * 我是的手段嘛
 */


/**
 * 这是我整个集团公司的产品类
 */
abstract class Product {
    /**
     * 甭管是什么产品它总要是能被生产出来
     */
    public abstract function beProducted();
    
    /**
     * 生产出来的东西，一定要销售出去，否则扩本呀
     */
    public abstract function beSelled();
}

//简单，忒简单了，看House 产品类：

/**
 * 这是我集团公司盖的房子
 */
class House extends Product {
    /**
     * 豆腐渣就豆腐渣呗，好歹也是个房子
     */
    public function beProducted() {
        echo "生产出的房子是这个样子的...<br>";
    }
    
    /**
     * 虽然是豆腐渣，也是能够销售出去的
     */
    public function beSelled() {
        echo "生产出的房子卖出去了...<br>";
    }
}


// 不多说，看Clothes 产品类：

/**
 * 我集团公司生产的衣服
 */
class Clothes extends Product {
    public function beProducted() {
        echo "生产出的衣服是这个样子的...<br>";
    }

    public function beSelled() {
        echo "生产出的衣服卖出去了...<br>";
    }
}

// 下面是iPod 产品类：

/**
 * 生产iPod了
 */
class IPod extends Product {
    public function beProducted() {
        echo "生产出的iPod是这个样子的...<br>";
    }
    
    public function beSelled() {
        echo "生产出的iPod卖出去了...<br>";
    }
}

// 产品类是有了，那我们再看Corp 抽象类：

/**
 * 定义一个公司的抽象类
 */
abstract class Corp {
    /**
     * 定义一个产品对象，抽象的了，不知道具体是什么产品
     */
    private $product;
    
    /**
     * 构造函数，由子类定义传递具体的产品进来
     */
    public function __construct(Product $product){
        $this->product = $product;
    }
    
    /**
     * 公司是干什么的？赚钱的呀，不赚钱傻子才干
     */
    public function makeMoney(){
        //每个公司都是一样，先生产
        $this->product->beProducted();
        
        //然后销售
        $this->product->beSelled();
    }
}

// 这里多了个有参构造，其目的是要继承的子类都必选重写自己的有参构造函数，把产品类传递进来，再看子
// 类HouseCorp 的实现：

/**
 * 房地产公司，按照翻译来说应该叫realty corp，这个是比较准确的翻译
 * 但是我问你房地产公司翻译成英文，你第一反应什么？对嘛还是house corp!
 */
class HouseCorp extends Corp {
    /**
     * 定义传递一个House产品进来
     */
    public function __construct(House $house){
        parent::__construct($house);
    }
    
    /**
     * 房地产公司很High了，赚钱，计算利润
     */
    public function makeMoney(){
        parent::makeMoney();
        
        echo "房地产公司赚大钱了...<br>";
    }
}


// 理解上没有多少难度，不多说，继续看山寨公司的实现:

/**
 * 我是山寨老大，你流行啥我就生产啥
 */
class ShanZhaiCorp extends Corp {
    /**
     * 产什么产品，不知道，等被调用的才知道
     */
    public function __construct(Product $product){
        parent::__construct($product);
    }
    
    /**
     * 狂赚钱
     */
    public function makeMoney(){
        parent::makeMoney();
        
        echo "我赚钱呀...<br>";
    }
}


// HouseCorp 类和ShanZhaiCorp 类的区别是在有参构造的参数类型上，HouseCorp 类比较明确，我就是
// 只要House 类，所以直接定义传递进来的必须是House 类， 一个类尽可能少的承担职责，那方法也是一样，
// 既然HouseCorp 类已经非常明确只生产House 产品，那为什么不定义成House 类型呢？ShanZhaiCorp 就
// 不同了，它是确定不了生产什么类型。

$house = new House();
echo "-------房地产公司是这个样子运行的-------<br>";
//先找到我的公司
$houseCorp = new HouseCorp($house);
//看我怎么挣钱
$houseCorp->makeMoney();

echo "<br><br>";


//山寨公司生产的产品很多，不过我只要制定产品就成了
echo "-------山寨公司  Clothes 是这样运行的-------<br>";
$shanZhaiCorp = new ShanZhaiCorp(new Clothes());
$shanZhaiCorp->makeMoney();
echo "<br><br>";

echo "-------山寨公司  IPod 是这样运行的-------<br>";
$shanZhaiCorp = new ShanZhaiCorp(new IPod());
$shanZhaiCorp->makeMoney();
echo "<br><br>";

/**
 * 那我们深入的思考一下，
 * 既然万物都是运动的，我现在只有房地产公司和山寨公司，那以后我会不会增加一些其他的公司呢？或者房地产
 * 公司会不会对业务进行细化，比如分为公寓房公司，别墅公司，以及商业房公司等等呢？那我告诉你，会的，绝
 * 对的会的，但是你发觉没，这种变化对我们上面的类图没有大的修改，充其量是扩展，你看呀：
 *
 * 增加公司，你要么继承Corp 类，要么继承HouseCorp 或ShanZhaiCorp，不用再修改原有的类了；
 *
 * 增加产品，继承Product 类，或者继承House 类，你要把房子分为公寓房、别墅、商业用房等等；
 *
 * 你都是在扩展，唯一你要修改的就是Client 类，你类都增加了哪能不修改调用呢，也就是说Corp 类和
 *
 * Product 类都可以自由的扩展，而不会对整个应用产生太的变更，这就是桥梁模式。
 *
 *
 * 桥梁模式的优点就是类间解耦，我们上面已经提到，两个角色都可以自己的扩展下去，不会相互影响，这个
 * 也符合OCP 原则。
 *
 *
 * 今天说到桥梁模式，那就多扯几句，大家对类的继承有什么看法吗？继承的优点有很多，可以把公共的方法
 * 或属性抽取，父类封装共性，子类实现特性，这是继承的基本功能，缺点有没有？有，强关联关系，父类有个方
 * 法，你子类也必须有这个方法，是不可选择的，那这会带来扩展性的问题，我举个简单的例子来说明这个问题：
 * Father 类有一个方法A，Son 继承了这个方法，然后GrandSon 也继承了这个方法，问题是突然有一天Son
 * 要重写父类的这个方法，他敢做吗？绝对不敢！GrandSon 可是要用从Father 继承过来的方法A，你修改了，
 * 那就要修改Son 和GrandSon 之间的关系，那这个风险就大了去。
 *
 *
 * 今天讲的这个桥梁模式就是这一问题的解决方法，桥梁模式描述了类间弱关联关系，还说上面的那个例子，
 * Fater 类完全可以把可能会变化的方法放出去，Son 子类要有这个方法很简答，桥梁搭过去，获得这个方法，
 * GrandSon 也一样，即使你Son 子类不想使用这个方法了，也没关系，对GrandSon 不产生影响，他不是从你
 * Son 中继承来的方法！
 *
 *
 * 继承不能说它不好，非常好，但是有缺点的，我们可以扬长避短，对于比较明确不发生变化的，则通过继承
 * 来完成，若不能确定是否会发生变化的，那就认为是会发生变化，则通过桥梁模式来解决，这才是一个完美的世
 * 界。
 */

运行结果：

-------房地产公司是这个样子运行的-------
生产出的房子是这个样子的...
生产出的房子卖出去了...
房地产公司赚大钱了...


-------山寨公司 Clothes 是这样运行的-------
生产出的衣服是这个样子的...
生产出的衣服卖出去了...
我赚钱呀...


-------山寨公司 IPod 是这样运行的-------
生产出的iPod是这个样子的...
生产出的iPod卖出去了...
我赚钱呀...