趁著自己有時間，寫點博客，記錄下自己的學習經歷，希望能夠幫助到別人。

上次我寫的一篇博客《史上最最最簡單的MVP教程》很多初學者看了都說簡單易懂，我也覺得挺開心的，以后會寫出更好的博客來幫助更多的人。

單例模式

簡單點說，就是一個應用程序中，某個類的實例對象只有一個，你沒有辦法去new，因為構造器是被private修飾的，一般通過getInstance()的方法來獲取它們的實例。getInstance()的返回值是一個對象的引用，并不是一個新的實例，所以不要錯誤的理解成多個對象。單例模式實現起來也很容易，直接看demo吧

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 提倡的方式，它不僅能避免多線程同步問題，而且還能防止反序列化重新創建新的對象，可謂是很堅強的壁壘啊，不過，個人認為由于1.5中才加入enum特性，用這種方式寫不免讓人感覺生疏。

---

雙重校驗鎖

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; } }

總結：我個人比較喜歡靜態內部類寫法和餓漢式寫法，其實這兩種寫法能夠應付絕大多數情況了。其他寫法也可以選擇，主要還是看業務需求吧。

觀察者模式

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

觀察者模式UML圖

看不懂圖的人端著小板凳到這里來，給你舉個栗子��：假設有三個人，小美（女，28），老王和老李。小美很漂亮，很風騷，老王和老李是兩個中年男屌絲，時刻關注著小美的一舉一動。有一天，小美說了一句：我老公今天不在家，一個人好無聊啊～～～，這句話被老王和老李聽到了，結果樂壞了，蹭蹭蹭，沒一會兒，老王就沖到小美家門口了，于是進門了……………………..帕～啪啪啪啪啪～ 在這里，小美是被觀察者，老王和老李是觀察者，被觀察者發出一條信息，然后觀察者們進行相應的處理，看代碼：

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

這個接口相當于老王和老李的電話號碼，小美發送通知的時候就會撥打getMessage這個電話，撥打電話就是調用接口，看不懂沒關系，先往下看

public class LaoWang implements Person {private String name = "老王";public LaoWang() {}@Overridepublic void getMessage(String s) {System.out.println(name + "接到了小美打過來的電話，電話內容是：" + s);}}public class LaoLi implements Person {private String name = "老李";public LaoLi() {}@Overridepublic 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 xiao_mei = new XiaoMei();LaoWang lao_wang = new LaoWang();LaoLi lao_li = new LaoLi();//老王和老李在小美那里都注冊了一下xiao_mei.addPerson(lao_wang);xiao_mei.addPerson(lao_li);//小美向老王和老李發送通知xiao_mei.notifyPerson();} }

運行結果我截圖了

運行結果

完美～～～

裝飾者模式

對已有的業務邏輯進一步的封裝，使其增加額外的功能，如Java中的IO流就使用了裝飾者模式，用戶在使用的時候，可以任意組裝，達到自己想要的效果。 舉個栗子，我想吃三明治，首先我需要一根大大的香腸，我喜歡吃奶油，在香腸上面加一點奶油，再放一點蔬菜，最后再用兩片面包夾一下，很豐盛的一頓午飯，營養又健康。（ps：不知道上海哪里有賣好吃的三明治的，求推薦～）那我們應該怎么來寫代碼呢？ 首先，我們需要寫一個Food類，讓其他所有食物都來繼承這個類，看代碼：

public class Food {private String food_name;public Food() {}public Food(String food_name) {this.food_name = food_name;}public String make() {return food_name;}; }

代碼很簡單，我就不解釋了，然后我們寫幾個子類繼承它：

//面包類 public class Bread extends Food {private Food basic_food;public Bread(Food basic_food) {this.basic_food = basic_food;}public String make() {return basic_food.make()+"+面包";} }//奶油類 public class Cream extends Food {private Food basic_food;public Cream(Food basic_food) {this.basic_food = basic_food;}public String make() {return basic_food.make()+"+奶油";} }//蔬菜類 public class Vegetable extends Food {private Food basic_food;public Vegetable(Food basic_food) {this.basic_food = basic_food;}public String make() {return basic_food.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");} }

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

// 抽象產品類 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 {@Overridepublic void run() {System.out.println("plane....");} }public class Broom implements Moveable {@Overridepublic 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{@Overridepublic Food createFood() {return new Apple();}@Overridepublic Vehicle createVehicle() {return new Car();}@Overridepublic 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();//代理吃飯(自己的飯，讓別人吃去吧)//void eat();//代理拉屎，自己的屎，讓別人拉去吧//void shit(); }

文明社會，代理吃飯，代理拉屎什么的我就不寫了，有傷社會風化～～～能明白就好
好了，我們看看婚慶公司的代碼:

public class WeddingCompany implements ProxyInterface {private ProxyInterface proxyInterface;public WeddingCompany(ProxyInterface proxyInterface) {this.proxyInterface = proxyInterface;}@Overridepublic 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{@Overridepublic void marry() {System.out.println("我們結婚啦～");}}

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

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

運行結果如下：

在我們預料中，結果正確，這就是靜態代理，動態代理我就不想說了，跟java反射有關系，網上資料很多，我以后有時間再更新吧。
覺得我寫的好的話，點個贊支持一下唄
這兩天開始寫微信公眾號了，大家可以去關注一下哦～～
我的微信公眾號：代碼也是人
二維碼：

微信公眾號二維碼.jpeg

技術交流群：471395156

作者：我是吳長老啊
鏈接：http://www.jianshu.com/p/93bc5aa1f887
來源：簡書

總結

以上是生活随笔為你收集整理的超详细：常用的设计模式汇总的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。