他有很多特點：

1、  裝飾模式雨繼承關系的目的都是要擴展對象的功能，但是裝飾模式可以提供比繼承更多的靈活性。裝飾模式準系統動態的決定“貼上”一個需要的“裝飾”，或者除掉一個不需要的裝飾。而繼承則不同，繼承關系是靜態的，他在系統運行前就決定了。

2、  他可以通過使用不同的具體修飾類以及這些裝飾類的排例組合，設計可以創造更多不同行為的組合。     

3、  他雖然比繼承性要靈活，這意味著他比繼承更容易出錯。

缺點：由于使用裝飾模式可以比使用繼承關系需要較少數目的類，但是在另一方面，使用裝飾模式會產生比使用繼承方式更多的對象。這在使用時進行錯誤查詢變得更困難了，特別是這些對象看上去都很像。

import java.util.*;

class BookName{
 String name;
 int number;
}
abstract class Note{
 BookName name = new BookName();
 abstract public void setName(String value);
 abstract public int getNumber();
 abstract public void setNumber(int value);
 abstract public String getName();
} 
class StudentNote extends Note implements Cloneable{
 BookName name = new BookName();
 int isbn;
 public void setName(String value){
  name.name = value;
 }
 public void setNumber(int i){
  name.number = i;
 }
 public int getNumber(){
  return name.number;
 }
 public String getName(){
  return name.name;
 }
 public Object clone() throws CloneNotSupportedException{
  StudentNote st = new StudentNote();
  st = (StudentNote)super.clone();
  st.name = new BookName();
  st.name.name = name.name;
  st.name.number = name.number;
  return st;
 }
 public void setIsbn(int i){
  isbn = i;
 }
 public int getIsbn(){return isbn;}
}
class Manager{
 private Vector v = new Vector();
 
 public void add(Note note){
  v.addElement(note);
 }
 public Note get(int i){
  return (Note)v.get(i);
 }
 public int size(){
  return v.size();
 }
}

class Client{
 private StudentNote student;
 private static Manager client = new Manager();
 public void register()throws CloneNotSupportedException{
  student = new StudentNote();
  StudentNote st = (StudentNote)student.clone();
  client.add(st);
 }
 public static Manager getInstance(){
  return client;
 }

}

class test{ 
 public static void main(String[] args)throws CloneNotSupportedException {
  Client c = new Client();
  c.register(); 
  c.register();
  Manager manager = c.getInstance();
  StudentNote student = (StudentNote)manager.get(0);
  StudentNote st = (StudentNote)manager.get(1);
  student.setName("sky");
  student.setNumber(101);
  student.setIsbn(10001);
  st.setName("fly");
  st.setNumber(102);
  st.setIsbn(10002);
  System.out.println(student.getName() + "\t" + student.getNumber() + "\t" + student.getIsbn());
  System.out.println(st.getName() + "\t" + st.getNumber() + "\t" + st.getIsbn());
 }
}

  <java與模式> ---電子書 page 425

裝飾模式—Decorator

裝飾模式有名包裝模式，裝飾模式以對客戶端透明的方式來擴展對象的功能，是繼承關系的一個替代的方案。

客戶端并不會覺得裝飾模式在裝飾前和裝飾后有什么不同，他可以在不使用更多的子類的情況下來進行對對象的功能加以擴展。結構圖如下：

裝飾模式原來被裝飾類的一個子類的實例，把客戶端的調用委派到被裝飾類。他有以下組成：抽象構件，具體構件，裝飾角色，具體裝飾；他一般在下面這些情況使用他最好：

1、  需要擴展一個類的功能，或給一個類增加附加責任。

2、  需要動態的給一個對象增加功能，這些功能可能被動態的撤消。

3、  需要增加一些基本功能的排例組合而產生的非常大量的功能，從而使繼承關系變得不現實。

優點：他可以靈活的增加一個類或對象的功能，也可以通過不同的具體裝飾類的排例組合設計出更加復雜的，功能更強的類。

import java.io.*;

public class FileRead{
 private static int space=0;
 private static double totalFile = 0;
 private static double totalDirectory = 0;
 
 public String printSpace(int space){
  String str = "";
  for(int i=0;i<space;i++)
   str += "    ";
  return str; 
 }

 public void searchFile(File f)throws IOException{
  String path = f.getAbsolutePath();
  File currentFile = new File(path); //取得當前路徑的文件
  File[] file = currentFile.listFiles();
  
  space++;

  for(int i=0;i<file.length;i++){
   System.out.println(printSpace(space) + file[i].getName());
   if(file[i].isDirectory()){
    totalDirectory  += 1;
    searchFile(file[i]);
    if(space>0)
     space--;   
   }
   totalFile += 1; 
  }
 } 
 public static void main(String args[])throws IOException{
  String path = null;
  if(args.length<1)
   path =".";
  else
   path = args[0];
  FileRead read = new FileRead();
  File file = new File(path);
  
  if(!file.exists()){
   System.err.print("the path is error");
   System.exit(1);
  } 
  read.searchFile(file);
  System.out.println("the file is :" + (totalFile-totalDirectory));
  System.out.println("thd directory is : " + totalDirectory);
 }
}
這個程序在便歷多文件時會出現問題？不知道問題在哪里？

合成模式
        合成模式他是一種樹型結構，他可以通過對合成的圖的單獨部分方法達到對整個合成圖方法問。他由三部分組成，抽象構件—Component和樹枝構件—Composite以及樹葉構件Leaf。合成模式分為兩種，一種是透明式的。另一個是安全式的合成模式。
         透明式的合成模式和安全式的合成模式，他們的組成成分都一樣，他們的區別是：透明式的合成模式，他在抽象構件種增加了操作子類對象的一些接口，這樣在實現的過程中，無論是樹枝構件還是樹葉構件都必須實現這些接口，這對樹葉構件來說，這種接口實現是多余的，所以樹葉構件是通過平庸式的方式來實現，這種實現，將造成編譯時可以通過，但是當用戶在應用的過程過如果調用這些方法，將造成運行時的錯誤，這就造成了程序的不安全；而安全式的合成模式，他并沒有在抽象構件實現對子結點接口的申明，他是通過樹枝直接對管理子類所需要的方法進行申明，這就給程序帶來靈活性，但是也給程序帶來不便的管理性，這種實現使得程序不會出現運行時的錯誤。
         一般我們在這樣的情況下應用合成模式：
                  1、當我們要體現構件的部分和整體的結構時。
                  2、當我們要要忽略個體構件與整體構件的區別時，并且要平等的對待個體構件和整體構件時。
         使用合成構件有以下好處：
                  1、使用合成模式可以很容易的增加新構件的種類。
                  2、使用合成模式方便了用戶對構件的使用，因為他們不用擔心使用的是樹頁構件還是樹枝構件。
         他的缺點：使用合成模式之后在控制樹枝構件的類型就不是那么容易了。