JAVA设计模式--结构型模式
2019獨角獸企業重金招聘Python工程師標準>>>
我們接著討論設計模式，上篇文章我講完了5種創建型模式，這章開始，我將講下7種結構型模式：適配器模式、裝飾模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。其中對象的適配器模式是各種模式的起源，我們看下面的圖：
6、適配器模式（Adapter）
?適配器模式將某個類的接口轉換成客戶端期望的另一個接口表示，目的是消除由于接口不匹配所造成的類的兼容性問題。主要分為三類：類的適配器模式、對象的適配器模式、接口的適配器模式。首先，我們來看看類的適配器模式，先看類圖：
核心思想就是：有一個Source類，擁有一個方法，待適配，目標接口時Targetable，通過Adapter類，將Source的功能擴展到Targetable里，看代碼：
public class Source { public void method1() { System.out.println("this is original method!"); } } public interface Targetable { /* 與原類中的方法相同 */ public void method1(); /* 新類的方法 */ public void method2(); } public class Adapter extends Source implements Targetable { @Override public void method2() { System.out.println("this is the targetable method!"); } }Adapter類繼承Source類，實現Targetable接口，下面是測試類：
public class AdapterTest { public static void main(String[] args) { Targetable target = new Adapter(); target.method1(); target.method2(); } }輸出：
this is original method!
this is the targetable method!
這樣Targetable接口的實現類就具有了Source類的功能。
對象的適配器模式
基本思路和類的適配器模式相同，只是將Adapter類作修改，這次不繼承Source類，而是持有Source類的實例，以達到解決兼容性的問題。看圖：
只需要修改Adapter類的源碼即可：
public class Wrapper implements Targetable { private Source source; public Wrapper(Source source){ super(); this.source = source; } @Override public void method2() { System.out.println("this is the targetable method!"); } @Override public void method1() { source.method1(); } }測試類：
public class AdapterTest { public static void main(String[] args) { Source source = new Source(); Targetable target = new Wrapper(source); target.method1(); target.method2(); } }輸出與第一種一樣，只是適配的方法不同而已。
第三種適配器模式是接口的適配器模式，接口的適配器是這樣的：有時我們寫的一個接口中有多個抽象方法，當我們寫該接口的實現類時，必須實現該接口的所有方法，這明顯有時比較浪費，因為并不是所有的方法都是我們需要的，有時只需要某一些，此處為了解決這個問題，我們引入了接口的適配器模式，借助于一個抽象類，該抽象類實現了該接口，實現了所有的方法，而我們不和原始的接口打交道，只和該抽象類取得聯系，所以我們寫一個類，繼承該抽象類，重寫我們需要的方法就行。看一下類圖：
這個很好理解，在實際開發中，我們也常會遇到這種接口中定義了太多的方法，以致于有時我們在一些實現類中并不是都需要。看代碼：
public interface Sourceable { public void method1(); public void method2(); }抽象類Wrapper2：
public abstract class Wrapper2 implements Sourceable{ public void method1(){} public void method2(){} } public class SourceSub1 extends Wrapper2 { public void method1(){ System.out.println("the sourceable interface's first Sub1!"); } } public class SourceSub2 extends Wrapper2 { public void method2(){ System.out.println("the sourceable interface's second Sub2!"); } } public class WrapperTest { public static void main(String[] args) { Sourceable source1 = new SourceSub1(); Sourceable source2 = new SourceSub2(); source1.method1(); source1.method2(); source2.method1(); source2.method2(); } }測試輸出：
the sourceable interface's first Sub1!
the sourceable interface's second Sub2!
達到了我們的效果！
?講了這么多，總結一下三種適配器模式的應用場景：
類的適配器模式：當希望將一個類轉換成滿足另一個新接口的類時，可以使用類的適配器模式，創建一個新類，繼承原有的類，實現新的接口即可。
對象的適配器模式：當希望將一個對象轉換成滿足另一個新接口的對象時，可以創建一個Wrapper類，持有原類的一個實例，在Wrapper類的方法中，調用實例的方法就行。
接口的適配器模式：當不希望實現一個接口中所有的方法時，可以創建一個抽象類Wrapper，實現所有方法，我們寫別的類的時候，繼承抽象類即可。
7、裝飾模式（Decorator）
顧名思義，裝飾模式就是給一個對象增加一些新的功能，而且是動態的，要求裝飾對象和被裝飾對象實現同一個接口，裝飾對象持有被裝飾對象的實例，關系圖如下：
Source類是被裝飾類，Decorator類是一個裝飾類，可以為Source類動態的添加一些功能，代碼如下：
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(); } }輸出：
before decorator!
the original method!
after decorator!
裝飾器模式的應用場景：
1、需要擴展一個類的功能。
2、動態的為一個對象增加功能，而且還能動態撤銷。（繼承不能做到這一點，繼承的功能是靜態的，不能動態增刪。）
缺點：產生過多相似的對象，不易排錯！
8、代理模式（Proxy）
其實每個模式名稱就表明了該模式的作用，代理模式就是多一個代理類出來，替原對象進行一些操作，比如我們在租房子的時候回去找中介，為什么呢？因為你對該地區房屋的信息掌握的不夠全面，希望找一個更熟悉的人去幫你做，此處的代理就是這個意思。再如我們有的時候打官司，我們需要請律師，因為律師在法律方面有專長，可以替我們進行操作，表達我們的想法。先來看看關系圖：
根據上文的闡述，代理模式就比較容易的理解了，我們看下代碼：
public interface Sourceable { public void method(); } public class Source implements Sourceable { @Override public void method() { System.out.println("the original method!"); } } public class Proxy implements Sourceable { private Source source; public Proxy(){ super(); this.source = new Source(); } @Override public void method() { before(); source.method(); atfer(); } private void atfer() { System.out.println("after proxy!"); } private void before() { System.out.println("before proxy!"); } }測試類：
public class ProxyTest { public static void main(String[] args) { Sourceable source = new Proxy(); source.method(); } }輸出：
before proxy!
the original method!
after proxy!
代理模式的應用場景：
如果已有的方法在使用的時候需要對原有的方法進行改進，此時有兩種辦法：
1、修改原有的方法來適應。這樣違反了“對擴展開放，對修改關閉”的原則。
2、就是采用一個代理類調用原有的方法，且對產生的結果進行控制。這種方法就是代理模式。
使用代理模式，可以將功能劃分的更加清晰，有助于后期維護！
9、外觀模式（Facade）
外觀模式是為了解決類與類之家的依賴關系的，像spring一樣，可以將類和類之間的關系配置到配置文件中，而外觀模式就是將他們的關系放在一個Facade類中，降低了類類之間的耦合度，該模式中沒有涉及到接口，看下類圖：（我們以一個計算機的啟動過程為例）
我們先看下實現類：
public class CPU { public void startup(){ System.out.println("cpu startup!"); } public void shutdown(){ System.out.println("cpu shutdown!"); } } public class Memory { public void startup(){ System.out.println("memory startup!"); } public void shutdown(){ System.out.println("memory shutdown!"); } } public class Disk { public void startup(){ System.out.println("disk startup!"); } public void shutdown(){ System.out.println("disk shutdown!"); } } public class 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!"); } }User類如下：
public class User { public static void main(String[] args) { Computer computer = new Computer(); computer.startup(); computer.shutdown(); } }輸出：
start the computer!
cpu startup!
memory startup!
disk startup!
start computer finished!
begin to close the computer!
cpu shutdown!
memory shutdown!
disk shutdown!
computer closed!
如果我們沒有Computer類，那么，CPU、Memory、Disk他們之間將會相互持有實例，產生關系，這樣會造成嚴重的依賴，修改一個類，可能會帶來其他類的修改，這不是我們想要看到的，有了Computer類，他們之間的關系被放在了Computer類里，這樣就起到了解耦的作用，這，就是外觀模式！
10、橋接模式（Bridge）
橋接模式就是把事物和其具體實現分開，使他們可以各自獨立的變化。橋接的用意是：將抽象化與實現化解耦，使得二者可以獨立變化，像我們常用的JDBC橋DriverManager一樣，JDBC進行連接數據庫的時候，在各個數據庫之間進行切換，基本不需要動太多的代碼，甚至絲毫不用動，原因就是JDBC提供統一接口，每個數據庫提供各自的實現，用一個叫做數據庫驅動的程序來橋接就行了。我們來看看關系圖：
實現代碼：先定義接口：
public interface Sourceable { public void method(); }分別定義兩個實現類：
public class SourceSub1 implements Sourceable { @Override public void method() { System.out.println("this is the first sub!"); } } public class SourceSub2 implements Sourceable { @Override public void method() { System.out.println("this is the second sub!"); } }定義一個橋，持有Sourceable的一個實例：
public abstract class Bridge { private Sourceable source; public void method(){ source.method(); } public Sourceable getSource() { return source; } public void setSource(Sourceable source) { this.source = source; } } public class MyBridge extends Bridge { public void method(){ getSource().method(); } }測試類：
public class BridgeTest { public static void main(String[] args) { Bridge bridge = new MyBridge(); /*調用第一個對象*/ Sourceable source1 = new SourceSub1(); bridge.setSource(source1); bridge.method(); /*調用第二個對象*/ Sourceable source2 = new SourceSub2(); bridge.setSource(source2); bridge.method(); } }output：
this is the first sub!
this is the second sub!
這樣，就通過對Bridge類的調用，實現了對接口Sourceable的實現類SourceSub1和SourceSub2的調用。接下來我再畫個圖，大家就應該明白了，因為這個圖是我們JDBC連接的原理，有數據庫學習基礎的，一結合就都懂了。
11、組合模式（Composite）
組合模式有時又叫部分-整體模式在處理類似樹形結構的問題時比較方便，看看關系圖：
直接來看代碼：
public class TreeNode { private String name; private TreeNode parent; private Vector<TreeNode> children = new Vector<TreeNode>(); public TreeNode(String name){ this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public TreeNode getParent() { return parent; } public void setParent(TreeNode parent) { this.parent = parent; } //添加孩子節點 public void add(TreeNode node){ children.add(node); } //刪除孩子節點 public void remove(TreeNode node){ children.remove(node); } //取得孩子節點 public Enumeration<TreeNode> getChildren(){ return children.elements(); } } public class Tree { TreeNode root = null; public Tree(String name) { root = new TreeNode(name); } public static void main(String[] args) { Tree tree = new Tree("A"); TreeNode nodeB = new TreeNode("B"); TreeNode nodeC = new TreeNode("C"); nodeB.add(nodeC); tree.root.add(nodeB); System.out.println("build the tree finished!"); } }使用場景：將多個對象組合在一起進行操作，常用于表示樹形結構中，例如二叉樹，數等。
12、享元模式（Flyweight）
享元模式的主要目的是實現對象的共享，即共享池，當系統中對象多的時候可以減少內存的開銷，通常與工廠模式一起使用。
FlyWeightFactory負責創建和管理享元單元，當一個客戶端請求時，工廠需要檢查當前對象池中是否有符合條件的對象，如果有，就返回已經存在的對象，如果沒有，則創建一個新對象，FlyWeight是超類。一提到共享池，我們很容易聯想到Java里面的JDBC連接池，想想每個連接的特點，我們不難總結出：適用于作共享的一些個對象，他們有一些共有的屬性，就拿數據庫連接池來說，url、driverClassName、username、password及dbname，這些屬性對于每個連接來說都是一樣的，所以就適合用享元模式來處理，建一個工廠類，將上述類似屬性作為內部數據，其它的作為外部數據，在方法調用時，當做參數傳進來，這樣就節省了空間，減少了實例的數量。
看個例子：
看下數據庫連接池的代碼：
public class ConnectionPool { private Vector<Connection> pool; /*公有屬性*/ private String url = "jdbc:mysql://localhost:3306/test"; private String username = "root"; private String password = "root"; private String driverClassName = "com.mysql.jdbc.Driver"; private int poolSize = 100; private static ConnectionPool instance = null; Connection conn = null; /*構造方法，做一些初始化工作*/ private ConnectionPool() { pool = new Vector<Connection>(poolSize); for (int i = 0; i < poolSize; i++) { try { Class.forName(driverClassName); conn = DriverManager.getConnection(url, username, password); pool.add(conn); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException e) { e.printStackTrace(); } } } /* 返回連接到連接池 */ public synchronized void release() { pool.add(conn); } /* 返回連接池中的一個數據庫連接 */ public synchronized Connection getConnection() { if (pool.size() > 0) { Connection conn = pool.get(0); pool.remove(conn); return conn; } else { return null; } } }通過連接池的管理，實現了數據庫連接的共享，不需要每一次都重新創建連接，節省了數據庫重新創建的開銷，提升了系統的性能！
本章講解了7種結構型模式，因為篇幅的問題，剩下的11種行為型模式，我們將另起篇章
?
?
轉載于:https://my.oschina.net/u/1024107/blog/752059
總結
以上是生活随笔為你收集整理的JAVA设计模式--结构型模式的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 麻省：第9讲
- 下一篇： spring AOP编程