他有很多特點：

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、使用合成模式方便了用戶對構件的使用，因為他們不用擔心使用的是樹頁構件還是樹枝構件。
         他的缺點：使用合成模式之后在控制樹枝構件的類型就不是那么容易了。

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

結構模式(Structural Pattern)描述的是類和對象結合在一起行成的更大的結構。分為類的結構模式和對象的結構的結構模式。類的結構模式如：適配器模式，對象的結構模式：代理人模式。

結構模式：合成模式、享元模式、裝飾模式、適配器模式、缺省適配器模式、代理模式、門面模式、橋梁模式

適配器模式與缺省適配器模式——Adapter ，Default Adapter  page349 第22章

適配器模式就是把一個類的接口變換成客戶端所期待的接口，從而使原來因接口不匹配而無法在一起工作的兩個類可以在一起工作。它有兩種模式，一種是類的適配器模式，一種叫對象的適配器模式。

模式中三種角色：

1、  目標角色：這就是客戶端所期待的接口。

2、  源角色：現有的適配接口。

3、  適配器角色：它負責叫源接口轉換成目標接口。

類適配器一般用的是繼承的方式來實現的，但對象適配器是用的委派。其中對象適配器比起類配器有一些優勢，它可以將不同源適配到同一個目標，它甚至可以適配同一個源和它的子類，這對類適配器來說很難的。（類適配器就要先做一個源類的子類，然后將源類的子類進行適配）

系統在什么時候使用適配器：

1、  系統需要使用現有的類，而此類的接口有不符合系統的要求。

2、  想成立一個可以重復使用的類，用于將那些之間沒有太大的關系的類一起工作。

缺省適配器模式：它和適配器模式幾乎相同，它的作用也和適配器的作用一樣，它是適配器模式中的一種特殊的模式。其中的適配器類是一個平庸化的類，它是一個抽象類，但是它實現了從源接口中繼承的所有方法，如果不存在適配類的子類，那么適配類就沒有意義。如：WindowListener 的適配類WindowsAdapter。

J2SE中的缺省適配器模式

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

原型模式：

       深度拷貝：一個是將一個對象中的一個所有域和方法都復制一遍，其中的對象域也一并復制；另一個種是通過流來進行深克窿，因為在java虛擬機中，當把一個對象寫到流的對象只是一個拷貝，JVM中還存在原對象。（把對象寫到流的過程叫串行化——Serializable）要能夠實現第二種深復制必須滿足，類中所引用的對象全部都是串行話的，否則，就需要仔細考察那些不可串行化的對象是否可設成transient，從而將之排除在復制之外。

代碼測試：

public Object objcetClone() throws IOException, ClassNotFoundException{

              ByteArrayOutputStream o = new ByteArrayOutputStream();

              ObjectOutputStream out = new ObjectOutputStream(o);

              out.writeObject(this);

              ByteArrayInputStream i = new ByteArrayInputStream(o.toByteArray());

              ObjectInputStream in = new ObjectInputStream(i);

              return in.readObject();

       }

 復習

其中登記式注冊單例模式：

import java.util.*;

class Single{

       private static HashMap hashmap = new HashMap();

       private int number = 0;

       static{

              Single single = new Single();

              hashmap.put(single.getClass().getName(),single);

       }

       private Single(){}

       public static Single getInstance(String name){

              if(name == null){

                     name = "Single";

              }

              if(hashmap.get(name) == null){

                     try{

                            hashmap.put(name,Class.forName(name).newInstance());

                     }catch(Exception e){

                            System.out.println(e.getMessage());

                     }

              }

              return (Single)hashmap.get(name);

       }

       public void fun(){

              number++;

              System.out.println("the is the single fun :" + number);

       }

}

他的另外一個做法是同過繼承，通過父類來注冊子類的對象：

代碼如：

class SingleChild extends Single{

       public SingleChild(){}

       public static SingleChild getInstance(){

              return (SingleChild)Single.getInstance("SingleChild");

       }

       public void fun(){

              System.out.println("singlechild");

       }

}

當它要這樣做之后就破壞了父類，因為子類要調用父類的構造子函數，所以父類的構造子函數就不能夠為私有的，這就破壞單例模式的優點。

 <java編程語言 >

多太中的一種情況

在類的多太中，域是由他引用的類型決定那個版本，而方法則是由對象的真實類決定的。這和接口中使用的一樣。

測試代碼如下：

class Father{

       public String str="father";

       public void fun(){

              System.out.println("Father : " + str);

       }

}

class ChildOne extends Father{

       public String str="childone";

       public void fun(){

              System.out.println("ChildOne : " + str);

       }

}

public class TestClassProMeth {

       public static void main(String args[]){

              ChildOne childone = new ChildOne();

              Father father = childone;

              father.fun();

              childone.fun();

              System.out.println(father.str + '\n' + childone.str);

       }

}

結果：

ChildOne : childone

ChildOne : childone

father

childone

接口：

在接口中的聲明的域是是一個常量（public static final），他的方法不能夠有其他的修飾符，隱式為public，也不能夠被擁有定義實現符的修飾如：native，synchronized，strictfp也不能夠是靜態的，因為靜態方法不能夠抽象方法。

繼承接口：如果接口聲明了一個和繼承來的常量名相同，則無論他的類型如何都將被隱藏，并且當他們的類型不一致時，編譯出錯。

測試如下：

interface Super{

       public static final String name = "super";

       void fun();

}

interface Entend extends Super{

       String name = "entend";

       String str = Super.name + '\n' + name;

       void fun();

}

class Realize implements Entend{

       public void fun(){

              System.out.println(Super.name + '\n' + Entend.name + '\n' + str);

       }

}

public class TestInterface {

       static String name ="testinterface";

       public static void main(String args[]){

              Realize real = new Realize();

              real.fun();

              System.out.println(Realize.name + '\n' + ((Super)real).name);

       }

}

結果：

super

entend

super

entend

entend

super

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

第17章  page245 多例模式

       當實例數目不多是時候，可以用一個個的靜態變量來存儲一個個的實例，在數目多是時候需要使用靜態聚集存儲方式來存儲這些實例。

問題：怎樣用靜態聚集存儲方式來存儲？具體如何實現？

建造模式（builder）

建造模式（builder）page277

建造模式可以將一個產品的內部表象與產品的生成過程分割開來，從而可以使一個建造過程生成具有不同的內部表象的產品對象

內部表象—一個產品有不同的組成成分作為產品的零件，這些零件有可以是對象，也有可能不是對象，它們通常又叫做產品的內部表象。

抽象建造者角色：給出一個抽象內部接口，以規范產品對象的各個組成成分的建造，一般而言，該接口獨立于應用程序的商業邏輯。

具體建造者角色：擔任這個角色的是與應用程序緊密相關的一些類，他們在應用程序調用下創建產品的實例。他的任務：1、實現抽象建造者所有申明的接口，給出一步一步的完成創建產品實例的操作。2、在創建過程完成后，提供產品的實例。

導演者：擔任這個角色的類調用具體建造者角色以創建產品對象。

產品角色：產品是焦躁中的復雜對象。

下面是一個由兩個產品類構成的建造模式結構圖： 

第20章 原始原型模式

用意：原始模型模式屬于對象的創建模式；通過給出一個原形對象來指明所要創建的對象類型，然后用復制這個原型對象的辦法創建出更多類型的對象。

問題：什么叫不變對象？ page314

簡單形式的原始模型模式：

客戶角色：客戶類提出創建對象的請求；

抽象原型角色：這是一個抽象角色，通常由一個java接口或java抽象實現，此角色給出所有的具體原型類所需要的接口；

具體原型角色：被復制的對象，此角色需要實現抽象的原型角色所要求的接口。

結構圖如下：

登記式原型模型模式：

增加了一個原型管理器角色：創建具體原型類的對象，并記錄每一個被創建的對象。

結構圖如下：

抽象原型

具體原型

客戶

原型管理器

 

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

抽象工廠模式：page171 第14章

抽象工廠的用意是使客戶端在不必指定產品的具體的情況下創建多個產品族中的產品對象；

抽象工程模式是對象的創建模式。

在什么情況下用抽象工廠模式：

1、 一個系統不應當依賴產品類實例如何創建、組合和表達的細節，這對與所有形態的工廠模式都是重要的。

2、這個系統的產品有多于一個的產品族，而系統只消耗其中某一族的產品

3、同屬于一個產品族的產品是在一起使用的，這一約束必須在系統的設計中體現出來

4、系統提供一個產品類的庫，所以的產品以同樣的接口出現，從而使客戶端不依賴于實現。

擴展：

1、產品的等級結構擴展，也就是當在增加一個平行等級新的產品時，抽象工程不支持“開—閉”原則

2、在增加新產品族的時，支持開-閉原則。

問題：為什么上面的抽象工廠和抽象產品沒有依賴關系呢？（在工廠方法模式中）在這里我們同樣用了抽象產品的接口作為抽象工廠的返回接口呀！

第15章 單例模式 page201

單例模式的要點：

1、  某個類只可以有一個實例

2、  該類必須自行創建實例

3、  它必須自行向整個系統提供這個實例

一、 漢式單例類

該類自己含有一個實現自己實例的靜態方法，同時為了不讓外界創建實例，則它的構造方法必須是私有的。

代碼測試：

       class EagerSimple{

              private static final EagerSimple eager = new EagerSimple();

              private EagerSimple{}

              public static EagerSimple getInstance(){

                     return eager;

}

}

二、懶漢式單例類

它也餓漢式單例類不同的是，只有當自己被引用的時候，自己才被實例化。結構圖與餓漢式單例類一樣的。

代碼測試：

class LanSimple{

       private static LanSimple simple= null;

       private LanSimple(){}

       synchronized public static LanSimple getInstance(){

              if(simple == null)

                     simple = new LanSimple();

              return simple;

}    

}

餓漢式單例類與懶漢式單例類的區別是：在時間和反映上說，餓漢式要比懶漢式好，但是從資源利用上則餓漢式要好。

雙重檢查成例的“懶漢式”單例類：

class LazySimple{

       private LazySimple(){}

       private static LazySimple lazy = null;

       public static LazySimple getInstance(){

              if(lazy == null){

                     synchronized(lazy){

                            if(lazy == null){

                                   lazy = new LazySimple();

                            }

                     }

              }

              return lazy;

       }

}

這個代碼看上去并沒有步合理之出，而且我認為還相當有意義，可是為什么說在java中就不對呢？不能夠使用呢？問題在哪里？

對簡單工廠的特殊情況進行測試——工廠角色與具體產品角色合并

代碼如下：

abstract class AbstractClass{

       private static String name;

       public final static AbstractClass format(String value){

              name = value;

              return new Embody();

       }

       public String getMsg(){

              return name;

       }

       public abstract void fun1();

}

class Embody extends AbstractClass{

       public void fun1(){

              System.out.println("the enbody extends AbstractClass" + getMsg());

       }

}

public class tt {

       public static void main(String args[]){

              AbstractClass.format("name").fun1();

       }

}

上面的代碼中通過工廠方法把子類具體的實例化隱藏了起來。

下面是對一個普通的簡單工廠模式的實現：

代碼測試：

package sky;

//產品抽象類

abstract class People{

       public String name; //名字

       public String occuptationl;  //職業

       abstract public String getMsg();

}

//學生類——具體產品

class Student extends People{

       private String name;

       private String occupation;

       private String grade;

       public Student(String name,String occupation){

              this.name = name;

              this.occupation = occupation;

       }

       public void setGrade(String grade){

              this.grade = grade;

       }

       public String getGrade(){

              return grade;

       }

       public String getMsg(){

              return getOccupation()+getName()+getGrade();

       }

       public String getOccupation(){

              return occupation;

       }

       public String getName(){

              return name;

       }

}

//教師類——具體產品類

class Teacherextends People{

       private String name;

       private String occupation;

       private int wage;

       public Teacher(String name,String occupation){

              this.name = name;

              this.occupation = occupation;

       }

       public void setWage(int wage){

              this.wage = wage;

       }

       public String getMsg(){

              return getOccupation()+getName() + getWage();

       }

       public String getOccupation(){

              return occupation;

       }

       public String getName(){

              return name;

       }

       public int getWage(){

              return wage;

       }

}

//工廠類

class factory{

       public static People build(String name,String occupation) throws BadPeopleException{

              if(occupation.equals("student")){

                     return new Student(name,occupation);

              }

              else if(occupation.equals("teacher")){

                     return new Teacher(name,occupation);

              }else{

                     throw new BadPeopleException("can not found the people");

              }

       }

}

//異常處理

class BadPeopleException extends Exception{

       public BadPeopleException(String msg){

              super(msg);

       }

}

public class test{

       public static void main(String args[]){

              try {

                     Student t = (Student) factory.build("sky","student");

 //從這個顯示轉換申明中我并沒有看到簡單工廠的好處

                     factory.build("fly","teacher");

/*難道只有這樣才可以看到它的優點嗎？——能夠避免客戶決定什么時候創建哪個實例*/

                     t.setGrade("three");

                     System.out.println(t.getMsg());

              } catch (BadPeopleException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

       }

}

     問題：接口和抽象類的區別在哪里？    

  第13章 工廠方法模式 <java與模式> ---電子書 page146

       組成為：抽象工廠、具體工廠、抽象產品、具體產品

其中抽象工廠是為外部訪問內部的一個接口，它的好處是可以通過擴張具體產品和具體工廠而不用改變客戶端的代碼.

一個簡單的測試代碼如下：

interface Fruit{

       void grow();

       void harvest();

}

class Apple implements Fruit{

       private int treeNumber;

       public void grow(){

              System.out.println("Apple.grow()");

       }

       public void harvest(){

              System.out.println("Apple.harvest()");

       }

       public void setTreeNumber(int number){

              treeNumber = number;

       }

       public int getTreeNumber(){

              return treeNumber;

       }

}

class StrawBerry implements Fruit{

       public void grow(){

              System.out.println("StrawBerry.grow()");

       }

       public void harvest(){

              System.out.println("StrawBerry.harvest()");

       }

}

 abstract class Gardener{

      abstract public Fruit product();

 }

 class AppleGardener extends Gardener{

      public Fruit product(){

             return new Apple();

      }

 }   

 class StrawBerryGardener extends Gardener{

      public Fruit product(){

             return new StrawBerry();

      }

 }

public class Client {

       public static void main(String args[]){

              Fruit apple,strawberry;

              AppleGardener applegarder = new AppleGardener();

              StrawBerryGardener strawberrygarder = new StrawBerryGardener();

              apple = applegarder.product();

              strawberry = strawberrygarder.product();

              apple.grow();

              strawberry.grow();

       }

}

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

第2.4部分 UML  page16

理解： 類圖

一、描述類的類圖

一般如果類不包含內部類，則可以將類圖分為四層。

1、第一層描述的是類的名字，如果為斜體則該類為抽象類。

2、第二層描述的是類的屬性，規則是：[+|-|#]classname<變量名>如果有下劃線則表示其為靜態的。+表示為public、—表示為private、#表示為protected。

3、第三層描述的是類的方法，規則是：[+|-|#]funcationname<變量名>如果有下劃

則表示其為靜態的。

4、第四層表示的是類的性質，也就是類的屬性，不過一旦有該屬性，類就要實現方法，set和get方法。

       接口類的類圖和類的類圖幾乎一樣。

問題：該類中包含有內部類的有是如何分層的呢？

二、描述對象的類圖

他們的關系會發生在類和類、類和接口、接口和接口之間。

類圖的關系可以分為：一般關系、關聯關系、聚合關系、合成關系、依賴關系。

1、一般關系表現在類或則接口之間的繼承關系。

2、關聯關系是指他用另一個類的實例作為其屬性，而聚合關系基本上也是這個意思不過聚合主要體現的是總體和四肢的關系，如：類的屬性是用一個對象數組實現的，那么該類就和實現這個屬性數組的類是一個聚合關系。

3、合成關系要比聚合關系要強，他在每一個時刻只能夠和一個對象發生合成關系，他不能夠共享。

4、依賴關系是在一個的方法中引用了一個類的對象作為是參數，或是引用了一個類的對象作為局部變量或引用類的靜態方法或屬性。 

問題：合成關系中的共享，到底什么不能夠共享？怎么理解這個不能夠共享？合成關系很難理解，“他在每一個時刻只能夠和一個對象發生合成關系”這句話與關聯關系中不就一樣了嗎？也就是說，當我們直接用一個類A來聲明一個對象作為一個類B的屬性，那么我們就可以說這個類A關聯類B，那也可以說類A合成類B嗎？

第十二章 簡單工廠模式

“開—閉”原則要求一個系統的設計準許在系統不需要修改的情況下擴展其功能。

理解：簡單工廠模型簡單說就是：抽象產品——>具體產品<-----------工廠類

       在特殊的情況下，也就是當只有一個具體產品的時候，我們可以將其中抽象產品不要，但是這種用法看上去不是很多。一個更為特殊的用法是將抽象產品和工廠類合并.