設計模式總結篇系列：原型模式（Prototype）

首先對原型模式進行一個簡單概念說明：通過一個已經存在的對象，復制出更多的具有與此對象具有相同類型的新的對象。

在理解Java原型模式之前，首先需要理解Java中的一個概念：復制/克隆。

在博文《Java總結篇系列：java.lang.Object》一文中，對Java中的clone()方法進行了一定的闡述。同時，我們需要知道，Java中的對象復制/克隆分為淺復制和深復制。

一、淺復制：

我們知道，一個類的定義中包括屬性和方法。屬性用於表示對象的狀態，方法用於表示對象所具有的行為。其中，屬性既可以是Java中基本數據類型，也可以是引用類型。Java中的淺復制通常使用clone()方式完成。

當進淺復制時，clone函數返回的是一個引用，指向的是新的clone出來的對象，此對象與原對象分別占用不同的堆空間。同時，復制出來的對象具有與原對象一致的狀態。

此處對象一致的狀態是指：復制出的對象與原對象中的屬性值完全相等==。

下面以復制一本書為例：

1.定義Book類和Author類：

class Author {  2 
    private String name;  4     private int age;  5 
    public String getName() {  7         return name;  8  }  9 
    public void setName(String name) { 11         this.name = name; 12  } 13 
    public int getAge() { 15         return age; 16  } 17 
    public void setAge(int age) { 19         this.age = age; 20  } 21 
}

class Book implements Cloneable {  2 
    private String title;  4     private int pageNum;  5     private Author author;  6 
    public Book clone() {  8         Book book = null;  9         try { 10             book = (Book) super.clone(); 11         } catch (CloneNotSupportedException e) { 12             // TODO Auto-generated catch block
 e.printStackTrace(); 14  } 15         return book; 16  } 17 
    public String getTitle() { 19         return title; 20  } 21 
    public void setTitle(String title) { 23         this.title = title; 24  } 25 
    public int getPageNum() { 27         return pageNum; 28  } 29 
    public void setPageNum(int pageNum) { 31         this.pageNum = pageNum; 32  } 33 
    public Author getAuthor() { 35         return author; 36  } 37 
    public void setAuthor(Author author) { 39         this.author = author; 40  } 41 
}

2.測試：

package com.qqyumidi;  2 
public class PrototypeTest {  4 
    public static void main(String[] args) {  6         Book book1 = new Book();  7         Author author = new Author();  8         author.setName("corn");  9         author.setAge(100); 10  book1.setAuthor(author); 11         book1.setTitle("好記性不如爛博客"); 12         book1.setPageNum(230); 13 
        Book book2 = book1.clone(); 15         
        System.out.println(book1 == book2);  // false
        System.out.println(book1.getPageNum() == book2.getPageNum());   // true
        System.out.println(book1.getTitle() == book2.getTitle());        // true
        System.out.println(book1.getAuthor() == book2.getAuthor());        // true
        
 } 22 }

由輸出的結果可以驗證說到的結論。由此我們發現：雖然復制出來的對象重新在堆上開辟了內存空間，但是，對象中各屬性確保持相等。對於基本數據類型很好理解，但對於引用數據類型來說，則意味着此引用類型的屬性所指向的對象本身是相同的， 並沒有重新開辟內存空間存儲。換句話說，引用類型的屬性所指向的對象並沒有復制。

由此，我們將其稱之為淺復制。當復制后的對象的引用類型的屬性所指向的對象也重新得以復制，此時，稱之為深復制。

 

 

二、深復制：

 Java中的深復制一般是通過對象的序列化和反序列化得以實現。序列化時，需要實現Serializable接口。

下面還是以Book為例，看下深復制的一般實現過程：

1.定義Book類和Author類（注意：不僅Book類需要實現Serializable接口，Author同樣也需要實現Serializable接口!!）：

class Author implements Serializable{  2 
    private String name;  4     private int age;  5 
    public String getName() {  7         return name;  8  }  9 
    public void setName(String name) { 11         this.name = name; 12  } 13 
    public int getAge() { 15         return age; 16  } 17 
    public void setAge(int age) { 19         this.age = age; 20  } 21 
}

class Book implements Serializable {  2 
    private String title;  4     private int pageNum;  5     private Author author;  6 
    public Book deepClone() throws IOException, ClassNotFoundException{  8         // 寫入當前對象的二進制流 
        ByteArrayOutputStream bos = new ByteArrayOutputStream(); 10         ObjectOutputStream oos = new ObjectOutputStream(bos); 11         oos.writeObject(this); 12         
        // 讀出二進制流產生的新對象 
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray()); 15         ObjectInputStream ois = new ObjectInputStream(bis); 16         return (Book) ois.readObject(); 17  } 18     
    public String getTitle() { 20         return title; 21  } 22 
    public void setTitle(String title) { 24         this.title = title; 25  } 26 
    public int getPageNum() { 28         return pageNum; 29  } 30 
    public void setPageNum(int pageNum) { 32         this.pageNum = pageNum; 33  } 34 
    public Author getAuthor() { 36         return author; 37  } 38 
    public void setAuthor(Author author) { 40         this.author = author; 41  } 42 
}

2.測試：

public class PrototypeTest {  2 
    public static void main(String[] args) throws ClassNotFoundException, IOException {  4         Book book1 = new Book();  5         Author author = new Author();  6         author.setName("corn");  7         author.setAge(100);  8  book1.setAuthor(author);  9         book1.setTitle("好記性不如爛博客"); 10         book1.setPageNum(230); 11 
        Book book2 = book1.deepClone(); 13         
        System.out.println(book1 == book2);  // false
        System.out.println(book1.getPageNum() == book2.getPageNum());   // true
        System.out.println(book1.getTitle() == book2.getTitle());        // false
        System.out.println(book1.getAuthor() == book2.getAuthor());        // false
        
 } 20 }

從輸出結果中可以看出，深復制不僅在堆內存上開辟了空間以存儲復制出的對象，甚至連對象中的引用類型的屬性所指向的對象也得以復制，重新開辟了堆空間存儲。

 

至此：設計模式中的創建型模式總結完畢，一共有五種創建型模式，分別為：單例模式（SingleTon）、建造者模式（Builder）、工廠方法模式（Factory Method）、抽象工廠模式（Abstract Factory）和原型模式（Prototype）。每種模式適用於不同的場景，具體應用時需注意區分。