定義：裝飾模式是在不必改變原類檔案和使用繼承的情況下，動態的擴充套件一個物件的功能。它是通過建立一個包裝物件，也就是裝飾來包裹真實的物件。
這一個解釋，引自百度百科，我們注意其中的幾點。
1，不改變原類檔案。
2，不使用繼承。
3，動態擴充套件。
另外，這個類圖只是裝飾器模式的完整結構，但其實裡面有很多可以變化的地方
1，Component介面可以是介面也可以是抽象類，甚至是一個普通的父類（這個強烈不推薦，普通的類作為繼承體系的超級父類不易於維護）。
2，裝飾器的抽象父類Decorator並不是必須的。
那麼我們將上述標準的裝飾器模式，用我們熟悉的JAVA程式碼給詮釋一下。首先是待裝飾的介面Component。
package com.decorator;
public interface Component {
void method();
}
複製程式碼接下來便是我們的一個具體的介面實現類，也就是俗稱的原始物件，或者說待裝飾物件。
package com.decorator;
public class ConcreteComponent implements Component{
public void method() {
System.out.println("原來的方法");
}
}
複製程式碼下面便是我們的抽象裝飾器父類，它主要是為裝飾器定義了我們需要裝飾的目標是什麼，並對Component進行了基礎的裝飾。
package com.decorator;
public abstract class Decorator implements Component{
protected Component component;
public Decorator(Component component) {
super();
this.component = component;
}
public void method() {
component.method();
}
}
複製程式碼再來便是我們具體的裝飾器A和裝飾器B
package com.decorator;
public class ConcreteDecoratorA extends Decorator{
public ConcreteDecoratorA(Component component) {
super(component);
}
public void methodA(){
System.out.println("被裝飾器A擴充套件的功能");
}
public void method(){
System.out.println("針對該方法加一層A包裝");
super.method();
System.out.println("A包裝結束");
}
}
複製程式碼package com.decorator;
public class ConcreteDecoratorB extends Decorator{
public ConcreteDecoratorB(Component component) {
super(component);
}
public void methodB(){
System.out.println("被裝飾器B擴充套件的功能");
}
public void method(){
System.out.println("針對該方法加一層B包裝");
super.method();
System.out.println("B包裝結束");
}
}
複製程式碼下面給出我們的測試類。我們針對多種情況進行包裝。
package com.decorator;
public class Main {
public static void main(String[] args) {
Component component =new ConcreteComponent();//原來的物件
System.out.println("------------------------------");
component.method();//原來的方法
ConcreteDecoratorA concreteDecoratorA = new ConcreteDecoratorA(component);//裝飾成A
System.out.println("------------------------------");
concreteDecoratorA.method();//原來的方法
concreteDecoratorA.methodA();//裝飾成A以後新增的方法
ConcreteDecoratorB concreteDecoratorB = new ConcreteDecoratorB(component);//裝飾成B
System.out.println("------------------------------");
concreteDecoratorB.method();//原來的方法
concreteDecoratorB.methodB();//裝飾成B以後新增的方法
concreteDecoratorB = new ConcreteDecoratorB(concreteDecoratorA);//裝飾成A以後再裝飾成B
System.out.println("------------------------------");
concreteDecoratorB.method();//原來的方法
concreteDecoratorB.methodB();//裝飾成B以後新增的方法
}
}
複製程式碼下面看下我們執行的結果，到底是產生了什麼效果。
從此可以看到，我們首先是使用的原始的類的方法，然後分別讓A和B裝飾完以後再呼叫，最後我們將兩個裝飾器一起使用，再呼叫該介面定義的方法。
上述當中，我們分別對待裝飾類進行了原方法的裝飾和新功能的增加，methodA和methodB就是新增加的功能，這些都是裝飾器可以做的，當然兩者並不一定兼有，但一般至少會有一種，否則也就失去了裝飾的意義。
另外，相信各位就算不太清楚，也都大致聽說過JAVA的IO是裝飾器模式實現的，所以不再廢話，在給出一個標準的模板示例以後，直接拿出IO的示例，我們真槍實彈的來。
package com.decorator;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.PushbackInputStream;
import java.io.PushbackReader;
public class IOTest {
/* test.txt內容：
* hello world!
*/
public static void main(String[] args) throws IOException, ClassNotFoundException {
//檔案路徑可自行更換
final String filePath = "E:/myeclipse project/POITest/src/com/decorator/test.txt";
//InputStream相當於被裝飾的介面或者抽象類，FileInputStream相當於原始的待裝飾的物件，FileInputStream無法裝飾InputStream
//另外FileInputStream是以只讀方式開啟了一個檔案,並開啟了一個檔案的控制程式碼存放在FileDescriptor物件的handle屬性
//所以下面有關回退和重新標記等操作，都是在堆中建立緩衝區所造成的假象,並不是真正的檔案流在回退或者重新標記
InputStream inputStream = new FileInputStream(filePath);
final int len = inputStream.available();//記錄一下流的長度
System.out.println("FileInputStream不支援mark和reset：" + inputStream.markSupported());
System.out.println("---------------------------------------------------------------------------------");
/* 下面分別展示三種裝飾器的作用BufferedInputStream,DataInputStream,PushbackInputStream,下面做了三個裝飾器的功能演示 */
//首先裝飾成BufferedInputStream，它提供我們mark，reset的功能
BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);//裝飾成 BufferedInputStream
System.out.println("BufferedInputStream支援mark和reset：" + bufferedInputStream.markSupported());
bufferedInputStream.mark(0);//標記一下
char c = (char) bufferedInputStream.read();
System.out.println("LZ檔案的第一個字元：" + c);
bufferedInputStream.reset();//重置
c = (char) bufferedInputStream.read();//再讀
System.out.println("重置以後再讀一個字元，依然會是第一個字元:" + c);
bufferedInputStream.reset();
System.out.println("---------------------------------------------------------------------------------");
//裝飾成 DataInputStream,我們為了又使用DataInputStream,又使用BufferedInputStream的mark reset功能，所以我們再進行一層包裝
//注意，這裡如果不使用BufferedInputStream，而使用原始的InputStream，read方法返回的結果會是-1，即已經讀取結束
//因為BufferedInputStream已經將文字的內容讀取完畢，並緩衝到堆上，預設的初始緩衝區大小是8192B
DataInputStream dataInputStream = new DataInputStream(bufferedInputStream);
dataInputStream.reset();//這是BufferedInputStream提供的功能，如果不在這個基礎上包裝會出錯
System.out.println("DataInputStream現在具有readInt，readChar,readUTF等功能");
int value = dataInputStream.readInt();//讀出來一個int,包含四個位元組
//我們轉換成字元依次顯示出來，可以看到LZ檔案的前四個字元
String binary = Integer.toBinaryString(value);
int first = binary.length() % 8;
System.out.print("使用readInt讀取的前四個字元：");
for (int i = 0; i < 4; i++) {
if (i == 0) {
System.out.print(((char)Integer.valueOf(binary.substring(0, first), 2).intValue()));
}else {
System.out.print(((char)Integer.valueOf(binary.substring(( i - 1 ) * 8 + first, i * 8 + first), 2).intValue()));
}
}
System.out.println();
System.out.println("---------------------------------------------------------------------------------");
//PushbackInputStream無法包裝BufferedInputStream支援mark reset，因為它覆蓋了reset和mark方法
//因為流已經被讀取到末尾，所以我們必須重新開啟一個檔案的控制程式碼，即FileInputStream
inputStream = new FileInputStream(filePath);
PushbackInputStream pushbackInputStream = new PushbackInputStream(inputStream,len);//裝飾成 PushbackInputStream
System.out.println("PushbackInputStream裝飾以後支援退回操作unread");
byte[] bytes = new byte[len];
pushbackInputStream.read(bytes);//讀完了整個流
System.out.println("unread回退前的內容：" + new String(bytes));
pushbackInputStream.unread(bytes);//再退回去
bytes = new byte[len];//清空byte陣列
pushbackInputStream.read(bytes);//再讀
System.out.println("unread回退後的內容：" + new String(bytes));
System.out.println("---------------------------------------------------------------------------------");
/* 以上有兩個一層裝飾和一個兩層裝飾,下面我們先裝飾成Reader，再進行其它裝飾 */
//由於之前被PushbackInputStream將流讀取到末尾，我們需要再次重新開啟檔案控制程式碼
inputStream = new FileInputStream(filePath);
InputStreamReader inputStreamReader = new InputStreamReader(inputStream,"utf-8");//先裝飾成InputStreamReader
System.out.println("InputStreamReader有reader的功能，比如轉碼：" + inputStreamReader.getEncoding());
System.out.println("---------------------------------------------------------------------------------");
BufferedReader bufferedReader = new BufferedReader(inputStreamReader);//我們進一步在reader的基礎上裝飾成BufferedReader
System.out.println("BufferedReader有readLine等功能：" + bufferedReader.readLine());
System.out.println("---------------------------------------------------------------------------------");
LineNumberReader lineNumberReader = new LineNumberReader(inputStreamReader);//我們進一步在reader的基礎上裝飾成LineNumberReader
System.out.println("LineNumberReader有設定行號，獲取行號等功能（行號從0開始）,當前行號：" + lineNumberReader.getLineNumber());
System.out.println("---------------------------------------------------------------------------------");
//此處由於剛才被readLine方法將流讀取到末尾,所以我們再次重新開啟檔案控制程式碼,並需要將inputstream再次包裝成reader
inputStreamReader = new InputStreamReader(new FileInputStream(filePath));
PushbackReader pushbackReader = new PushbackReader(inputStreamReader,len);//我們進一步在reader的基礎上裝飾成PushbackReader
System.out.println("PushbackReader是擁有退回操作的reader物件");
char[] chars = new char[len];
pushbackReader.read(chars);
System.out.println("unread回退前的內容：" + new String(chars));
pushbackReader.unread(chars);//再退回去
chars = new char[len];//清空char陣列
pushbackReader.read(chars);//再讀
System.out.println("unread回退後的內容：" + new String(chars));
}
}
複製程式碼上述便是IO的裝飾器使用，其中InputStream就相當於上述的Component介面，只不過這裡是一個抽象類，這是我們裝飾的目標抽象類。FileInputstream就是一個ConcreteComponent，即待裝飾的具體物件，它並不是JAVA的IO結構中的一個裝飾器，因為它無法裝飾InputStream。剩下BufferedInputStream，DataInputstream等等就是各種裝飾器了，對比上述的標準裝飾器樣板，JAVA的IO中也有抽象的裝飾器基類的存在，只是上述沒有體現出來，就是FilterInputStream，它是很多裝飾器最基礎的裝飾基類。
在上述過程中，其中dataInputStream是經過兩次裝飾後得到的，它具有了dataInputStream和bufferedInputStream的雙重功能，另外，InputStreamReader是一個特殊的裝飾器，它提供了位元組流到字元流的橋樑，其實它除了具有裝飾器的特點以外，也有點像一個介面卡，但還是覺得它應當算是一個裝飾器。
其它的IO裝飾器各位可以自行嘗試或者和上述的標準的裝飾器模式程式碼比對一下，下面另附LZ的IO裝飾器程式執行後結果。
從上面的展示中，已經可以充分體會到裝飾器模式的靈活了，我們建立的一個FileInputstream物件，我們可以使用各種裝飾器讓它具有不同的特別的功能，這正是動態擴充套件一個類的功能的最佳體現，而裝飾器模式的靈活性正是JAVA中IO所需要的，不得不讚一下JAVA類庫的建造者實在是強悍。
上述的XXXXInputStream的各個類都繼承了InputStream，這樣做不僅是為了複用InputStream的父類功能（InputStream也是一種模板方法模式，它定義了read(byte[])方法的簡單演算法，並將read()方法交給具體的InputStream去實現），也是為了可以重疊裝飾，即裝飾器也可以再次被裝飾，而過渡到Reader以後，Reader的裝飾器體系則是類似的。
總之呢，裝飾器模式就是一個可以非常靈活的動態擴充套件類功能的設計模式，它採用組合的方式取代繼承，使得各個功能的擴充套件更加獨立和靈活。
note:有些事，很多人都在做，你不做不代表你錯啦