裝飾模式(Decorator pattern)

裝飾模式（Decorator pattern）: 又名包裝模式（Wrapper pattern）, 它以對客戶端透明的方式擴展對象的功能，是繼承關係的一個替代方案。

裝飾模式以對客戶透明的方式動態的給一個對象附加上更多的責任。換言之，客戶端並不會以爲對象在裝飾前和裝飾後有什麼不一樣。

裝飾模式能夠在不創造更多子類的狀況下，將對象的功能加以擴展。

裝飾模式 把客戶端的調用委派到被裝飾類。裝飾模式的關鍵在於這種擴展徹底是透明的。

 

組成：

　　1.抽象構件角色（Component）：給出一個抽象類或接口，以規範準備接收附加責任的對象。

　　2.具體構件角色（Concrete Component）：定義一個將要接收附加責任的類。

　　3.裝飾角色（Decorator）：持有一個構件（Component）對象的引用，並定義一個與抽象構件接口一致的接口

　　4.具體裝飾角色（Concrete Decorator）：負責給構件對象「貼上」附加的責任。

 

特色：

1. 裝飾對象和真實對象有相同的接口。這樣客戶端對象就能夠以和真實對象相同的方式和裝飾對象交互。
2. 裝飾對象包含一個真實對象的引用（reference）。
3. 裝飾對象能夠在轉發這些請求之前或之後增長一些附加功能。這樣就確保了在運行時，不用修改給定對象的結構就能夠在外部增長附加的功能。在面向對象的設計中，一般是經過繼承來實現對給定類的功能擴展（感受跟代理模式有點像，都是持有真實對象的引用，轉發請求先後增長附加功能）。

 代碼實例：

抽象的構建角色：

1 public interface Componment  //抽象的構件角色，給出一個抽象接口，規範準備接收附加責任的對象
2 {
3     public void doSomething();
4 }

View Code

具體的構建角色：

1 public class ConcreteComponment implements Componment//具體構建角色，定義一個要接收附加責任的類
2 {
3     public void doSomething()
4     {
5         System.out.println("功能A");
6         
7     }
8 }

View Code

裝飾角色：

 1 public class Decorator implements Componment //裝飾角色，
 2 {
 3     private Componment componment; //持有一個構件（Componment）對象的引用
 4     
 5     public Decorator(Componment componment)
 6     {
 7         this.componment = componment;
 8     }
 9     public void doSomething()
10     {
11         componment.doSomething();    
12     }
13 }

View Code

具體裝飾角色1：

 1 public class ConcreteDecorator1 extends Decorator //具體裝飾角色1
 2 {
 3     
 4     public ConcreteDecorator1(Componment componment)
 5     {
 6         super(componment);
 7     }
 8 
 9     public void doSomething()
10     {
11         super.doSomething();
12         this.doAnotherthing();
13     }
14     
15     private void doAnotherthing()
16     {
17         System.out.println("功能B");
18     }
19 
20 }

View Code

具體裝飾角色2：

 1 public class ConcreteDecorator2 extends Decorator
 2 {
 3     public ConcreteDecorator2(Componment componment)
 4     {
 5         super(componment);
 6     }
 7     
 8     @Override
 9     public void doSomething()
10     {
11         super.doSomething();
12         this.doAnotherthing();
13     }
14     
15     private void doAnotherthing()
16     {
17         System.out.println("功能C");
18     }
19 
20 }

View Code

測試：

 1 public class Test
 2 {
 3     public static void main(String[] args)
 4     {
 5         Componment componment = new ConcreteComponment();
 6 
 7         Componment componment2 = new ConcreteDecorator1(componment);
 8         
 9         Componment componment3 = new ConcreteDecorator2(componment2);
10         
11         componment3.doSomething(); //功能A
12                                     
13     
14     }
15 }

View Code

輸出結果：

功能A
功能B
功能C

對具體的構建角色進行了「包裝」,就實現了更多的功能。到底須要多少包裝，咱們能夠本身決定，體現了動態性和靈活性。

java I/O採用裝飾模式實現。

裝飾模式用來擴展特定對象的功能，即動態的給對象添加特定的責任（功能），而繼承是靜態的分配職責，會致使不少子類的產生，缺少靈活性。