常用設計模式說明

常用設計模式彙總

一、單例模式

簡言之，一個應用程序中，某個類的實例對象只有一個，你沒辦法去new，因爲構造器是被private修飾的，一般通過getInstance()的方法來獲取它們的實例。getInstance()的返回值是一個對象的引用，並不是一個新的實例，所以不要錯誤的理解成多個對象。

• 懶漢式（線程不安全）

public class Singleton {
 
 	private static Singleton singleton;

 	private Singleton() {}

 	public static Singleton getInstance() {
  		if (singleton == null) {
   			singleton = new Singleton();
  		}
  		return singleton;
 	}
}

• 懶漢式（線程安全）

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

• 餓漢式寫法

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

• 靜態內部類

public class Singleton {  
    private static class SingletonHolder {  
    	private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    	return SingletonHolder.INSTANCE;  
    }  
}  

• 枚舉

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {}  
} 

這種方式是Effective Java作者Josh Bloch提倡的方式，它不僅能避免多線程同步問題，而且還能防止反序列化重新創建新的對象。

• 雙重校驗鎖

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
    if (singleton == null) {  
        synchronized (Singleton.class) {  
        	if (singleton == null) {  
            	singleton = new Singleton();  
        	}  
        }  
    }  
    return singleton;  
    }  
} 

二、觀察者模式

對象間一對多的依賴關係，當一個對象的狀態發生改變時，所有依賴於它的對象都得到通知並被自動更新。


假設有三個人，小美（女，28），老王和老李。小美很漂亮，很風騷，老王和老李是兩個中年男屌絲，時刻關注着小美的一舉一動。有一天，小美說了一句：我老公今天不在家，一個人好無聊啊～～～，這句話被老王和老李聽到了，結果樂壞了，蹭蹭蹭，沒一會兒，老王就衝到小美家門口了，於是進門了……啪～嘿嘿嘿～~ 在這裏，小美是被觀察者，老王和老李是觀察者，被觀察者發出一條信息，然後觀察者們進行相應的處理，示例代碼：

public interface Person {
    //老王和老李通過這個接口可以接收到小美髮過來的消息
    void getMessage(String s);
}

這個接口相當於老王和老李的電話號碼，小美髮送通知的時候就會撥打getMessage()這個電話，撥打電話就是調用接口

// 老王
public class LaoWang implements Person {

    private String name = "老王";

    public LaoWang() {}

    @Override
    public void getMessage(String s) {
        System.out.println(name + "接到了小美打過來的電話，電話內容是：" + s);
    }

}

// 老李
public class LaoLi implements Person {

    private String name = "老李";

    public LaoLi() {}

    @Override
    public void getMessage(String s) {
        System.out.println(name + "接到了小美打過來的電話，電話內容是-->" + s);
    }

}

// 小美
public class XiaoMei {

    List<Person> list = new ArrayList<Person>();
     public XiaoMei(){}

     public void addPerson(Person person){
         list.add(person);
     }

     //遍歷list，把自己的通知發送給所有暗戀自己的人
     public void notifyPerson() {
         for(Person person:list){
             person.getMessage("今天家裏就我一個人，你們過來吧，誰先追到我我就跟誰嘿嘿嘿~");
         }
     }
}

// 測試代碼
public class Test {
    public static void main(String[] args) {
        XiaoMei xiaoMei = new XiaoMei();
        LaoWang laoWang = new LaoWang();
        LaoLi laoLi = new LaoLi();

        //老王和老李在小美那裏都註冊了一下
        xiaoMei.addPerson(laoWang);
        xiaoMei.addPerson(laoLi);

        //小美向老王和老李發送通知
        xiaoMei.notifyPerson();
    }
}

運行結果：

老王接到了小美打過來的電話，電話內容是：今天家裏就我一個人，你們過來吧，誰先追到我我就跟誰嘿嘿嘿~
老李接到了小美打過來的電話，電話內容是–>今天家裏就我一個人，你們過來吧，誰先追到我我就跟誰嘿嘿嘿~

三、裝飾者模式

對已有的業務邏輯進一步的封裝，使其增加額外的功能，如Java中的IO流就使用了裝飾者模式，用戶在使用的時候，可以任意組裝，達到自己想要的效果。
舉個栗子，我想喫漢堡，首先我需要一塊肉，我喜歡喫奶油，在肉片上面加一點奶油，再放一點蔬菜，最後再用兩片面包夾起來。那我們應該怎麼來寫代碼呢？ 首先，我們需要寫一個Food類，讓其他所有食物都來繼承這個類，看代碼：

public class Food {

    private String foodName;

    public Food() {
    }

    public Food(String foodName) {
        this.foodName = foodName;
    }

    public String make() {
        return foodName;
    };
}

然後我們寫幾個子類繼承它：

// 麪包類
public class Bread extends Food {

    private Food basicFood;

    public Bread(Food basicFood) {
        this.basicFood = basicFood;
    }

    public String make() {
        return basicFood.make()+" + 麪包";
    }
}

// 奶油類
public class Cream extends Food {

    private Food basicFood;

    public Cream(Food basicFood) {
        this.basicFood = basicFood;
    }

    public String make() {
        return basicFood.make()+" + 奶油";
    }
}

//蔬菜類
public class Vegetable extends Food {

    private Food basicFood;

    public Vegetable(Food basicFood) {
        this.basicFood = basicFood;
    }

    public String make() {
        return basicFood.make()+" + 蔬菜";
    }

}

這幾個類都是差不多的，構造方法傳入一個Food類型的參數，然後在make方法中加入一些自己的邏輯，如果你還是看不懂爲什麼這麼寫，不急，你看看我的Test類是怎麼寫的，一看你就明白了

public class Test {
    public static void main(String[] args) {
        Food food = new Bread(new Vegetable(new Cream(new Food("香腸"))));
        System.out.println(food.make());
    }
}

看到沒有，一層一層封裝，我們從裏往外看：最裏面我new了一個香腸，在香腸的外面我包裹了一層奶油，在奶油的外面我又加了一層蔬菜，最外面我放的是麪包，是不是很形象，哈哈這個設計模式簡直跟現實生活中一摸一樣，看懂了嗎？ 我們看看運行結果吧。

香腸 + 奶油 + 蔬菜 + 麪包

四、適配器模式

將兩種完全不同的事物聯繫到一起，舉個栗子，就像現實生活中的變壓器，假設一個手機充電器需要的電壓是20V，但是正常的電壓是220V，這時候就需要一個變壓器，將220V的電壓轉換成20V的電壓，這樣，變壓器就將20V的電壓和手機聯繫起來了。

public class Test {
    public static void main(String[] args) {
        Phone phone = new Phone();
        VoltageAdapter adapter = new VoltageAdapter();
        phone.setAdapter(adapter);
        phone.charge();
    }
}

// 手機類
class Phone {

    public static final int V = 220;// 正常電壓220v，是一個常量

    private VoltageAdapter adapter;

    // 充電
    public void charge() {
        adapter.changeVoltage();
    }

    public void setAdapter(VoltageAdapter adapter) {
        this.adapter = adapter;
    }
}

// 變壓器
class VoltageAdapter {
    // 改變電壓的功能
    public void changeVoltage() {
        System.out.println("正在充電...");
        System.out.println("原始電壓：" + Phone.V + "V");
        System.out.println("經過變壓器轉換之後的電壓：" + (Phone.V - 200) + "V");
    }
}

正在充電…
原始電壓：220V
經過變壓器轉換之後的電壓：20V

五、工廠模式

簡單工廠模式：一個抽象的接口，多個抽象接口的實現類，一個工廠類，用來實例化抽象的接口

// 抽象產品類
abstract class Car {
    public void run();

    public void stop();
}

// 具體實現類
class Benz implements Car {
    public void run() {
        System.out.println("Benz開始啓動了。。。。。");
    }

    public void stop() {
        System.out.println("Benz停車了。。。。。");
    }
}

class Ford implements Car {
    public void run() {
        System.out.println("Ford開始啓動了。。。");
    }

    public void stop() {
        System.out.println("Ford停車了。。。。");
    }
}

// 工廠類
class Factory {
    public static Car getCarInstance(String type) {
        Car c = null;
        if ("Benz".equals(type)) {
            c = new Benz();
        }
        if ("Ford".equals(type)) {
            c = new Ford();
        }
        return c;
    }
}

public class Test {

    public static void main(String[] args) {
        Car c = Factory.getCarInstance("Benz");
        if (c != null) {
            c.run();
            c.stop();
        } else {
            System.out.println("造不了這種汽車。。。");
        }

    }

}

工廠方法模式：有四個角色，抽象工廠模式，具體工廠模式，抽象產品模式，具體產品模式。不再是由一個工廠類去實例化具體的產品，而是由抽象工廠的子類去實例化產品。

// 抽象產品角色
public interface Moveable {
    void run();
}

// 具體產品角色
public class Plane implements Moveable {
    @Override
    public void run() {
        System.out.println("plane....");
    }
}

public class Broom implements Moveable {
    @Override
    public void run() {
        System.out.println("broom.....");
    }
}

// 抽象工廠
public abstract class VehicleFactory {
    abstract Moveable create();
}

// 具體工廠
public class PlaneFactory extends VehicleFactory {
    public Moveable create() {
        return new Plane();
    }
}

public class BroomFactory extends VehicleFactory {
    public Moveable create() {
        return new Broom();
    }
}

// 測試類
public class Test {
    public static void main(String[] args) {
        VehicleFactory factory = new BroomFactory();
        Moveable m = factory.create();
        m.run();
    }
}

抽象工廠模式：與工廠方法模式不同的是，工廠方法模式中的工廠只生產單一的產品，而抽象工廠模式中的工廠生產多個產品

//抽象工廠類
public abstract class AbstractFactory {
    public abstract Vehicle createVehicle();
    public abstract Weapon createWeapon();
    public abstract Food createFood();
}

//具體工廠類，其中Food,Vehicle，Weapon是抽象類，
public class DefaultFactory extends AbstractFactory{
    @Override
    public Food createFood() {
        return new Apple();
    }
    @Override
    public Vehicle createVehicle() {
        return new Car();
    }
    @Override
    public Weapon createWeapon() {
        return new AK47();
    }
}

//測試類
public class Test {
    public static void main(String[] args) {
        AbstractFactory f = new DefaultFactory();
        Vehicle v = f.createVehicle();
        v.run();
        Weapon w = f.createWeapon();
        w.shoot();
        Food a = f.createFood();
        a.printName();
    }
}

六、代理模式（proxy）

有兩種，靜態代理和動態代理。
先說靜態代理，很多理論性的東西我不講，直接舉例：
到了一定的年齡，我們就要結婚，結婚是一件很麻煩的事情，（包括那些被父母催婚的）。有錢的家庭可能會找司儀來主持婚禮，顯得熱鬧，洋氣～好了，現在婚慶公司的生意來了，我們只需要給錢，婚慶公司就會幫我們安排一整套結婚的流程。整個流程大概是這樣的：家裏人催婚->男女雙方家庭商定結婚的黃道即日->找一家靠譜的婚慶公司->在約定的時間舉行結婚儀式->結婚完畢
婚慶公司打算怎麼安排婚禮的節目，在婚禮完畢以後婚慶公司會做什麼，我們一概不知。。。別擔心，不是黑中介，我們只要把錢給人家，人家會把事情給我們做好。所以，這裏的婚慶公司相當於代理角色，現在明白什麼是代理角色了吧。
代碼實現請看：

//代理接口
public interface ProxyInterface {
 	//需要代理的是結婚這件事，如果還有其他事情需要代理，比如喫飯睡覺上廁所，也可以寫
 	void marry();
}

public class WeddingCompany implements ProxyInterface {

 	private ProxyInterface proxyInterface;

 	public WeddingCompany(ProxyInterface proxyInterface) {
  		this.proxyInterface = proxyInterface;
 	}

 	@Override
 	public void marry() {
  		System.out.println("我們是婚慶公司的");
 		System.out.println("我們在做結婚前的準備工作");
  		System.out.println("節目彩排...");
  		System.out.println("禮物購買...");
  		System.out.println("工作人員分工...");
  		System.out.println("可以開始結婚了");
  		proxyInterface.marry();
  		System.out.println("結婚完畢，我們需要做後續處理，你們可以回家了，其餘的事情我們公司來做");
 	}

}

看到沒有，婚慶公司需要做的事情很多，我們再看看結婚家庭的代碼:

public class NormalHome implements ProxyInterface{

 	@Override
 	public void marry() {
  		System.out.println("我們結婚啦～");
 	}
}

這個已經很明顯了，結婚家庭只需要結婚，而婚慶公司要包攬一切，前前後後的事情都是婚慶公司來做，聽說現在婚慶公司很賺錢的，這就是原因，乾的活多，能不賺錢嗎？
來看看測試類代碼：

public class Test {
 	public static void main(String[] args) {
  		ProxyInterface proxyInterface = new WeddingCompany(new NormalHome());
  		proxyInterface.marry();
 	}
}

運行結果如下：

在我們預料中，結果正確，這就是靜態代理。

關於靜態代理和動態代理的區別，個人觀點：
靜態代理：是在java文件編譯前，手動寫好代理類對象。這樣只能代理一類對象，即一類接口的類型。
動態代理：是通過反射原理，在程序運行的時候動態的生成的代理對象，所以可以代理任意的類對象。

動態代理
舉例：我是周杰倫的歌迷。一直想點歌給周杰倫唱。要怎麼辦？直接找他，估計沒時間搭理我，最有希望的就是找他的經紀人，通過經紀人，傳達我想點的歌。這個時候這個經紀人就是代理。
代碼示例：
1，周杰倫是一個歌手，我們首先創建一個Singer接口類，並聲明一個點歌和告別的方法；

public interface Singer {
    /**
     * 根據歌名點歌
     * @param songName
     */
    public void orderSong(String songName);
    /**
     * 向觀衆告別
     * @param audienceName
     */
    public void sayGoodBye(String audienceName);
}

2，接下來創建周杰倫類並實現歌手接口；

public class Jay implements Singer {

    @Override
    public void orderSong(String songName) {
        System.out.println("演唱歌曲：" + songName);
    }

    @Override
    public void sayGoodBye(String audienceName) {
        System.out.println("再見：" + audienceName);
    }

}

3，就算我找到了經紀人（代理），那我也不能隨便就叫經紀人通知（調用）周杰倫（目標對象）唱歌（的方法），我還要準備一個感人肺腑的故事，但是我又不會講故事，這個時候，經紀人就提供給了我一個模板（調用處理類，一個接口），讓我按照模板編寫故事（實現invoke方法）；

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyStoryInvocationHandler implements InvocationHandler {

    private Object object;
    
    public MyStoryInvocationHandler(Object o) {
        this.object = o;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
        System.out.println("Jay，我是你代理經紀人：" + proxy.getClass().getName());
        //處理業務
        System.out.println("巴拉巴拉......(講了一個故事)");
        
        for(Object arg:args) {
            System.out.println("傳入的參數：" + arg);
        }
        
        //通過反射機制，通知力宏做事情
        method.invoke(object, args);
        
        //處理業務
        System.out.println("巴拉巴拉，感謝......");
        
        return null;
    }

}

代碼中的method.invoke()方法使用到了反射機制。

4，OK，到這裏所有的準備工作就完成了，接下來就開始吧。

import java.lang.reflect.Proxy;

public class MyPorxy {
    public static void main(String[] args) {
        //實例化目標對象（創造一個Jay）
        Jay jay = new Jay();
        //實例化調用處理類（編好的故事）
        MyStoryInvocationHandler handler = new MyStoryInvocationHandler(jay);
        
        //接下來創建代理（經紀人）
        
        //準備一個類加載器
        ClassLoader loader =   MyPorxy.class.getClassLoader();
        //獲取目標對象的接口類對象數組
        Class<?>[] interfaces = jay.getClass().getInterfaces();
        
        //創建代理
        Singer proxy = (Singer) Proxy.newProxyInstance(loader, interfaces, handler);
        
        //開始點歌
        proxy.orderSong("告白氣球");
        System.out.println("****** 歌唱中......********");
        //歌唱完了，say goodBye吧
        proxy.sayGoodBye("我的粉絲");
       
    }
}

運行結果：
【CSDN編輯器的鍋，我的省略號變短了…】

Jay，我是你代理經紀人：com.sun.proxy.$ Proxy0
巴拉巴拉…(講了一個故事)
傳入的參數：告白氣球
演唱歌曲：告白氣球
巴拉巴拉，感謝…
****** 歌唱中…********
Jay，我是你代理經紀人：com.sun.proxy.$ Proxy0
巴拉巴拉…(講了一個故事)
傳入的參數：我的粉絲
再見：我的粉絲
巴拉巴拉，感謝…

代理模式源碼分析及詳細角色等介紹各位可以百度其他作者作品~