這篇文章講述的是java設計模式，包括單例模式、工廠模式、代理模式，如有錯誤或不當之處，希望各位大神批評指正。

什麼是設計模式？

• 設計模式：是指在大量的理論和實踐中總結和理論化之後，優選的程式碼結構、程式設計風格、以及解決問題的思考模式。正如數學中的公式的使用一樣。

• 包括：

  1. 單例模式
  2. 模板模式
  3. 工廠模式
  4. 代理模式
  5. 等等…

單例模式

什麼是單例模式？

單例模式是指，採用某種手段或者方法，保證整個軟體系統中只能存在一個物件的例項，並且該例項只提供建立該物件的方法。

使用情況及優缺點

• 使用情況：當您想控制例項數目，節省系統資源的時候，和一個全域性使用的類頻繁地建立與銷燬的時候
• 優點：節省系統資源的開銷，避免記憶體的重複使用
• 缺點：沒有介面，不能繼承

單例模式的例子

餓漢式

package com.cn.cmc.javadesignstyle;

public class SingletonDemo {
    //獲取一個單例的例項
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance() ;
        Singleton singleton2 = Singleton.getInstance() ;
        System.out.println(singleton1 == singleton2);

        singleton1.claim();
    }
}
/**
 * 單例模式：程式執行中只能存在一個物件的例項
 * 
 * 設計步驟：1. 將構造器私有化，保證外部不能建立
 *          2. 初始化例項
 *          3. 私有化例項，向外界提供一個返回例項的介面
 *          4. 次公共方法必須通過類來呼叫static
 */
 

class Singleton{

    //將構造器私有化
    private Singleton(){

    }
    //在內部初始化一個例項
    //惡漢模式：在初始化類的時候直接例項化物件
    private static Singleton singleton = new Singleton() ;
    //懶漢模式：初始化時候不新建物件，在具體用到的時候在例項化
    private static Singleton singleton2 = null ;
    //向外部提供一個返回例項方法
    //餓漢
    public static Singleton getInstance
 
() {
        return singleton;
    }
}

懶漢式

package com.cn.cmc.javadesignstyle;

public class SingletonDemo {
    //獲取一個單例的例項
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance() ;
        Singleton singleton2 = Singleton.getInstance() ;
        System.out.println(singleton1 == singleton2);

        singleton1.claim();
    }
}
/**
 * 單例模式：程式執行中只能存在一個物件的例項
 * 
 * 設計步驟：1. 將構造器私有化，保證外部不能建立
 *          2. 初始化例項
 *          3. 私有化例項，向外界提供一個返回例項的介面
 *          4. 次公共方法必須通過類來呼叫static
 */
class Singleton{

    //將構造器私有化
    private Singleton(){

    }
    //在內部初始化一個例項
    //懶漢模式：初始化時候不新建物件，在具體用到的時候在例項化
    private static Singleton singleton2 = null ;
    //向外部提供一個返回例項方法
    public synchronized static Singleton getInstance2(){
        if(singleton2 == null){
            singleton2 = new Singleton() ;
        }
        return singleton2 ;
    }
}

注：使用懶漢模式時要注意執行緒安全問題，需要使用synchronized來控制進入建立例項方法的執行緒

靜態內部類式

package com.cn.cmc.javadesignstyle;

public class SingletonDemo {
    //獲取一個單例的例項
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance() ;
        Singleton singleton2 = Singleton.getInstance() ;
        System.out.println(singleton1 == singleton2);

    }
}
/**
 * 單例模式：程式執行中只能存在一個物件的例項
 * 
 * 設計步驟：1. 將構造器私有化，保證外部不能建立
 *          2. 初始化例項
 *          3. 私有化例項，向外界提供一個返回例項的介面
 *          4. 次公共方法必須通過類來呼叫static
 */
class Singleton{

    //將構造器私有化
    private Singleton(){

    }
    //靜態內部類方式,在第一次使用時才會載入
    private static class SingletonClassInstance{
        private static final Singleton instance = new Singleton() ;
    }
    public static Singleton getInstance(){
        return SingletonClassInstance.instance ;
    }
}

列舉式

package com.cn.cmc.javadesignstyle;

public class SingletonDemo {
    //獲取一個單例的例項
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.INSTANCE ;
        Singleton singleton2 = Singleton.INSTANCE ;
        System.out.println(singleton1 == singleton2);

    }
}
/**
 * 單例模式：程式執行中只能存在一個物件的例項
 * 
 * 設計步驟：1. 將構造器私有化，保證外部不能建立
 *          2. 初始化例項
 *          3. 私有化例項，向外界提供一個返回例項的介面
 *          4. 次公共方法必須通過類來呼叫static
 */
enum Singleton{

    //列舉類本身就是單例
    INSTANCE ;

    //相關操作
    public void operator(){
        System.out.println("操作...");
    }
}

單例模式總結

• 餓漢式自身執行緒安全，呼叫高效但不支援延遲載入
• 懶漢式需要synchronized保證執行緒安全，支援懶載入但呼叫低效
• 靜態內部類方式自身執行緒安全，支援懶載入且效率高效

• 列舉式自身執行緒安全，編寫方便效率高效但不支援懶載入

• 選用時：若佔用資源少，不需要懶載入，列舉式好於餓漢式
  若佔用資源多，需要懶載入時，靜態內部類式要好於懶漢式

模板模式

什麼是模板模式

在模板模式（Template Pattern）中，一個抽象類公開定義了執行它的方法的方式/模板。它的子類可以按需要重寫方法實現，但呼叫將以抽象類中定義的方式進行。這種型別的設計模式屬於行為型模式。

使用情況及優缺點

• 使用情況：一些方法通用，卻在每一個子類都重新寫了這一方法。
• 優點： 封裝不變部分，擴充套件可變部分。 提取公共程式碼，便於維護。 行為由父類控制，子類實現。
• 缺點：每一個不同的實現都需要一個子類來實現，導致類的個數增加，使得系統更加龐大。

模板模式的例子

package com.cn.cmc.javadesignstyle;

/**
 * 模板模式：父類只規定有什麼通用方法，具體的實現交給子類來執行
 * 
 * 設計步驟：1. 將父類定義為抽象類
 *          2. 將父類的方法定義為抽象方法
 *          3.子類在繼承父類時實現具體的方法
 */

//將父類定義為抽象類
abstract class Template{
    //將父類中的方法定義為抽象方法
    abstract void begin() ;
    abstract void say() ;
    abstract void end() ;
}

//子類在繼承模板類時實現具體的方法
class Cat extends Template{
    void begin() {
        System.out.println("我是一隻貓");
    }
    void say() {
        System.out.println("喵喵喵~");
    }
    void end() {
        System.out.println("說完了");
    }   
}
class Dog extends Template{
    void begin() {
        System.out.println("我是一隻狗");
    }
    void say() {
        System.out.println("汪汪汪！");
    }
    void end() {
        System.out.println("說完了");
    }   
}

public class TemplatePattern {
    public static void main(String[] args) {
        //建立實現模板方法的類
        Cat cat = new Cat() ;
        Dog dog = new Dog() ;

        cat.begin();
        cat.say();
        cat.end();
        dog.begin();
        dog.say();
        dog.end();
    }
}

工廠模式

什麼是工廠模式？

工廠模式（Factory Pattern）是 Java 中最常用的設計模式之一。這種型別的設計模式屬於建立型模式，它提供了一種建立物件的最佳方式。

使用情況及優缺點

• 使用情況：定義一個建立物件的介面，讓其子類自己決定例項化哪一個工廠類，工廠模式使其建立過程延遲到子類進行。
• 優點：一個呼叫者想建立一個物件，只要知道其名稱就可以了。 擴充套件性高，如果想增加一個產品，只要擴充套件一個工廠類就可以。 遮蔽產品的具體實現，呼叫者只關心產品的介面。
• 缺點：每次增加一個產品時，都需要增加一個具體類和物件實現工廠，使得系統中類的個數成倍增加，在一定程度上增加了系統的複雜度，同時也增加了系統具體類的依賴。

工廠模式的例子

簡單工廠模式

package com.cn.cmc.singleton;

/**
 * 工廠模式：定義一個建立類的介面，並讓其子類決定實現哪個工廠類，使建立者和呼叫者分離
 * 簡單工廠模式：對於同一等級結構的任一產品，對於新增加的產品需要修改已有程式碼
 * 工廠方法模式：用來生產同一等級結構中的任一產品，對於新增加的產品支援
 * 抽象工廠模式：用來生產不同產品族的全部產品
 * 
 * 設計步驟：1.定義工廠類
 *          2.定義建立類的介面
 */
/*工廠類*/
class AnimalFactory {
    //工廠介面中只寫獲取類的方法
    public static Sheep createSheep(){
        return new Sheep() ;
    }
    public static Cow createCow(){
        return new Cow() ;
    }
}

/*介面類*/
interface Animal {
    public void cry() ;
}
/*實現類*/
class Cow implements Animal{

    public void cry() {
        System.out.println("哞哞哞~");
    }
}
class Sheep implements Animal{
    public void cry(){
        System.out.println("咩咩咩~");
    }
} 

public class SimpleFactory {
    public static void main(String[] args) {
        //工廠模式建立物件
        Sheep sheep = AnimalFactory.createSheep() ;
        Cow cow = AnimalFactory.createCow() ;
        sheep.cry();
        cow.cry();

    }
}

工廠方法模式

package com.cn.cmc.factory;

/**
 * 工廠模式：定義一個建立類的介面，並讓其子類決定實現哪個工廠類，使建立者和呼叫者分離
 * 簡單工廠模式：對於同一等級結構的任一產品，對於新增加的產品需要修改已有程式碼
 * 工廠方法模式：用來生產同一等級結構中的任一產品，對於新增加的產品支援
 * 抽象工廠模式：用來生產不同產品族的全部產品
 * 
 * 設計步驟：1.定義工廠類
 *          2.定義建立類的介面
 */
/*工廠類*/
class AnimalFactory {
    //工廠介面中只寫獲取類的方法
    public static Sheep createSheep(){
        return new Sheep() ;
    }
    public static Cow createCow(){
        return new Cow() ;
    }
}

/*介面類*/
interface Animal {
    public void cry() ;
}
/*實現類*/
class Cow implements Animal{

    public void cry() {
        System.out.println("哞哞哞~");
    }
}
class Sheep implements Animal{
    public void cry(){
        System.out.println("咩咩咩~");
    }
} 

public class SimpleFactory {
    public static void main(String[] args) {
        //工廠模式建立物件
        Sheep sheep = AnimalFactory.createSheep() ;
        Cow cow = AnimalFactory.createCow() ;
        sheep.cry();
        cow.cry();

    }
}

抽象工廠模式

package com.cn.cmc.factory;

public class AbstractFactory {
    /**
     * 抽象工廠模式：提供一個建立一系列相關或相互依賴物件的介面，而無需指定它們具體的類。
     *              系統的產品有多於一個的產品族，而系統只消費其中某一族的產品時使用。
     */
    public static void main(String[] args) {
        Engine e = new LuxuryCarFactory().createEngine() ;
        Tyre t = new LuxuryCarFactory().createTyre() ;
        Seat s = new LuxuryCarFactory().createSeat() ;
        e.run();
        e.start();
        t.revolve();
        s.feel();
    }
}

/*高階車生產工廠*/
class LuxuryCarFactory implements CarFactory{

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }

    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }
}

/*低端車生產工廠*/
class LowCarFactory implements CarFactory{

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }

    @Override
    public Engine createEngine() {
        return new LowEngine();
    }
}


/*汽車抽象工廠類*/
interface CarFactory{
    Seat createSeat() ;
    Tyre createTyre() ;
    Engine createEngine() ;
}

/*座椅介面*/
interface Seat{
    void feel() ;
}
/*座椅實現類-高階*/
class LuxurySeat implements Seat{

    @Override
    public void feel() {
        System.out.println("高階座椅十分舒適");
    }
}
/*座椅實現類-低端*/
class LowSeat implements Seat{

    @Override
    public void feel() {
        System.out.println("低端座椅不舒服");
    }
}

/*輪胎介面*/
interface Tyre{
    void revolve() ;
}
/*輪胎實現類-高階輪胎*/
class LuxuryTyre implements Tyre{

    @Override
    public void revolve() {
        System.out.println("高階輪胎不易磨損");
    }
}
/*輪胎實現類-低端輪胎*/
class LowTyre implements Tyre{

    @Override
    public void revolve() {
        System.out.println("低端輪胎易磨損");
    }
}

/*引擎介面*/
interface Engine {
    void run() ;
    void start() ;
}
/*引擎實現類-高階*/
class LuxuryEngine implements Engine{

    @Override
    public void run() {
        System.out.println("高階引擎馬力大");
    }

    @Override
    public void start() {
        System.out.println("高階引擎轉速快");
    }
}
/*引擎實現類-低端*/
class LowEngine implements Engine{

    @Override
    public void run() {
        System.out.println("低端引擎馬力小");
    }

    @Override
    public void start() {
        System.out.println("低端引擎轉速慢");
    }

}

工廠模式之間的對比

• 簡單靜態工廠模式：雖然不符合設計原則，但用的最多
• 工廠方法模式：可以通過不修改原有類的前提下實現對類的擴充套件
• 抽象工廠模式：不可以增加單個產品，但可以增加產品族，大專案用的多

代理模式

什麼是代理模式

為其他物件提供一種代理以控制對這個物件的訪問。

使用情況及優缺點

• 使用情況：想在訪問一個類時做一些控制。如安全代理，遠端載入，延遲載入
• 優點：職責清晰、高擴充套件性、智慧化。
• 缺點：由於在客戶端和真實主題之間增加了代理物件，因此有些型別的代理模式可能會造成請求的處理速度變慢。而且實現代理模式需要額外的工作，有些代理模式的實現非常複雜。

代理模式的例子

靜態代理

• 模擬客戶找代理買手機

package com.cn.cmc.proxy;

public class StaticProxy {
    public static void main(String[] args) {
        //模擬客戶找代理買一臺蘋果手機
        IPhone iphone = new IPhone() ;
        PhoneProxy phoneproxy = new PhoneProxy(iphone) ;

        phoneproxy.look();
        phoneproxy.tryout();
        phoneproxy.consult();
        phoneproxy.buy();
        phoneproxy.bill();
    }
}

/*手機介面*/
interface Phone {
    public void look();
    public void tryout();
    public void consult() ;
    public void buy() ;
    public void bill() ;
}

/*手機代理類*/
class PhoneProxy implements Phone{

    private Phone phone ;

    public PhoneProxy(Phone phone) {
        super();
        this.phone = phone;
    }

    @Override
    public void look() {
        System.out.println("代理看手機");
    }

    @Override
    public void tryout() {
        System.out.println("代理試用手機");
    }

    @Override
    public void consult() {
        System.out.println("代理諮詢手機效能");
    }

    @Override
    public void buy() {
        phone.buy();
    }

    @Override
    public void bill() {
        System.out.println("代理要發票");
    }
}

/*手機類*/

class IPhone implements Phone {

    @Override
    public void look() {
        System.out.println("蘋果店裡看手機");
    }

    @Override
    public void tryout() {
        System.out.println("蘋果店裡試用手機");
    }

    @Override
    public void consult() {
        System.out.println("蘋果店裡諮詢手機");
    }

    @Override
    public void buy() {
        System.out.println("蘋果店裡買手機");
    }

    @Override
    public void bill() {
        System.out.println("蘋果店裡要發票");
    }

}

動態代理

package com.cn.cmc.proxy;

import java.awt.PageAttributes;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class JDKDynamicProxy {
    public static void main(String[] args) {
        Phone iphone = new IPhone() ;

        PhoneHandler phonehandler = new PhoneHandler(iphone) ;  
        /*建立一個代理
         * classloader：類載入器
         * class[]：要代理的Class陣列
         * handler:代理要實現的Handler
         * */
        Phone proxy = (Phone) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Phone.class}, phonehandler) ;

        proxy.buy();

    }
}

/*手機代理類*/
class PhoneHandler implements InvocationHandler{

    Phone phone ;

    public PhoneHandler(Phone phone) {
        super();
        this.phone = phone;
    }

    /**
     * invoke為呼叫真正的方法
     * proxy：為在其上呼叫方法的代理例項
     * method：對應於在代理例項上呼叫的介面方法的 Method 例項
     * args：包含傳入代理例項上方法呼叫的引數值的物件陣列
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理開始買手機");

        if(method.getName().equals("look")){
            phone.look();
        }else if(method.getName().equals("tryout")){
            phone.tryout();
        }else if(method.getName().equals("consult")){
            phone.consult();
        }else if(method.getName().equals("buy")){
            phone.buy();
        }else if(method.getName().equals("bill")){
            phone.bill();
        }else{
            System.out.println("沒有此方法");
        }
        System.out.println("代理買手機結束");

        return null;
    }

}

/*手機介面*/
interface Phone {
    public void look();
    public void tryout();
    public void consult() ;
    public void buy() ;
    public void bill() ;
}

/*手機類*/

class IPhone implements Phone {

    @Override
    public void look() {
        System.out.println("蘋果店裡看手機");
    }

    @Override
    public void tryout() {
        System.out.println("蘋果店裡試用手機");
    }

    @Override
    public void consult() {
        System.out.println("蘋果店裡諮詢手機");
    }

    @Override
    public void buy() {
        System.out.println("蘋果店裡買手機");
    }

    @Override
    public void bill() {
        System.out.println("蘋果店裡要發票");
    }

}