2. 程式人生 > >Java設計模式之結構型模式（一）

Java設計模式之結構型模式（一）

阿新 • • 發佈：2019-02-02

在解決了物件的建立問題之後，物件的組成以及物件之間的依賴關係就成了開發人員關注的焦點，因為如何設計物件的結構、繼承和依賴關係會影響到後續程式的維護性、程式碼的健壯性、耦合性等。

一、介面卡模式（Adapter）

介面卡模式是指“將一個類的介面轉換成客戶希望的另一個介面。Adapter模式使得原本介面不相容而不能一起工作的那些類可以一起工作，其別名是包裝器（Wrapper）”。介面卡可以分為類的介面卡模式、物件的介面卡模式、介面的介面卡模式。

1.1 類的介面卡模式

類介面卡使用多重繼承對一個介面與另一個介面進行匹配。
這裡寫圖片描述
有一個Adaptee類，擁有一個方法，待適配，目標介面是Target，通過Adapter類，將Adaptee的功能擴充套件到Target裡，看程式碼：

public class Adaptee {  

    public void request() {  
        System.out.println("this is original method!");  
    }  
} 
public interface Target {  

    /* 與原類中的方法相同 */  
    public void request();  

    /* 新類的方法 */  
    public void specificRequest();  
}  
public class Adapter extends Adaptee
 
 implements Target {  

    @Override  
    public void specificRequest() {  
        System.out.println("this is the Adaptee method!");  
    }  
}

Adapter類繼承Adaptee類，實現Target介面，下面是測試類：

public class AdapterTest {  

    public static void main(String[] args) {  
        Target target = new Adapter();  
        target.request();  
        target.specificRequest();  
    }  
}

1.2 物件的介面卡模式

物件匹配依賴於物件組合。
這裡寫圖片描述
例子只需要修改Adapter類的原始碼即可

public class Adapter implements Target {  

    private Adaptee adaptee;  

    public Wrapper(Adaptee adaptee){  
        super();  
        this.adaptee = adaptee;  
    }  
    @Override  
    public void specificRequest() {  
        System.out.println("this is the Adaptee method!");  
    }  

    @Override  
    public void request() {  
        adaptee.request();  
    }  
}

1.3 介面的介面卡模式

有時我們寫的一個介面中有多個抽象方法，當我們寫該介面的實現類時，必須實現該介面的所有方法，這明顯有時比較浪費，因為並不是所有的方法都是我們需要的，有時只需要某一些，此處為了解決這個問題，我們引入了介面的介面卡模式，藉助於一個抽象類，該抽象類實現了該介面，實現了所有的方法，而我們不和原始的介面打交道，只和該抽象類取得聯絡，所以我們寫一個類，繼承該抽象類，重寫我們需要的方法就行。看一下類圖：
這裡寫圖片描述

public interface Target {  

    public void method1();  
    public void method2();  
}  
public abstract class Adapter implements Target {  

    public void method1(){}  
    public void method2(){}  
}  
public class Adaptee1 extends Adapter {  
    public void method1(){  
        System.out.println("the Target interface's first Sub1!");  
    }  
}  
public class Adaptee1 extends Adapter {  
    public void method2(){  
        System.out.println("the Target interface's second Sub2!");  
    }  
}

三種介面卡模式的應用場景：

  • 類的介面卡模式：當希望將一個類轉換成滿足另一個新介面的類時，可以使用類的介面卡模式，建立一個新類，繼承原有的類，實現新的介面即可。
  • 物件的介面卡模式：當希望將一個物件轉換成滿足另一個新介面的物件時，可以建立一個Wrapper類，持有原類的一個例項，在Wrapper類的方法中，呼叫例項的方法就行。
  • 介面的介面卡模式：當不希望實現一個介面中所有的方法時，可以建立一個抽象類Wrapper，實現所有方法，我們寫別的類的時候，繼承抽象類即可。

二、裝飾模式（Decorator）

裝飾模式別名也叫包裝器，GOF中定義為“動態的給物件新增一些額外的職責”。要求裝飾物件和被裝飾物件實現同一個介面，裝飾物件持有被裝飾物件的例項，關係圖如下：
這裡寫圖片描述

public interface Sourceable {  
    public void method();  
}  
public class Source implements Sourceable {  

    @Override  
    public void method() {  
        System.out.println("the original method!");  
    }  
}  
public class Decorator implements Sourceable {  

    private Sourceable source;  

    public Decorator(Sourceable source){  
        super();  
        this.source = source;  
    }  
    @Override  
    public void method() {  
        System.out.println("before decorator!");  
        source.method();  
        System.out.println("after decorator!");  
    }  
}

測試類：

public class DecoratorTest {  

    public static void main(String[] args) {  
        Sourceable source = new Source();  
        Sourceable obj = new Decorator(source);  
        obj.method();  
    }  
}

裝飾器模式的應用場景：

  1. 需要擴充套件一個類的功能。
  2. 動態的為一個物件增加功能，而且還能動態撤銷。（繼承不能做到這一點，繼承的功能是靜態的，不能動態增刪。）

三、門面模式（Facade）

門面模式又稱外觀模式，是指“外部與一個子系統的通訊必須通過一個統一的門面物件進行”。簡單來說，該模式就是把一些複雜的流程封裝成一個介面供給外部使用者更簡單的使用。
這裡寫圖片描述
門面角色：外觀模式的核心。它被客戶角色呼叫，它熟悉子系統的功能。內部根據客戶角色的需求預定了幾種功能的組合。
子系統角色：可以同時又一個。它對客戶角色和Facade時未知的。它內部可以有系統內的相互互動，也可以由供外界呼叫的介面。

下面，我們就通過一個簡單的例子來實現該模式。
每個Computer都有CPU、Memory、Disk。在Computer開啟和關閉的時候，相應的部件也會開啟和關閉，所以，使用了該外觀模式後，會使使用者和部件之間解耦。如：
這裡寫圖片描述

//cpu子系統類
public class CPU {

    public void start() {
        System.out.println("cpu is start...");
    }

    public void shutDown() {
        System.out.println("CPU is shutDown...");
    }
}
public class Memory {  //Memory子系統類

    public void startup(){  
        System.out.println("memory startup!");  
    }  

    public void shutdown(){  
        System.out.println("memory shutdown!");  
    }  
}  
public class Disk {  //Disk子系統

    public void startup(){  
        System.out.println("disk startup!");  
    }  

    public void shutdown(){  
        System.out.println("disk shutdown!");  
    }  
}  
public class Computer { //門面類Computer 
    private CPU cpu;  
    private Memory memory;  
    private Disk disk;  

    public Computer(){  
        cpu = new CPU();  
        memory = new Memory();  
        disk = new Disk();  
    }  

    public void startup(){  
        System.out.println("start the computer!");  
        cpu.startup();  
        memory.startup();  
        disk.startup();  
        System.out.println("start computer finished!");  
    }  

    public void shutdown(){  
        System.out.println("begin to close the computer!");  
        cpu.shutdown();  
        memory.shutdown();  
        disk.shutdown();  
        System.out.println("computer closed!");  
    }  
}  
public class User {  

    public static void main(String[] args) {  
        Computer computer = new Computer();  
        computer.startup();  
        computer.shutdown();  
    }  
}

如果我們沒有Computer類，那麼，CPU、Memory、Disk他們之間將會相互持有例項，產生關係，這樣會造成嚴重的依賴，修改一個類，可能會帶來其他類的修改，這不是我們想要看到的，有了Computer類，他們之間的關係被放在了Computer類裡，這樣就起到了解耦的作用。

使用場景：

  1. 為複雜的模組或子系統提供外界訪問的模組；
  2. 子系統相互獨立；
  3. 在層析結構中，可以使用外觀模式定義系統的每一層的入口。

四、橋接模式（Bridge）

橋接模式是指“將抽象部分與它的實現部分分離，是它們都可以獨立的變化。”
這裡寫圖片描述
Abstraction：定義抽象類的介面，維護一個指向Implementor介面的指標，將使用者的請求轉發給它的Implementor。RefinedAbstraction寇衝由Abstraction定義的介面。
Implementor：定義實現類的介面，該介面不一定要和Abstraction的介面定義的一樣，事實上兩個介面可以完全不同。
ConcretelImplementor：實現Implementor介面並定義其具體實現。

我們這裡使用電視機遙控器做示例，多個電視機廠家想要遙控器廠家生產遙控器，並且遙控器的樣式可能會變化。
這裡寫圖片描述
電視機廠家遙控介面

public interface Control {

    public void On();
    public void Off();
    public void setChannel(int ch);
    public void setVolume(int vol);
}

電視機廠家遙控介面實現

public class SharpControl implements Control {

    @Override
    public void On() {
        System.out.println("***Open Sharp TV***");
    }

    @Override
    public void Off() {
        System.out.println("***Off Sharp TV***");
    }

    @Override
    public void setChannel(int ch) {
        System.out.println("***The Sharp TV Channel is setted "+ch+"***");
    }

    @Override
    public void setVolume(int vol) {
        System.out.println("***The Sharp TV Volume is setted "+vol+"***");
    }
}
public class SonyControl implements Control {

    @Override
    public void On() {
        System.out.println("*Open Sony TV*");
    }

    @Override
    public void Off() {
        System.out.println("*Off Sony TV*");
    }

    @Override
    public void setChannel(int ch) {
        System.out.println("*The Sony TV Channel is setted "+ch+"*");
    }

    @Override
    public void setVolume(int vol) {
        System.out.println("*The Sony TV Volume is setted "+vol+"*");
    }
}

遙控器廠家抽象類介面

public abstract class TvControlabs {

    Control mControl=null;

    public TvControlabs(Control mControl) {
        this.mControl=mControl;
    }

    public abstract void Onoff();
    public abstract void nextChannel();
    public abstract void preChannel();
}

遙控器為廠家生產各種型別的遙控器

public class TvControl extends TvControlabs {
    private  int ch = 0;
    private  boolean ison = false;

    public TvControl(Control mControl) {
        super(mControl);
    }

    @Override
    public void Onoff() {
        if(ison) {
            ison=false;
            mControl.Off();
        } else {
            ison=true;
            mControl.On();
        }
    }

    @Override
    public void nextChannel() {
        ch++;
        mControl.setChannel(ch);
    }

    @Override
    public void preChannel() {
        ch--;
        if(ch<0) {
            ch=200;
        }
        mControl.setChannel(ch);
    }
}
public class newTvControl extends TvControlabs {
    private  int ch=0;
    private  boolean ison=false;
    private int prech=0;

    public newTvControl(Control mControl) {
        super(mControl);
    }

    @Override
    public void Onoff() { 
        if(ison) {
            ison=false;
            mControl.Off();
        } else {
            ison=true;
            mControl.On();
        }
    }

    @Override
    public void nextChannel() {
        prech=ch;
        ch++;
        mControl.setChannel(ch);
    }

    @Override
    public void preChannel() {
        prech=ch;
        ch--;
        if(ch<0) {
            ch=200;
        }
        mControl.setChannel(ch);
    }

    public void  setChannel(int nch) {
        prech=ch;
        ch=nch;
        mControl.setChannel(ch);    
    }

    public void   Back() {
        mControl.setChannel(prech);
    }
}

這裡各個電視機廠家的電視機都實現了Control介面，而遙控器廠家只需要設計出遙控器型別並呼叫各個電視機廠家的具體實現就可以了。
使用場景：

  1. 如果一個系統需要在構件的抽象化角色和具體化角色之間增加更多的靈活性，避免在兩個層次之間建立靜態的繼承聯絡，通過橋接模式可以使它們在抽象層建立一個關聯關係。
  2. 對於那些不希望使用繼承或因為多層次繼承導致系統類的個數急劇增加的系統，橋接模式尤為適用。
  3. 一個類存在兩個獨立變化的維度，且這兩個維度都需要進行擴充套件。

注意事項：對於兩個獨立變化的維度，使用橋接模式再適合不過了。

五、組合模式（Composite）

組合模式又稱合成模式，是用於把一組相似的物件當作一個單一的物件。將物件組合成樹形結構以表示“部分-整體”的層次機構。
這裡寫圖片描述
Component 是組合中的物件宣告介面，在適當的情況下，實現所有類共有介面的預設行為。宣告一個介面用於訪問和管理Component
子部件。
Leaf 在組合中表示葉子結點物件，葉子結點沒有子結點。
Composite 定義有枝節點行為，用來儲存子部件，在Component介面中實現與子部件有關操作，如增加(add)和刪除。

public abstract class Component {       
     String name;

     public Component(String s){
         this.name=s;
     }
     public abstract void add(Component c);
     public abstract void remove(Component c);
     public abstract void foreach();
 }

組合類

public class Composite extends Component {
    private List<Component>child=new ArrayList<Component>
();

    public Composite(String s) {
        super(s);
    }

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

    @Override
    public void foreach() {
        System.out.println("節點名:\t"+name);
        for (Component c : child) {
            c.foreach();
        }
    }

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

葉子節點

public class Leaf extends Component {

    public Leaf(String s) {
        super(s);
    }

    @Override
    public void add(Component c) {
    }

    @Override
    public void foreach() {
        System.out.println("tself name-->"+this.name);
    }

    @Override
    public void remove(Component c) {
    } 
 }

測試類

public class TestComponent {
    public static void main(String[] args) {     
        Component component = new Composite("根節點");
        Component child = new Composite("一級子節點child");
        Component child_1 = new Leaf("一級子節點child之子節點一");
        Component child_2 = new Leaf("一級子節點child之子節點二");
        child.add(child_1);
        child.add(child_2);
        Component child2=new Composite("一級子節點child2");
        component.add(child);
        component.add(child2);
        component.foreach();
    }
}

使用場景：部分、整體場景，如樹形選單，檔案、資料夾的管理。

六、享元模式（Flyweight）

享元模式是指“運用共享技術有效的支援大量細粒度的物件”。主要目的是實現物件的共享，即共享池，當系統中物件多的時候可以減少記憶體的開銷，通常與工廠模式一起使用。
這裡寫圖片描述
FlyWeight 享元介面或者（抽象享元類），定義共享介面
ConcreteFlyWeight 具體享元類，該類例項將實現共享
UnSharedConcreteFlyWeight 非共享享元實現類
FlyWeightFactory 享元工廠類，控制例項的建立和共享

內部狀態 vs. 外部狀態
內部狀態是儲存在享元物件內部，一般在構造時確定或通過setter設定，並且不會隨環境改變而改變的狀態，因此內部狀態可以共享。
外部狀態是隨環境改變而改變、不可以共享的狀態。外部狀態在需要使用時通過客戶端傳入享元物件。外部狀態必須由客戶端儲存。

public interface FlyWeight {
    void action(String externalState);
}
public class ConcreteFlyWeight implements FlyWeight {

    private String name;

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

    @Override
    public void action(String externalState) {
        System.out.pringln("name = {}, outerState = {}", this.name, externalState);
    }
}

享元模式中，最關鍵的享元工廠。它將維護已建立的享元例項，並通過例項標記（一般用內部狀態）去索引對應的例項。當目標物件未建立時，享元工廠負責建立例項並將其加入標記-物件對映。當目標物件已建立時，享元工廠直接返回已有例項，實現物件的複用。

public class FlyWeightFactory {

  private static ConcurrentHashMap<String, FlyWeight> allFlyWeight = new ConcurrentHashMap<String, FlyWeight>();

  public static FlyWeight getFlyWeight(String name) {
    if (allFlyWeight.get(name) == null) {
      synchronized (allFlyWeight) {
        if (allFlyWeight.get(name) == null) {
          System.out.println("Instance of name = {} does not exist, creating it");
          FlyWeight flyWeight = new ConcreteFlyWeight(name);
          System.out.println("Instance of name = {} created");
          allFlyWeight.put(name, flyWeight);
        }
      }
    }
    return allFlyWeight.get(name);
  }
}

使用場景： 1、系統有大量相似物件。 2、需要緩衝池的場景。

相關推薦

Java學習--設計模式之結構型模式（二）

and 它的 null spa bubuko imp AD mco flyweight 一、裝飾器模式（Decorator Pattern） 　　1、概念 　　　裝飾器模式（Decorator Pattern）允許向一個現有的對象添加新的功能，同時又不改變其結構。這種類

Java設計模式之結構型模式（一）

在解決了物件的建立問題之後，物件的組成以及物件之間的依賴關係就成了開發人員關注的焦點，因為如何設計物件的結構、繼承和依賴關係會影響到後續程式的維護性、程式碼的健壯性、耦合性等。 一、介面卡模式（Adapter） 介面卡模式是指“將一個類的介面轉換成客戶希

設計模式之結構型模式

cor 字節 任務 bst move 方便 內容 入口 相同 一、結構型模式概述 二、結構型模式內容 1、適配器模式 （1）功能： 將一個類的接口轉換成客戶希望的另外一個接口，使得原本接口不兼容而不能一起工作的那些類可以一起工作。

Java新手專案之第一個專案（一）2016.5.16-5.22

Java學生選課教務系統 作為學習Java的新手，之前學過點Java的基礎，後來又看了看網易雲課堂的java，總共差不多兩個月的時間吧，陸陸續續跟著書和視訊編了一些程式。馬上也要畢業，現在開始，希望能夠寫一些新手，進階，高階專案經歷。一方面，是對自己實踐的一個

Java工具類之Pattern和Matcher（一）

我們在web開發時，肯定會涉及到資料校驗，這時正則表示式就必須用到了。在Java中有個Pattern型別對某種正則表示式編譯， ，然後使用Matcher類進行判斷是否匹配等。其中String類中也有match();使用。這個對Pattern和Matcher的簡單使用。 pa

死磕 java同步系列之ReentrantLock原始碼解析（一）——公平鎖、非公平鎖

問題 （1）重入鎖是什麼？ （2）ReentrantLock如何實現重入鎖？ （3）ReentrantLock為什麼預設是非公平模式？ （4）ReentrantLock除了可重入還有哪些特性？ 簡介 Reentrant = Re + entrant，Re是重複、又、再的意思，entrant是enter的名詞或

Java應用伺服器之tomcat基礎配置（一）

　　前文我們聊到了java相關重要元件和它們之間的關係以及jdk、tomcat部署回顧請參考https://www.cnblogs.com/qiuhom-1874/p/13302938.html；今天我們來聊一聊tomcat的配置使用相關話題； 　　一、tomcat配置相關檔案簡介 　　1、server.xm

Java設計模式（九）之結構型模式：外觀模式

一、定義： 所謂外觀模式，就是提供一個統一的介面，用來訪問子系統中的一群介面。 外觀模式定義了一個高層介面，讓子系統更容易使用。如下圖，是使用外觀模式後將子系統的使用變得更加簡單。 在引入外觀模式後，客戶只需要與外觀角色打交道，客戶與子系統的複雜關係由外觀角色來實現

Java設計模式（十二）之結構型模式：享元模式

一、定義： 享元模式，也就是說在一個系統中如果有多個相同的物件，那麼只共享一份就可以了，不必每個都去例項化一個物件。比如說一個文本系統，每個字母定一個物件，那麼大小寫字母一共就是52個，那麼就要定義52個物件。如果有一個1M的文字，那麼字母是何其的多，如果每個字母都定義一個

設計模式之結構型-適配器模式(Adapter)

request 不同之處 設計模式 wid date 結構 lap target err （一）定義：將一個接口轉換成為客戶想要的另一個接口，適配器模式使接口不兼容的那些類可以一起工作。 1.1 UML類圖 1.2 類與對象之間關系 Target：目錄抽象類，定義客戶

設計模式之結構型--代理模式

類和對象 mic div att 機票 name void out pro 代理模式(Proxy pattern)核心作用： 通過代理，控制對對象的訪問 可以詳細控制訪問某個(某類)對象的方法，在調用這個方法前做前置處理，調用這個方法後 做後置處理(即：AOP的微觀實現)

設計模式之結構型--裝飾模式

ret his 組合 子類 產生 margin per 調用 輸出 裝飾模式： 職責： 動態得為一個對象增加新的功能 裝飾模式是一種用於代替繼承的技術，無須通過繼承增加子類就 能擴展對象的新功能。使用對象的關聯關系代替繼承關系，更加靈活。 同時避免類型體系的快速膨脹

設計模式（12）—— 結構型 ——代理（Proxy）

介紹 介紹：為其它物件提供一種代理，以控制對這個物件的訪問 說明：代理物件在客戶端和目標物件之間起到中介作用 適用場景： 保護目標物件 增強目標物件 優點： 將代理物件

設計模式（10）—— 結構型 ——組合（Composite ）

簡介 定義：將物件組合成樹形結構以表示“部分——整體”的層次結構。 說明：組合模式使客戶端對單個物件和組合物件保持一致的處理方式 型別：結構型 適用場景 希望客戶端可以忽略組合物件與單個物件的差異時 處理一

設計模式（8）—— 結構型 ——介面卡（Adapter）

定義：將一個類的介面轉換成客戶期望的另一個介面，使原本介面不相容的類可以一起工作 型別：結構型 適用場景： 已經存在的類，它的方法和需求不匹配時（方法結果系統或者相似） 不是軟體設計階段考慮的設計模式，是隨著軟體維護，

設計模式（6）—— 結構型 ——外觀（Facade）

簡介 定義：又叫門面模式，提供一個統一的介面，用來訪問子系統中的一群介面。 解釋：外觀模式定義了一個高層介面，讓子系統更容易被使用。 型別：結構型 適用場景： 子系統越來越複雜，外觀模式能夠提供簡單的呼叫介面。

設計模式分類之結構型模式

結構型模式包括介面卡模式、裝飾模式、橋接模式、組合模式、享元模式、代理模式、外觀模式。 介面卡模式 將一個類的介面轉換成客戶希望的另外一個介面。Adapter模式使得原本由於介面不相容而不能一起工作的那些類可以一起工作 裝飾模式 動態地給一個物件新增一些額外的職責，就增

Java經典23種設計模式之行為型模式(一)

行為型設計模式有11種，分別是Chain of Responsibility ( 責任鏈模式 )、Command ( 命令模式 )、Interpreter ( 直譯器模式 ) 、Iterator ( 迭代器模式 )、Mediator ( 中介者模式 ) 、Memento (

設計模式分類（建立型模式、結構型模式、行為模式）

1．建立型模式前面講過，社會化的分工越來越細，自然在軟體設計方面也是如此，因此物件的建立和物件的使用分開也就成為了必然趨勢。因為物件的建立會消耗掉系統的很多資源，所以單獨對物件的建立進行研究，從而能夠高效地建立物件就是建立型模式要探討的問題。這裡有6個具體的建立型模式可供研究

設計模式彙總：結構型模型（下）

總體來說設計模式分為三大類： 建立型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。 結構型模式，共七種：介面卡模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享