策略模式-觀察者模式-裝飾者模式-工廠模式-單例模式

算是最近學設計模式（HEAD FIRST設計模式）的一個總結吧，力求用最精簡的代碼說明其設計本質。

第一個模式：策略模式

代碼：

interface refuel {
    public void fuelUp();
}


class car {
    refuel fuelType;

    public void setFuelType(refuel type) {
        this.fuelType = type;
    }

    public void fuelUp() {
        fuelType.fuelUp();
    }

}


class fuelUpWith_93 implements refuel {

    @Override
    public void fuelUp() {
        System.out.println("Fueled up with No.93 gasoline");
    }

}


class fuelUpWith_97 implements refuel {

    @Override
    public void fuelUp() {
        System.out.println("Fueled up with No.97 gasoline");
    }

}

說明：汽車都需要加油，但是不同汽車加不同的油，通過讓汽車持有一個具體實現加油算法的對象（通常向上轉型為其接口），在汽車加油的時候直接調用這個接口，讓其自己實現這種汽車加油的相關算法。

設計思想：解耦合，這個設計模式最大的優點是：能保證復用所有相同的代碼（只要你的汽車持有了其使用的汽油類型），又能保證當你需要一種新的實現的時候可以快速加入進去（寫一種實現基礎接口的算法實現）而不需要修改原有代碼。

第二個設計模式：觀察者模式

代碼(JAVA內置實現)：

import java.util.Observable;
import java.util.Observer;

public class Main {

    public static void main(String[] args) {
        School highSchool = new School();
        Student Jack = new Student("Jack");
        Student Tom = new Student("Tom");
        Jack.register(highSchool);
        Tom.register(highSchool);
        highSchool.termBegins();
    }
}


class School extends Observable {

    public void termBegins() {
        this.setChanged();
        this.notifyObservers();
    }

}


class Student implements Observer {

    Observable o;
    String name;

    public Student(String name) {
        this.name = new String(name);
    }

    public void register(Observable o) {
        this.o = o;
        o.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof School) {
            System.out.println(name + " go to schoole");
        }
    }

}

代碼（手動實現）：

import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {
        Student Jack = new Student("Jack");
        Student Tom = new Student("Tom");
        School highSchool = new School();
        highSchool.register(Jack);
        highSchool.register(Tom);
        highSchool.termBegins();
    }
}


class School {

    ArrayList<Student> stuList = new ArrayList<Student>();

    public void register(Student stu) {
        stuList.add(stu);
    }

    public void termBegins() {
        this.notifyObservers();
        System.out.println("Welcome to school!");
    }

    private void notifyObservers() {
        for (Student stu : stuList) {
            stu.update();
        }
    }
}


class Student {

    String name;

    public Student(String name) {
        this.name = new String(name);
    }

    public void update() {
        System.out.println(name + " go to school");
    }

}

說明：把學生（觀察者）對象交給學校（被觀察者）。當學校開學時，一個一個去“通知”，讓其持有的學生對象作出對應的反應。

設計思想：當需要變化的時候通知觀察者們。Swing組件中大量用到（反應鼠標點擊消息等等）。其他沒啥很特別的東西。

第三個設計模式：裝飾者模式
代碼：

public class Main {

    public static void main(String[] args) {
        coffee myCoffee = new Mocha(new Milk(new regularCoffee()));
        System.out.println(myCoffee.getName());
    }
}


interface coffee {

    public int getCost();

    public String getName();

}


class regularCoffee implements coffee {

    @Override
    public int getCost() {
        return 5; // 最最普通的一杯咖啡底價5元
    }

    @Override
    public String getName() {
        return "咖啡"; // 最最普通的咖啡
    }

}


abstract class coffeeDecorator implements coffee {

    coffee oriCoffee;

}


class Milk extends coffeeDecorator { // 牛奶，加牛奶的修飾器

    public Milk(coffee c) {
        this.oriCoffee = c;
    }

    @Override
    public int getCost() {
        return oriCoffee.getCost() + 3; // 加一份牛奶再加3元
    }

    @Override
    public String getName() {
        return "牛奶" + oriCoffee.getName(); // 加一份牛奶的話，名字上也要加一份牛奶前綴
    }

}


class Mocha extends coffeeDecorator { // 摩卡，加巧克力的修飾器

    public Mocha(coffee c) {
        this.oriCoffee = c;
    }

    @Override
    public int getCost() {
        return oriCoffee.getCost() + 4; // 加一份巧克力再叫4元
    }

    @Override
    public String getName() {
        return "摩卡" + oriCoffee.getName(); // 加一份巧克力的話，名字也加一個前綴
    }

}

說明：每一次新建一個裝飾者（Mocha或者Milk或者你寫的別的什么），都依賴於一個傳入的參數（目前的咖啡），在這個基礎上繼續添加裝飾。

設計思想：一些類可能有自由組合的可能（比如咖啡），你很難一次把他們寫全（從設計上也不應該如此），於是便應該用裝飾者模式讓使用者自己去搭配。每一次經過修飾就在傳入參數的基礎上進行修改。

第四個設計模式：工廠模式

首先要說的是工廠模式這個名字讓人迷惑，因為很多模式好像都和工廠模式有關系：

1，靜態工廠模式 ： 一般是說用靜態方法寫的簡單工廠模式。

2，簡單工廠模式 ：就是一個類，里面封裝了某個類的構造方法，不僅調配構造參數，也許還有別的工作要做。

3，工廠方法模式 ：在工廠中定義一個創建對象的接口，但是讓子類去實現（通過Abstract）具體的創建過程。（和模板方法模式有點像）

4，抽象工廠模式 ：提供一個接口，用來創建相關或依賴對象的家族。

關於工廠方法模式和抽象工廠模式可以看：看這篇文章

 

第五個設計模式：單例模式
代碼（餓漢模式）：

class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton() {

    }

    public static Singleton getInstance() {
        return instance;
    }

}

 

說明：餓漢模式就是直接在類的靜態字段中寫上一個實例對象。由<clinit>方法自動在類加載結束的時候進行創建。JVM會保證類的加載線程安全，所以這種情況基本上不需要考慮多線程情況下的線程安全。但是問題還是有：生命周期不可以控制，這個類一加載就存在一個實例對象。

代碼（懶漢模式,雙重檢查模式+volatile）：

class Singleton {

    private volatile static Singleton instance;

    private Singleton() {

    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    return new Singleton();
                }
            }
        }
        return instance;
    }
}

說明：看這篇文章的說明

設計思想：很多類只需要有一個實例，也許只能有一個實例，當嘗試獲取多個實例時會返回相同一個實例對象（或者返回null或者報錯）。