物件導向-設計模式-結構型

物件導向-設計模式-結構型

 

　　　　　　一年好景君須記，最是橙黃橘綠時。

 

簡介：物件導向-設計模式-結構型。

一、概述

何謂設計模式：

設計模式(Design Pattern)是一套被反覆使用、多數人知曉的、經過分類的、程式碼設計經驗的總結。

設計模式的好處&學習目的：

1、為了程式碼可重用行、讓程式碼更易被他人理解、保證程式碼的可靠性、使程式碼編寫真正實現工程化；

2、設計模式便於我們維護專案，增強系統的健壯性和可擴充套件性；

3、設計模式還可以鍛鍊碼農的設計思維、昇華程式碼質量等。

二、結構型

介面卡模式、橋接模式、組合模式、裝飾模式、外觀模式、享元模式、代理模式。

1. 介面卡（Adapter）

Intent

把一個類介面轉換成另一個使用者需要的介面。

Class Diagram

Implementation

鴨子（Duck）和火雞（Turkey）擁有不同的叫聲，Duck 的叫聲呼叫 quack() 方法，而 Turkey 呼叫 gobble() 方法。

要求將 Turkey 的 gobble() 方法適配成 Duck 的 quack() 方法，從而讓火雞冒充鴨子！

public interface Duck {
    void quack();
}

public interface Turkey {
    void gobble();
}

public class WildTurkey implements Turkey {
    @Override
    public void gobble() {
        System.out.println("gobble!");
    }
}

public class TurkeyAdapter implements Duck {
    Turkey turkey;

    public TurkeyAdapter(Turkey turkey) {
        this.turkey = turkey;
    }

    @Override
    public void quack() {
        turkey.gobble();
    }
}

public class Client {
    public static void main(String[] args) {
        Turkey turkey = new WildTurkey();
        Duck duck = new TurkeyAdapter(turkey);
        duck.quack();
    }
}

2. 橋接（Bridge）

Intent

將抽象與實現分離開來，使它們可以獨立變化。

Class Diagram

• Abstraction：定義抽象類的介面
• Implementor：定義實現類介面

Implementation

RemoteControl 表示遙控器，指代 Abstraction。

TV 表示電視，指代 Implementor。

橋接模式將遙控器和電視分離開來，從而可以獨立改變遙控器或者電視的實現。

public abstract class TV {
    public abstract void on();

    public abstract void off();

    public abstract void tuneChannel();
}

public class Sony extends TV {
    @Override
    public void on() {
        System.out.println("Sony.on()");
    }

    @Override
    public void off() {
        System.out.println("Sony.off()");
    }

    @Override
    public void tuneChannel() {
        System.out.println("Sony.tuneChannel()");
    }
}

public class RCA extends TV {
    @Override
    public void on() {
        System.out.println("RCA.on()");
    }

    @Override
    public void off() {
        System.out.println("RCA.off()");
    }

    @Override
    public void tuneChannel() {
        System.out.println("RCA.tuneChannel()");
    }
}

public abstract class RemoteControl {
    protected TV tv;

    public RemoteControl(TV tv) {
        this.tv = tv;
    }

    public abstract void on();

    public abstract void off();

    public abstract void tuneChannel();
}

public class ConcreteRemoteControl1 extends RemoteControl {
    public ConcreteRemoteControl1(TV tv) {
        super(tv);
    }

    @Override
    public void on() {
        System.out.println("ConcreteRemoteControl1.on()");
        tv.on();
    }

    @Override
    public void off() {
        System.out.println("ConcreteRemoteControl1.off()");
        tv.off();
    }

    @Override
    public void tuneChannel() {
        System.out.println("ConcreteRemoteControl1.tuneChannel()");
        tv.tuneChannel();
    }
}

public class ConcreteRemoteControl2 extends RemoteControl {
    public ConcreteRemoteControl2(TV tv) {
        super(tv);
    }

    @Override
    public void on() {
        System.out.println("ConcreteRemoteControl2.on()");
        tv.on();
    }

    @Override
    public void off() {
        System.out.println("ConcreteRemoteControl2.off()");
        tv.off();
    }

    @Override
    public void tuneChannel() {
        System.out.println("ConcreteRemoteControl2.tuneChannel()");
        tv.tuneChannel();
    }
}

public class Client {
    public static void main(String[] args) {
        RemoteControl remoteControl1 = new ConcreteRemoteControl1(new RCA());
        remoteControl1.on();
        remoteControl1.off();
        remoteControl1.tuneChannel();
        RemoteControl remoteControl2 = new ConcreteRemoteControl2(new Sony());
         remoteControl2.on();
         remoteControl2.off();
         remoteControl2.tuneChannel();
    }
}

3. 組合（Composite）

Intent

將物件組合成樹形結構來表示“整體/部分”層次關係，允許使用者以相同的方式處理單獨物件和組合物件。

Class Diagram

元件（Component）類是組合類（Composite）和葉子類（Leaf）的父類，可以把組合類看成是樹的中間節點。

組合物件擁有一個或者多個元件物件，因此組合物件的操作可以委託給元件物件去處理，而元件物件可以是另一個組合物件或者葉子物件。

Implementation

public abstract class Component {
    protected String name;

    public Component(String name) {
        this.name = name;
    }

    public void print() {
        print(0);
    }

    abstract void print(int level);

    abstract public void add(Component component);

    abstract public void remove(Component component);
}

public class Composite extends Component {

    private List<Component> child;

    public Composite(String name) {
        super(name);
        child = new ArrayList<>();
    }

    @Override
    void print(int level) {
        for (int i = 0; i < level; i++) {
            System.out.print("--");
        }
        System.out.println("Composite:" + name);
        for (Component component : child) {
            component.print(level + 1);
        }
    }

    @Override
    public void add(Component component) {
        child.add(component);
    }

    @Override
    public void remove(Component component) {
        child.remove(component);
    }
}

public class Leaf extends Component {
    public Leaf(String name) {
        super(name);
    }

    @Override
    void print(int level) {
        for (int i = 0; i < level; i++) {
            System.out.print("--");
        }
        System.out.println("left:" + name);
    }

    @Override
    public void add(Component component) {
        throw new UnsupportedOperationException(); // 犧牲透明性換取單一職責原則，這樣就不用考慮是葉子節點還是組合節點
    }

    @Override
    public void remove(Component component) {
        throw new UnsupportedOperationException();
    }
}

public class Client {
    public static void main(String[] args) {
        Composite root = new Composite("root");
        Component node1 = new Leaf("1");
        Component node2 = new Composite("2");
        Component node3 = new Leaf("3");
        root.add(node1);
        root.add(node2);
        root.add(node3);
        Component node21 = new Leaf("21");
        Component node22 = new Composite("22");
        node2.add(node21);
        node2.add(node22);
        Component node221 = new Leaf("221");
        node22.add(node221);
        root.print();
    }
}

輸出：
Composite:root
--left:1
--Composite:2
----left:21
----Composite:22
------left:221
--left:3

4. 裝飾（Decorator）

Intent

為物件動態新增功能。

Class Diagram

裝飾者（Decorator）和具體元件（ConcreteComponent）都繼承自元件（Component），具體元件的方法實現不需要依賴於其它物件，而裝飾者組合了一個元件，這樣它可以裝飾其它裝飾者或者具體元件。所謂裝飾，就是把這個裝飾者套在被裝飾者之上，從而動態擴充套件被裝飾者的功能。裝飾者的方法有一部分是自己的，這屬於它的功能，然後呼叫被裝飾者的方法實現，從而也保留了被裝飾者的功能。可以看到，具體元件應當是裝飾層次的最低層，因為只有具體元件的方法實現不需要依賴於其它物件。

 

 

Implementation

設計不同種類的飲料，飲料可以新增配料，比如可以新增牛奶，並且支援動態新增新配料。每增加一種配料，該飲料的價格就會增加，要求計算一種飲料的價格。

下圖表示在 DarkRoast 飲料上新增新新增 Mocha 配料，之後又新增了 Whip 配料。DarkRoast 被 Mocha 包裹，Mocha 又被 Whip 包裹。它們都繼承自相同父類，都有 cost() 方法，外層類的 cost() 方法呼叫了內層類的 cost() 方法。

 

 

public interface Beverage {
    double cost();
}

public class DarkRoast implements Beverage {
    @Override
    public double cost() {
        return 1;
    }
}

public class HouseBlend implements Beverage {
    @Override
    public double cost() {
        return 1;
    }
}

public abstract class CondimentDecorator implements Beverage {
    protected Beverage beverage;
}

public class Milk extends CondimentDecorator {

    public Milk(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public double cost() {
        return 1 + beverage.cost();
    }
}

public class Mocha extends CondimentDecorator {

    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public double cost() {
        return 1 + beverage.cost();
    }
}

public class Client {

    public static void main(String[] args) {
        Beverage beverage = new HouseBlend();
        beverage = new Mocha(beverage);
        beverage = new Milk(beverage);
        System.out.println(beverage.cost());  // 3.0
    }
}

設計原則

類應該對擴充套件開放，對修改關閉：也就是新增新功能時不需要修改程式碼。飲料可以動態新增新的配料，而不需要去修改飲料的程式碼。

不可能把所有的類設計成都滿足這一原則，應當把該原則應用於最有可能發生改變的地方。

5. 外觀（Facade）

Intent

提供了一個統一的介面，用來訪問子系統中的一群介面，從而讓子系統更容易使用。

Class Diagram

Implementation

觀看電影需要操作很多電器，使用外觀模式實現一鍵看電影功能。

public class SubSystem {
    public void turnOnTV() {
        System.out.println("turnOnTV()");
    }

    public void setCD(String cd) {
        System.out.println("setCD( " + cd + " )");
    }

    public void startWatching(){
        System.out.println("startWatching()");
    }
}

public class Facade {
    private SubSystem subSystem = new SubSystem();

    public void watchMovie() {
        subSystem.turnOnTV();
        subSystem.setCD("a movie");
        subSystem.startWatching();
    }
}

public class Client {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.watchMovie();
    }
}

設計原則

最少知道原則：只和你的密友談話。也就是說客戶物件所需要互動的物件應當儘可能少。

6. 享元（Flyweight）

Intent

利用共享的方式來支援大量細粒度的物件，這些物件一部分內部狀態是相同的。

Class Diagram

• Flyweight：享元物件
• IntrinsicState：內部狀態，享元物件共享內部狀態
• ExtrinsicState：外部狀態，每個享元物件的外部狀態不同

 

 

Implementation

public interface Flyweight {
    void doOperation(String extrinsicState);
}

public class ConcreteFlyweight implements Flyweight {

    private String intrinsicState;

    public ConcreteFlyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    @Override
    public void doOperation(String extrinsicState) {
        System.out.println("Object address: " + System.identityHashCode(this));
        System.out.println("IntrinsicState: " + intrinsicState);
        System.out.println("ExtrinsicState: " + extrinsicState);
    }
}

public class FlyweightFactory {

    private HashMap<String, Flyweight> flyweights = new HashMap<>();

    Flyweight getFlyweight(String intrinsicState) {
        if (!flyweights.containsKey(intrinsicState)) {
            Flyweight flyweight = new ConcreteFlyweight(intrinsicState);
            flyweights.put(intrinsicState, flyweight);
        }
        return flyweights.get(intrinsicState);
    }
}

public class Client {

    public static void main(String[] args) {
        FlyweightFactory factory = new FlyweightFactory();
        Flyweight flyweight1 = factory.getFlyweight("aa");
        Flyweight flyweight2 = factory.getFlyweight("aa");
        flyweight1.doOperation("x");
        flyweight2.doOperation("y");
    }
}

輸出：
Object address: 1163157884
IntrinsicState: aa
ExtrinsicState: x
Object address: 1163157884
IntrinsicState: aa
ExtrinsicState: y

JDK

Java 利用快取來加速大量小物件的訪問時間。

• java.lang.Integer#valueOf(int)
• java.lang.Boolean#valueOf(boolean)
• java.lang.Byte#valueOf(byte)
• java.lang.Character#valueOf(char)

7. 代理（Proxy）

Intent

控制對其它物件的訪問。

Class Diagram

代理有以下四類：

• 遠端代理（Remote Proxy）：控制對遠端物件（不同地址空間）的訪問，它負責將請求及其引數進行編碼，並向不同地址空間中的物件傳送已經編碼的請求。
• 虛擬代理（Virtual Proxy）：根據需要建立開銷很大的物件，它可以快取實體的附加資訊，以便延遲對它的訪問，例如在網站載入一個很大圖片時，不能馬上完成，可以用虛擬代理快取圖片的大小資訊，然後生成一張臨時圖片代替原始圖片。
• 保護代理（Protection Proxy）：按許可權控制物件的訪問，它負責檢查呼叫者是否具有實現一個請求所必須的訪問許可權。
• 智慧代理（Smart Reference）：取代了簡單的指標，它在訪問物件時執行一些附加操作：記錄物件的引用次數；當第一次引用一個物件時，將它裝入記憶體；在訪問一個實際物件前，檢查是否已經鎖定了它，以確保其它物件不能改變它。

Implementation

以下是一個虛擬代理的實現，模擬了圖片延遲載入的情況下使用與圖片大小相等的臨時內容去替換原始圖片，直到圖片載入完成才將圖片顯示出來。

public interface Image {
    void showImage();
}

public class HighResolutionImage implements Image {

    private URL imageURL;
    private long startTime;
    private int height;
    private int width;

    public int getHeight() {
        return height;
    }

    public int getWidth() {
        return width;
    }

    public HighResolutionImage(URL imageURL) {
        this.imageURL = imageURL;
        this.startTime = System.currentTimeMillis();
        this.width = 600;
        this.height = 600;
    }

    public boolean isLoad() {
        // 模擬圖片載入，延遲 3s 載入完成
        long endTime = System.currentTimeMillis();
        return endTime - startTime > 3000;
    }

    @Override
    public void showImage() {
        System.out.println("Real Image: " + imageURL);
    }
}

public class ImageProxy implements Image {

    private HighResolutionImage highResolutionImage;

    public ImageProxy(HighResolutionImage highResolutionImage) {
        this.highResolutionImage = highResolutionImage;
    }

    @Override
    public void showImage() {
        while (!highResolutionImage.isLoad()) {
            try {
                System.out.println("Temp Image: " + highResolutionImage.getWidth() + " " + highResolutionImage.getHeight());
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        highResolutionImage.showImage();
    }
}

public class ImageViewer {

    public static void main(String[] args) throws Exception {
        String image = "http://www.ttt.com/image.jpg";
        URL url = new URL(image);
        HighResolutionImage highResolutionImage = new HighResolutionImage(url);
        ImageProxy imageProxy = new ImageProxy(highResolutionImage);
        imageProxy.showImage();
    }
}

JDK

• java.lang.reflect.Proxy
• RMI（Remote Method Invocation 遠端方法呼叫）

 

 

 

 

 

一年好景君須記

最是橙黃橘綠時