22.2 緊耦合程式演化

兩個手機品牌，都有遊戲，兩個手機是不同的作業系統。怎麼寫？
該有一個父類手機品牌遊戲，讓N和M品牌手機遊戲都繼承它。

如果N和M品牌手機又都增加了通訊錄功能呢？

基於這個模型，那如果新增加一個手機品牌，並且每個手機品牌增加各種功能，例如：遊戲、通訊錄、MP3等。

那樣就會變得非常麻煩。

繼承的問題
無法在執行時改變從父類繼承的實現，子類和父類依賴關係緊密，父類中任何變化都會導致子類發生變化。
當複用子類時，如果繼承下來的子類不適合解決新問題，則父類必須重寫或被其他更適合的類替換，導致限制了複用性。

面向物件中首先使用合成/聚合複用原則

22.3 合成/聚合複用原則

聚合
表示“弱”的擁有關係，A物件可包含B物件，但B物件不是A物件的一部分；
合成
是一種“強”的擁有關係，部分和整體的生命週期是一樣的。

大雁和翅膀就類似於合成關係；每隻大雁是屬於一個雁群，一個雁群有多隻大雁，所以大雁和雁群是聚合關係。

好處
優先使用物件的合成/聚合有助於你保持每個類被封裝，並被集中在單個任務上。這樣類和類繼承層次會保持較小規模，且不太可能增長為不控制的龐然大物。

22.4 鬆耦合的程式

根據這個原則，修改之前的類結構。

手機品牌包含有手機軟體，但軟體不是品牌的一部分，所以是聚合關係。

手機軟體

public abstract class HandsetSoft {
    public abstract void run();
}

遊戲、通訊錄等具體類

public class HandsetGame extends HandsetSoft {

    @Override
    public void run(){
        println("遊戲");
    }
}

public class HandsetAddress extends HandsetSoft {

    @Override
    public void run(){
        println("通訊錄"
 
);
    }
}

手機品牌類

public abstract class HandsetBrand {
    //弱聚合
    protected HandsetSoft soft;

    //設定手機軟體
    public void setHandsetSoft(HandsetSoft soft){
        this.soft = soft;
    }

    //執行
    public abstract void run();
}

品牌N品牌M等具體類

//品牌N
class HandsetBrandN extends HandsetBrand {

    @Override
    public void run(){
        soft.run();
    }
}

//品牌M
class HandsetBrandM extends HandsetBrand {

    @Override
    public void run(){
        soft.run();
    }
}

客戶端

public class Main {
    HandsetBrand ab;
    //建立品牌N
    ab = new HandsetBrandN();

    //給品牌N安裝遊戲
    ab.setHandsetSoft(new HandsetGame());
    ab.run();

    //給品牌N安裝通訊錄
    ab.setHandsetSoft(new HandsetAddress());
    ab.run();
}

22.5 橋接模式

將抽象部分和它的實現部分分離，使它們都可以獨立的變化。

就像之前例子，讓手機既可以按品牌分類，也可以按功能來分類。

Implementor類

public abstract class Implementor {
    public abstract void operation();
}

ConcreteImplementorA和ConcreteImplementorB等派生類

public class ConcreteImplementorA extends Implementor{
    @Override
    public void operation(){
        println("具體實現A的方法執行");
    }
}

public class ConcreteImplementorB extends Implementor{
    @Override
    public void operation(){
        println("具體實現B的方法執行");
    }
}

Abstraction類

public abstract class Abstraction {
    protected Implementor impl;

    public Abstraction(Implementor impl){
        this.impl = impl;
    }

    public abstract void operation();
}

RefinedAbstraction類

public class RefinedAbstraction extends Abstraction {
    public RefinedAbstraction(Implementor impl){
        super(impl);
    }

    @Override
    public void operation(){
        impl.operation();
    }
}

客戶端實現

public class Main {
    public static void main(String[] args){
        Abstraction ab = new RefinedAbstraction(new ConcreteImplementorA());
        ab.operation();

        ab = new RefinedAbstraction(new ConcreteImplementorB());
        ab.operation();
    }
}