一、設計模式的分類

設計模式分為三類：

1、創建型模式，共五種：工廠方法模式、抽象工廠模式、單例模式、建造者模式、原型模式。
2、結構型模式，共七種：適配器模式、橋接模式、組合模式、裝飾器模式、外觀模式、享元模式、代理模式。
3、行為型模式，共十一種：策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、解釋器模式。

二、設計模式

1、工廠模式

1）普通工廠模式就是建立一個工廠類，對實現了同一接口的一些類進行實例的創建。
示例代碼：

建立一個示例。
先創建共同的接口：
public interface Shape {  
    public void draw();  
} 

再創建實現類：
長方形
public class Rectangle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Rectangle");  
    }  
}  
正方形
public class Square implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Square");  
    }  
}  

最后創建工廠類：
public class ShapeFactory {  
    public Shape produce(String type) {  
        if ("Rectangle".equals(type)) {  
            return new Rectangle();  
        } else if ("Square".equals(type)) {  
            return new Square();  
        } else {  
            System.out.println("請輸入正確的類型!");  
            return null;  
        }  
    }  
}  

測試代碼：
public class FactoryTest {  
    public static void main(String[] args) {  
        ShapeFactory factory = new ShapeFactory();  
        Shape Shape= factory.produce("Rectangle");  
        shape.draw();  
    }  
}  

輸出結果：Rectangle

2）多個工廠方法模式是對普通工廠方法模式的改進，在普通工廠方法模式中，如果傳遞的字符串出錯，則不能正確創建對象，而多個工廠方法模式是提供多個工廠方法，分別創建對象。
示例代碼：

將上面發送的工廠代碼ShapeFactory 修改下：
public class ShapeFactory {  
   public Shape produceRectangle(){  
        return new Rectangle();  
    }  
    public Shape produceSquare(){  
        return new Square();  
    }  
}  

測試代碼：
public class FactoryTest {  
    public static void main(String[] args) {  
        ShapeFactory factory = new ShapeFactory();  
        Shape shape = factory.produceRectangle();  
        shape.draw();  
    }  
}  

輸出結果：Rectangle

3）靜態工廠方法模式是將上面的多個工廠方法模式里的方法設置為靜態方法，直接調用。
示例代碼：

public class ShapeFactory {  
   public static Shape produceRectangle(){  
        return new Rectangle();  
    }  
    public static Shape Square(){  
        return new Square();  
    }  
}  

測試代碼：
public class FactoryTest {  
    public static void main(String[] args) {  
        Shape shape = ShapeFactory.produceRectangle();  
        shape.draw();  
    }  
}  

輸出結果：Rectangle

總結：凡是出現了大量的產品需要創建，并且具有共同的接口時，可以通過工廠方法模式進行創建。在以上的三種模式中，第一種如果傳入的字符串有誤，不能正確創建對象，第三種相對于第二種，不需要實例化工廠類，所以，大多數情況下，我們會選用第三種——靜態工廠方法模式。

注：使用反射機制可以解決每次增加一個產品時，都需要增加一個對象實現工廠的缺點。
示例代碼：

public class ShapeFactory {
    public static Object getClass(Class<?extends Shape> clazz) {
        Object obj = null;
        try {
            obj = Class.forName(clazz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

2、抽象工廠模式

工廠方法模式有一個問題，類的創建依賴工廠類，也就是說，如果想要拓展程序，必須對工廠類進行修改，這違背了閉包原則，所以，從設計角度考慮，有一定的問題，如何解決？就用到抽象工廠模式，創建多個工廠類，這樣一旦需要增加新的功能，直接增加新的工廠類就可以了，不需要修改之前的代碼。

示例代碼：

建立一個示例。
先創建共同的接口：
public interface Shape {  
    public void draw();  
} 

再創建實現類：
長方形
public class Rectangle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Rectangle");  
    }  
}  
正方形
public class Square implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Square");  
    }  
}  

最后創建工廠類：
先創建共同接口：
public interface Factory {  
    public void produce();  
} 
再創建工廠類：
public class RectangleFactory {  
    public Shape produce(String type) {  
            return new Rectangle();   
    }  
}  
public class SquareFactory {  
    public Shape produce(String type) {  
            return new Square();   
    }  
}  

測試代碼：
public class FactoryTest {  
    public static void main(String[] args) {  
        Factory factory = new RectangleFactory();  
        Shape Shape= factory.produce();  
        shape.draw();  
    }  
}  

輸出結果：Rectangle

這個模式的好處就是，如果你現在想增加一個功能：發及時信息，則只需做一個實現類，實現Sender接口，同時做一個工廠類，實現Provider接口，就OK了，無需去改動現成的代碼。

3、單例模式

單例對象（Singleton）是一種常用的設計模式。在Java應用中，單例對象能保證在一個JVM中，該對象只有一個實例存在。
示例代碼：

單例類：
public class Singleton {  

    /* 持有私有靜態實例，防止被引用，此處賦值為null，目的是實現延遲加載 */  
    private static Singleton instance = null;  
  
    /* 私有構造方法，防止被實例化 */  
    private Singleton() {  
    }  
  
    /* 靜態工程方法，創建實例 */  
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
  
    /* 如果該對象被用于序列化，可以保證對象在序列化前后保持一致 */  
    public Object readResolve() {  
        return instance;  
    }  
}   

這個類可以滿足基本要求，但是，像這樣毫無線程安全保護的類，
如果我們把它放入多線程的環境下，肯定就會出現問題了，
如何解決？我們首先會想到對getInstance方法加synchronized關鍵字，
如下：
public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  

但是，synchronized關鍵字鎖住的是這個對象，這樣的用法，
在性能上會有所下降，因為每次調用getInstance()，都要對對象上鎖，
事實上，只有在第一次創建對象的時候需要加鎖，之后就不需要了，
所以，這個地方需要改進。我們改成下面這個：
public static Singleton getInstance() {  
        if (instance == null) {  
            synchronized (instance) {  
                if (instance == null) {  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  

將synchronized關鍵字加在了內部，也就是說當調用的時候是不需要加鎖的，只有在instance為null，并創建對象的時候才需要加鎖，性能有一定的提升。
看下面的情況：在Java指令中創建對象和賦值操作是分開進行的，也就是說instance = new Singleton();語句是分兩步執行的。但是JVM并不保證這兩個操作的先后順序，也就是說有可能JVM會為新的Singleton實例分配空間，然后直接賦值給instance成員，然后再去初始化這個Singleton實例。這樣就可能出錯了，我們以A、B兩個線程為例：

a>A、B線程同時進入了第一個if判斷
b>A首先進入synchronized塊，由于instance為null，所以它執行instance = new Singleton();
c>由于JVM內部的優化機制，JVM先畫出了一些分配給Singleton實例的空白內存，并賦值給instance成員（注意此時JVM沒有開始初始化這個實例），然后A離開了synchronized塊。
d>B進入synchronized塊，由于instance此時不是null，因此它馬上離開了synchronized塊并將結果返回給調用該方法的程序。
e>此時B線程打算使用Singleton實例，卻發現它沒有被初始化，于是錯誤發生了。

所以程序還是有可能發生錯誤，其實程序在運行過程是很復雜的，從這點我們就可以看出，尤其是在寫多線程環境下的程序更有難度，有挑戰性。我們對該程序做進一步優化：

private static class SingletonFactory{           
        private static Singleton instance = new Singleton();           
    }           
    public static Singleton getInstance(){           
        return SingletonFactory.instance;           
    }  

實際情況是，單例模式使用內部類來維護單例的實現，JVM內部的機制
能夠保證當一個類被加載的時候，這個類的加載過程是線程互斥的。這
樣當我們第一次調用getInstance的時候，JVM能夠幫我們保證instance
只被創建一次，并且會保證把賦值給instance的內存初始化完畢，這樣
我們就不用擔心上面的問題。同時該方法也只會在第一次調用的時候使
用互斥機制，這樣就解決了低性能問題。這樣我們暫時總結一個完美的
單例模式：
public class Singleton {  
  
    /* 私有構造方法，防止被實例化 */  
    private Singleton() {  
    }  
  
    /* 此處使用一個內部類來維護單例 */  
    private static class SingletonFactory {  
        private static Singleton instance = new Singleton();  
    }  
  
    /* 獲取實例 */  
    public static Singleton getInstance() {  
        return SingletonFactory.instance;  
    }  
  
    /* 如果該對象被用于序列化，可以保證對象在序列化前后保持一致 */  
    public Object readResolve() {  
        return getInstance();  
    }  
}  

也有人這樣實現：因為我們只需要在創建類的時候進行同步，所以只要將
創建和getInstance()分開，單獨為創建加synchronized關鍵字，也是可以
的：
public class SingletonTest {  
  
    private static SingletonTest instance = null;  
  
    private SingletonTest() {  
    }  
  
    private static synchronized void syncInit() {  
        if (instance == null) {  
            instance = new SingletonTest();  
        }  
    }  
  
    public static SingletonTest getInstance() {  
        if (instance == null) {  
            syncInit();  
        }  
        return instance;  
    }  
}  

補充：采用"影子實例"的辦法為單例對象的屬性同步更新

public class SingletonTest {  
  
    private static SingletonTest instance = null;  
    private Vector properties = null;  
  
    public Vector getProperties() {  
        return properties;  
    }  
  
    private SingletonTest() {  
    }  
  
    private static synchronized void syncInit() {  
        if (instance == null) {  
            instance = new SingletonTest();  
        }  
    }  
  
    public static SingletonTest getInstance() {  
        if (instance == null) {  
            syncInit();  
        }  
        return instance;  
    }  
  
    public void updateProperties() {  
        SingletonTest shadow = new SingletonTest();  
        properties = shadow.getProperties();  
    }  
}  

4、建造者模式

建造者模式是將一個復雜的對象，與它的屬性分離，使用同樣的構建方式，可以產生不同的對象。
示例代碼：

復雜的對象：
public class Person {
 
    private String head;
    private String body;
    private String foot;
 
    public String getHead() {
        return head;
    }
 
    public void setHead(String head) {
        this.head = head;
    }
 
    public String getBody() {
        return body;
    }
 
    public void setBody(String body) {
        this.body = body;
    }
 
    public String getFoot() {
        return foot;
    }
 
    public void setFoot(String foot) {
        this.foot = foot;
    }
}

建造方式的接口：
public interface PersonBuilder {
    void buildHead();
    void buildBody();
    void buildFoot();
    Person buildPerson();
}

建造方式：
public class ManBuilder implements PersonBuilder {
 
    Person person;
 
    public ManBuilder() {
        person = new Person();
    }
 
    public void buildBody() {
        person.setBody("建造男人的身體");
    }
 
    public void buildFoot() {
        person.setFoot("建造男人的腳");
    }
 
    public void buildHead() {
        person.setHead("建造男人的頭");
    }
 
    public Person buildPerson() {
        return person;
    }
}

建造者：
public class PersonDirector {
    public Person constructPerson(PersonBuilder pb) {
        pb.buildHead();
        pb.buildBody();
        pb.buildFoot();
        return pb.buildPerson();
    }
}

測試代碼：
public class Test {
    public static void main(String[] args) {
        PersonDirector pd = new PersonDirector();
        Person person = pd.constructPerson(new ManBuilder());
        System.out.println(person.getBody());
        System.out.println(person.getFoot());
        System.out.println(person.getHead());
    }
}

建造者模式：是將一個復雜的對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示。

5、原型模式

原型模式將一個對象作為原型，對其進行復制、克隆，產生一個和原對象類似的新對象。在Java中，復制對象是通過clone()實現的。
示例代碼：

先創建一個原型類：
public class Prototype implements Cloneable {  
  
    public Object clone() throws CloneNotSupportedException {  
        Prototype proto = (Prototype) super.clone();  
        return proto;  
    }  
}  

一個原型類，只需要實現Cloneable接口，覆寫clone方法，此處clone方法可以改成任意的名稱，因為Cloneable接口是個空接口，你可以任意定義實現類的方法名，如cloneA或者cloneB，因為此處的重點是super.clone()這句話，super.clone()調用的是Object的clone()方法，而在Object類中，clone()是native的。
對象的復制分為淺復制和深復制：
淺復制：將一個對象復制后，基本數據類型的變量都會重新創建，而引用類型，指向的還是原對象所指向的。
深復制：將一個對象復制后，不論是基本數據類型還有引用類型，都是重新創建的。簡單來說，就是深復制進行了完全徹底的復制，而淺復制不徹底。
深淺復制示例代碼：

public class Prototype implements Cloneable, Serializable {  
  
    private static final long serialVersionUID = 1L;  
    private String string;  
  
    private SerializableObject obj;  
  
    /* 淺復制 */  
    public Object clone() throws CloneNotSupportedException {  
        Prototype proto = (Prototype) super.clone();  
        return proto;  
    }  
  
    /* 深復制 */  
    public Object deepClone() throws IOException, ClassNotFoundException {  
  
        /* 寫入當前對象的二進制流 */  
        ByteArrayOutputStream bos = new ByteArrayOutputStream();  
        ObjectOutputStream oos = new ObjectOutputStream(bos);  
        oos.writeObject(this);  
  
        /* 讀出二進制流產生的新對象 */  
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());  
        ObjectInputStream ois = new ObjectInputStream(bis);  
        return ois.readObject();  
    }  
  
    public String getString() {  
        return string;  
    }  
  
    public void setString(String string) {  
        this.string = string;  
    }  
  
    public SerializableObject getObj() {  
        return obj;  
    }  
  
    public void setObj(SerializableObject obj) {  
        this.obj = obj;  
    }  
  
}  
  
class SerializableObject implements Serializable {  
    private static final long serialVersionUID = 1L;  
}  

要實現深復制，需要采用流的形式讀入當前對象的二進制輸入，再寫出二進制數據對應的對象。

6、適配器模式

適配器模式主要分為三類：類的適配器模式、對象的適配器模式、接口的適配器模式。
適配器模式將某個類的接口轉換成我們期望的另一個接口表示，目的是消除由于接口不匹配所造成的類的兼容性問題。

6.1類的適配器模式

類的適配器模式核心思想就是：有一個Source類，擁有一個方法，待適配；目標接口是Targetable；通過Adapter類，將Source的功能擴展到Targetable里。
示例代碼：

public class Source {
    public void method1() {  
        System.out.println("this is original method!");  
    }  
}

public interface Targetable {
    /* 與原類中的方法相同 */
    public void method1();

    /* 新類的方法 */
    public void method2();
}

public class Adapter extends Source implements Targetable {
    public void method2() {
        System.out.println("this is the targetable method!");
    }
}

測試類：
public class AdapterTest {
    public static void main(String[] args) {
        Targetable target = new Adapter();
        target.method1();
        target.method2();
    }
}

6.2對象的適配器模式

對象的適配器模式的基本思路和類的適配器模式相同，只是將Adapter類作修改成Wrapper，這次不繼承Source類，而是持有Source類的實例，以達到解決兼容性的問題。
示例代碼：

public class Wrapper implements Targetable {

    private Source source;

    public Wrapper(Source source) {
        super();
        this.source = source;
    }

    @Override
    public void method2() {
        System.out.println("this is the targetable method!");
    }

    @Override
    public void method1() {
        source.method1();
    }
}

測試代碼：
public class AdapterTest {
    public static void main(String[] args) {
        Source source = new Source();
        Targetable target = new Wrapper(source);
        target.method1();
        target.method2();
    }
}

6.3接口的適配器模式

有時我們寫的一個接口中有多個抽象方法，當我們寫該接口的實現類時，必須實現該接口的所有方法，這明顯有時比較浪費，因為并不是所有的方法都是我們需要的，有時只需要某一些，此處為了解決這個問題，我們引入了接口的適配器模式，借助于一個抽象類，該抽象類實現了該接口，實現了所有的方法，而我們不和原始的接口打交道，只和該抽象類取得聯系，所以我們寫一個類，繼承該抽象類，重寫我們需要的方法就行了。

7、橋接模式

橋梁模式的用意是”將抽象化(Abstraction)與實現化(Implementation)脫耦，使得二者可以獨立地變化”。
抽象化：存在于多個實體中的共同的概念性聯系，就是抽象化。作為一個過程，抽象化就是忽略一些信息，從而把不同的實體當做同樣的實體對待。
實現化：抽象化給出的具體實現，就是實現化。
脫耦：所謂耦合，就是兩個實體的行為的某種強關聯。而將它們的強關聯去掉，就是耦合的解脫，或稱脫耦。在這里，脫耦是指將抽象化和實現化之間的耦合解脫開，或者說是將它們之間的強關聯改換成弱關聯。
示例代碼：

實體接口：
public interface Driver {  
    public void connect();  
} 
實體類：
public class MysqlDriver implements Driver {

    @Override
    public void connect() {
        System.out.println("connect mysql done!");
    }
}
實體類：
public class DB2Driver implements Driver {

    @Override
    public void connect() {
        System.out.println("connect db2 done!");
    }
}

抽象化：
public abstract class DriverManager {

    private Driver driver;


    public void connect() {
        driver.connect();
    }

    public Driver getDriver() {
        return driver;
    }

    public void setDriver(Driver driver) {
        this.driver = driver;
    }
}

實現化：
public class MyDriverManager extends DriverManager {

    public void connect() {
        super.connect();
    }
}

測試代碼：
public class Client {

    public static void main(String[] args) {

        DriverManager driverManager = new MyDriverManager();
        Driver driver1 = new MysqlDriver();
        driverManager.setDriver(driver1);
        driverManager.connect();

        Driver driver2 = new DB2Driver();
        driverManager.setDriver(driver2);
        driverManager.connect();

    }
}

8、裝飾模式

在不必改變原類文件和使用繼承的情況下，動態地擴展一個對象的功能。它是通過創建一個包裝對象，也就是裝飾來包裹真實的對象。

裝飾模式的特點：
（1） 裝飾對象和真實對象有相同的接口。這樣客戶端對象就能以和真實對象相同的方式和裝飾對象交互。
（2） 裝飾對象包含一個真實對象的引用（reference）
（3） 裝飾對象接受所有來自客戶端的請求。它把這些請求轉發給真實的對象。
（4） 裝飾對象可以在轉發這些請求以前或以后增加一些附加功能。這樣就確保了在運行時，不用修改給定對象的結構就可以在外部增加附加的功能。在面向對象的設計中，通常是通過繼承來實現對給定類的功能擴展。繼承不能做到這一點，繼承的功能是靜態的，不能動態增刪。

示例代碼：

實體接口：
public interface Sourceable {
    public void method();
}
實體類：
public class Source implements Sourceable {

    @Override
    public void method() {
        System.out.println("the original method!");
    }
}
裝飾類：
public class Decorator implements Sourceable {

    private Sourceable source;

    public Decorator(Sourceable source) {
        super();
        this.source = source;
    }

    @Override
    public void method() {
        System.out.println("before decorator!");
        source.method();
        System.out.println("after decorator!");
    }
}

測試類：
public class DecoratorTest {

    public static void main(String[] args) {
        //（1） 裝飾對象和真實對象有相同的接口。這樣客戶端對象就能以和真實對象相同的方式和裝飾對象交互。
        //（2） 裝飾對象包含一個真實對象的引用（reference）
        //（3） 裝飾對象接受所有來自客戶端的請求。它把這些請求轉發給真實的對象。
        //（4） 裝飾對象可以在轉發這些請求以前或以后增加一些附加功能。這樣就確保了在運行時，不用修改給定對象的結構就可以在外部增加附加的功能。
        //    在面向對象的設計中，通常是通過繼承來實現對給定類的功能擴展。
        //    繼承不能做到這一點，繼承的功能是靜態的，不能動態增刪。
        Sourceable source = new Source();
        Sourceable obj = new Decorator(source);
        obj.method();
    }
}

9、代理模式

代理模式就是多一個代理類出來，替原對象進行一些操作。代理類就像中介，它比我們掌握著更多的信息。
示例代碼：

實體接口：
public interface Sourceable {
    public void method();
}
實體類：
public class Source implements Sourceable {

    @Override
    public void method() {
        System.out.println("the original method!");
    }
}
代理類：
public class Proxy implements Sourceable {

    private Source source;

    public Proxy() {
        super();
        this.source = new Source();
    }

    @Override
    public void method() {
        before();
        source.method();
        atfer();
    }

    private void atfer() {
        System.out.println("after proxy!");
    }

    private void before() {
        System.out.println("before proxy!");
    }
}
測試代碼：
public class ProxyTest {

    public static void main(String[] args) {
        Sourceable source = new Proxy();
        source.method();
    }
}

10、外觀模式

外觀模式是為了解決類與類之間的依賴關系的，像spring一樣，可以將類和類之間的關系配置到配置文件中，而外觀模式就是將他們的關系放在一個Facade類中，降低了類類之間的耦合度，該模式中沒有涉及到接口。
示例代碼：

實體類：
public class CPU {

    public void startup() {
        System.out.println("cpu startup!");
    }

    public void shutdown() {
        System.out.println("cpu shutdown!");
    }
}
實體類：
public class Disk {

    public void startup() {
        System.out.println("disk startup!");
    }

    public void shutdown() {
        System.out.println("disk shutdown!");
    }
}
實體類：
public class Memory {

    public void startup() {
        System.out.println("memory startup!");
    }

    public void shutdown() {
        System.out.println("memory shutdown!");
    }
}
外觀類：
public class Computer {

    private CPU cpu;
    private Memory memory;
    private Disk disk;

    public Computer() {
        cpu = new CPU();
        memory = new Memory();
        disk = new Disk();
    }

    public void startup() {
        System.out.println("start the computer!");
        cpu.startup();
        memory.startup();
        disk.startup();
        System.out.println("start computer finished!");
    }

    public void shutdown() {
        System.out.println("begin to close the computer!");
        cpu.shutdown();
        memory.shutdown();
        disk.shutdown();
        System.out.println("computer closed!");
    }
}

測試類：
public class User {

    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.startup();
        computer.shutdown();
    }
}

11、組合模式

將對象組合成樹形結構以表示“部分-整體”的層次結構，組合模式使得用戶對單個對象和組合對象的使用具有一致性。掌握組合模式的重點是要理解清楚 “部分/整體” 還有 ”單個對象“ 與 “組合對象” 的含義。
示例代碼：

組件抽象類：
public abstract class Company {

    private String name;

    public Company() {
    }

    public Company(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    protected abstract void add(Company company);

    protected abstract void romove(Company company);

    protected abstract void display(int depth);

}
樹干實體類：（用于存儲子部件）
public class ConcreteCompany extends Company {

    private List<Company> cList;

    public ConcreteCompany() {
        cList = new ArrayList();
    }

    public ConcreteCompany(String name) {
        super(name);
        cList = new ArrayList();
    }

    @Override
    protected void add(Company company) {
        cList.add(company);
    }

    @Override
    protected void display(int depth) {

        StringBuilder sb = new StringBuilder("");
        for (int i = 0; i < depth; i++) {
            sb.append("-");
        }
        System.out.println(new String(sb) + this.getName());
        for (Company c : cList) {
            c.display(depth + 2);
        }
    }

    @Override
    protected void romove(Company company) {
        cList.remove(company);
    }
}
子部件實體類：
public class HRDepartment extends Company {
    public HRDepartment(String name) {
        super(name);
    }

    @Override
    protected void add(Company company) {
    }

    @Override
    protected void display(int depth) {
        StringBuilder sb = new StringBuilder("");
        for (int i = 0; i < depth; i++) {
            sb.append("-");
        }
        System.out.println(new String(sb) + this.getName());
    }

    @Override
    protected void romove(Company company) {
    }
}
子部件實體類：
public class FinanceDepartment extends Company {
    public FinanceDepartment(String name) {
        super(name);
    }

    @Override
    protected void add(Company company) {
    }

    @Override
    protected void display(int depth) {
        StringBuilder sb = new StringBuilder("");
        for (int i = 0; i < depth; i++) {
            sb.append("-");
        }
        System.out.println(new String(sb) + this.getName());
    }

    @Override
    protected void romove(Company company) {
    }
}

測試類：
public class Client {
    public static void main(String[] args) {
        Company root = new ConcreteCompany();
        root.setName("北京總公司");
        root.add(new HRDepartment("總公司人力資源部"));
        root.add(new FinanceDepartment("總公司財務部"));
        Company shandongCom = new ConcreteCompany("山東分公司");
        shandongCom.add(new HRDepartment("山東分公司人力資源部"));
        shandongCom.add(new FinanceDepartment("山東分公司賬務部"));
        Company zaozhuangCom = new ConcreteCompany("棗莊辦事處");
        zaozhuangCom.add(new FinanceDepartment("棗莊辦事處財務部"));
        zaozhuangCom.add(new HRDepartment("棗莊辦事處人力資源部"));
        Company jinanCom = new ConcreteCompany("濟南辦事處");
        jinanCom.add(new FinanceDepartment("濟南辦事處財務部"));
        jinanCom.add(new HRDepartment("濟南辦事處人力資源部"));
        shandongCom.add(jinanCom);
        shandongCom.add(zaozhuangCom);
        Company huadongCom = new ConcreteCompany("上海華東分公司");
        huadongCom.add(new HRDepartment("上海華東分公司人力資源部"));
        huadongCom.add(new FinanceDepartment("上海華東分公司賬務部"));
        Company hangzhouCom = new ConcreteCompany("杭州辦事處");
        hangzhouCom.add(new FinanceDepartment("杭州辦事處財務部"));
        hangzhouCom.add(new HRDepartment("杭州辦事處人力資源部"));
        Company nanjingCom = new ConcreteCompany("南京辦事處");
        nanjingCom.add(new FinanceDepartment("南京辦事處財務部"));
        nanjingCom.add(new HRDepartment("南京辦事處人力資源部"));
        huadongCom.add(hangzhouCom);
        huadongCom.add(nanjingCom);
        root.add(shandongCom);
        root.add(huadongCom);
        root.display(0);
    }
}

12、享元模式

享元模式的主要目的是實現對象的共享，即共享池，當系統中對象多的時候可以減少內存的開銷，通常與工廠模式一起使用。
示例代碼：

java的JDBC連接池：
public class ConnectionPool {

    private Vector<Connection> pool;

    /* 公有屬性 */
    private String url = "jdbc:mysql://localhost:3306/test";
    private String username = "root";
    private String password = "root";
    private String driverClassName = "com.mysql.jdbc.Driver";

    private int poolSize = 100;
    private static ConnectionPool instance = null;
    Connection conn = null;

    /* 構造方法，做一些初始化工作 */
    private ConnectionPool() {
        pool = new Vector<Connection>(poolSize);

        for (int i = 0; i < poolSize; i++) {
            try {
                Class.forName(driverClassName);
                conn = DriverManager.getConnection(url, username, password);
                pool.add(conn);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /* 返回連接到連接池 */
    public synchronized void release() {
        pool.add(conn);
    }

    /* 返回連接池中的一個數據庫連接 */
    public synchronized Connection getConnection() {
        if (pool.size() > 0) {
            Connection conn = pool.get(0);
            pool.remove(conn);
            return conn;
        } else {
            return null;
        }
    }
}