Java常见的几种设计模式
單例模式
指一個應(yīng)用程序中，某個類的實例對象只有一個，你沒有辦法去new，因為構(gòu)造器是被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; } }靜態(tài)內(nèi)部類
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() { } }此種寫法不僅能避免多線程同步問題，而且還能防止反序列化重新創(chuàng)建新的對象，但是對于我們的認(rèn)識可能會有些生疏，如下所示。
雙重校驗鎖
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; } }在選擇寫法的時候，我們應(yīng)該根據(jù)業(yè)務(wù)需求邏輯思考選擇最適合我們的寫法。
觀察者模式
對象間一對多的依賴關(guān)系，當(dāng)一個對象的狀態(tài)發(fā)生改變時，所有依賴于它的對象都得到通知并被自動更新。
觀察者模式UML圖
上圖解析示例：假設(shè)有三個人，小美（女，22），小王和小李。小美很漂亮，小王和小李是兩個程序猿，時刻關(guān)注著小美的一舉一動。有一天，小美說了一句：“誰來陪我打游戲啊。”這句話被小王和小李聽到了，結(jié)果樂壞了，蹭蹭蹭，沒一會兒，小王就沖到小美家門口了，在這里，小美是被觀察者，小王和小李是觀察者，被觀察者發(fā)出一條信息，然后觀察者們進行相應(yīng)的處理，看代碼：
public interface Person {//小王和小李通過這個接口可以接收到小美發(fā)過來的消息void getMessage(String s); }這個接口相當(dāng)于小王和小李的電話號碼，小美發(fā)送通知的時候就會撥打getMessage這個電話，撥打電話就是調(diào)用接口，看不懂沒關(guān)系，先往下看
public class LaoWang implements Person {private String name = "小王";public LaoWang() {}@Overridepublic void getMessage(String s) {System.out.println(name + "接到了小美打過來的電話，電話內(nèi)容是：" + s);}}public class LaoLi implements Person {private String name = "小李";public LaoLi() {}@Overridepublic void getMessage(String s) {System.out.println(name + "接到了小美打過來的電話，電話內(nèi)容是：->" + s);}}代碼很簡單，我們再看看小美的代碼：
public class XiaoMei {List<Person> list = new ArrayList<Person>();public XiaoMei(){}public void addPerson(Person person){list.add(person);}//遍歷list，把自己的通知發(fā)送給所有暗戀自己的人public void notifyPerson() {for(Person person:list){person.getMessage("你們過來吧，誰先過來誰就能陪我一起玩兒游戲!");}} }我們寫一個測試類來看一下結(jié)果對不對
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);//小美向小王和小李發(fā)送通知xiao_mei.notifyPerson();} }裝飾者模式
對已有的業(yè)務(wù)邏輯進一步的封裝，使其增加額外的功能，如Java中的IO流就使用了裝飾者模式，用戶在使用的時候，可以任意組裝，達到自己想要的效果。 解析示例，我想吃三明治，首先我需要一根大大的香腸，我喜歡吃奶油，在香腸上面加一點奶油，再放一點蔬菜，最后再用兩片面包夾一下，很豐盛的一頓午飯，營養(yǎng)又健康。（ps：不知道上海哪里有賣好吃的三明治的，求推薦～）那我們應(yīng)該怎么來寫代碼呢？ 首先，我們需要寫一個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()+"+蔬菜";}}這幾個類都是差不多的，構(gòu)造方法傳入一個Food類型的參數(shù)，然后在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了一個香腸，在香腸的外面我包裹了一層奶油，在奶油的外面我又加了一層蔬菜，最外面我放的是面包，我們一起來看一下運行結(jié)果吧。
適配器模式
將兩種完全不同的事物聯(lián)系到一起，就像現(xiàn)實生活中的變壓器。假設(shè)一個手機充電器需要的電壓是20V，但是正常的電壓是220V，這時候就需要一個變壓器，將220V的電壓轉(zhuǎn)換成20V的電壓，這樣，變壓器就將20V的電壓和手機聯(lián)系起來了。
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("經(jīng)過變壓器轉(zhuǎn)換之后的電壓:" + (Phone.V - 200) + "V");} }運行結(jié)果展示
工廠模式
簡單工廠模式：一個抽象的接口，多個抽象接口的實現(xiàn)類，一個工廠類，用來實例化抽象的接口
// 抽象產(chǎn)品類 abstract class Car {public void run();public void stop(); } // 具體實現(xiàn)類 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("造不了這種汽車。。。");}}}工廠方法模式：有四個角色，抽象工廠模式，具體工廠模式，抽象產(chǎn)品模式，具體產(chǎn)品模式。不再是由一個工廠類去實例化具體的產(chǎn)品，而是由抽象工廠的子類去實例化產(chǎn)品
// 抽象產(chǎn)品角色 public interface Moveable {void run(); } // 具體產(chǎn)品角色 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();} }抽象工廠模式：與工廠方法模式不同的是，工廠方法模式中的工廠只生產(chǎn)單一的產(chǎn)品，而抽象工廠模式中的工廠生產(chǎn)多個產(chǎn)品
/抽象工廠類 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）
有兩種，靜態(tài)代理和動態(tài)代理。先說靜態(tài)代理，解析示例，到了一定的年齡，我們就要結(jié)婚，結(jié)婚是一件很麻煩的事情，（包括那些被父母催婚的）。有錢的家庭可能會找司儀來主持婚禮，顯得熱鬧，洋氣～好了，現(xiàn)在婚慶公司的生意來了，我們只需要給錢，婚慶公司就會幫我們安排一整套結(jié)婚的流程。整個流程大概是這樣的：家里人催婚->男女雙方家庭商定結(jié)婚的黃道即日->找一家靠譜的婚慶公司->在約定的時間舉行結(jié)婚儀式->結(jié)婚完畢
婚慶公司打算怎么安排婚禮的節(jié)目，在婚禮完畢以后婚慶公司會做什么，我們一概不知。。。別擔(dān)心，不是黑中介，我們只要把錢給人家，人家會把事情給我們做好。所以，這里的婚慶公司相當(dāng)于代理角色。
實例展示：
//代理接口 public interface ProxyInterface { //需要代理的是結(jié)婚這件事，如果還有其他事情需要代理，比如吃飯睡覺上廁所，也可以寫 void marry(); //代理吃飯(自己的飯，讓別人吃去吧) //void eat(); //代理拉屎，自己的屎，讓別人拉去吧 //void shit(); }接下來，我們看看婚慶公司的代碼:
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("我們在做結(jié)婚前的準(zhǔn)備工作");System.out.println("節(jié)目彩排...");System.out.println("禮物購買...");System.out.println("工作人員分工...");System.out.println("可以開始結(jié)婚了");proxyInterface.marry();System.out.println("結(jié)婚完畢，我們需要做后續(xù)處理，你們可以回家了，其余的事情我們公司來做"); }}再然后是結(jié)婚家庭的代碼:
public class NormalHome implements ProxyInterface{@Override public void marry() {System.out.println("我們結(jié)婚啦～"); }}這個已經(jīng)很明顯了，結(jié)婚家庭只需要結(jié)婚，而婚慶公司要包攬一切，前前后后的事情都是婚慶公司來做，婚慶公司要思考的問題要做的事是最多的。
來看看測試類代碼：
public class Test { public static void main(String[] args) {ProxyInterface proxyInterface = new WeddingCompany(new NormalHome());proxyInterface.marry(); } }運行結(jié)果如下：
生產(chǎn)者/消費者模式
什么是生產(chǎn)者/消費者模式？
某個模塊負(fù)責(zé)產(chǎn)生數(shù)據(jù)，這些數(shù)據(jù)由另一個模塊來負(fù)責(zé)處理（此處的模塊是廣義的，可以是類、函數(shù)、線程、進程等）。產(chǎn)生數(shù)據(jù)的模塊，就形象地稱為生產(chǎn)者；而處理數(shù)據(jù)的模塊，就稱為消費者。在生產(chǎn)者與消費者之間在加個緩沖區(qū)，我們形象的稱之為倉庫，生產(chǎn)者負(fù)責(zé)往倉庫了進商品，而消費者負(fù)責(zé)從倉庫里拿商品，這就構(gòu)成了生產(chǎn)者消費者模式。結(jié)構(gòu)圖如下：
生產(chǎn)者消費者模式有如下幾個優(yōu)點：
1、解耦
由于有緩沖區(qū)的存在，生產(chǎn)者和消費者之間不直接依賴，耦合度降低。
2、支持并發(fā)
由于生產(chǎn)者與消費者是兩個獨立的并發(fā)體，他們之間是用緩沖區(qū)作為橋梁連接，生產(chǎn)者只需要往緩沖區(qū)里丟數(shù)據(jù)，就可以繼續(xù)生產(chǎn)下一個數(shù)據(jù)，而消費者只需要從緩沖區(qū)了拿數(shù)據(jù)即可，這樣就不會因為彼此的處理速度而發(fā)生阻塞。
3、支持忙閑不均
緩沖區(qū)還有另一個好處。如果制造數(shù)據(jù)的速度時快時慢，緩沖區(qū)的好處就體現(xiàn)出來 了。當(dāng)數(shù)據(jù)制造快的時候，消費者來不及處理，未處理的數(shù)據(jù)可以暫時存在緩沖區(qū)中。 等生產(chǎn)者的制造速度慢下來，消費者再慢慢處理掉。
生產(chǎn)者-消費者模型準(zhǔn)確說應(yīng)該是“生產(chǎn)者-倉儲-消費者”模型，這樣的模型遵循如下的規(guī)則：
1、生產(chǎn)者僅僅在倉儲未滿時候生產(chǎn)，倉滿則停止生產(chǎn)。
2、消費者僅僅在倉儲有產(chǎn)品時候才能消費，倉空則等待。
3、當(dāng)消費者發(fā)現(xiàn)倉儲沒產(chǎn)品可消費時候會通知生產(chǎn)者生產(chǎn)。
4、生產(chǎn)者在生產(chǎn)出可消費產(chǎn)品時候，應(yīng)該通知等待的消費者去消費
此模型將要結(jié)合java.lang.Object的wait與notify、notifyAll方法來實現(xiàn)以上的需求。實例代碼如下：
創(chuàng)建所謂的“倉庫”，此類是（本質(zhì)上：共同訪問的）共享數(shù)據(jù)區(qū)域
創(chuàng)建生產(chǎn)者：
public class Producter implements Runnable {private SyncStack stack;public Producter(SyncStack stack){this.stack = stack;}public void run(){for(int i = 0;i<stack.pro().length;i++){String producter = "產(chǎn)品" + i;stack.push(producter);System.out.println("生產(chǎn)了：" + producter);try {Thread.sleep(200);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}} }創(chuàng)建消費者：
public class Consumer implements Runnable {private SyncStack stack;public Consumer(SyncStack stack){this.stack = stack;}public void run(){for(int i=0;i<stack.pro().length;i++){String consumer = stack.pop();System.out.println("消費了：" + consumer );try {Thread.sleep(400);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}} }測試類：
public class TestDeam {public static void main(String[] args) {SyncStack stack = new SyncStack(); Consumer p = new Consumer(stack); Producter c = new Producter(stack); new Thread(p).start(); new Thread(c).start(); } }測試結(jié)果：
生產(chǎn)了:產(chǎn)品0
消費了：產(chǎn)品0
生產(chǎn)了:產(chǎn)品1
生產(chǎn)了:產(chǎn)品2
消費了：產(chǎn)品2
生產(chǎn)了:產(chǎn)品3
消費了：產(chǎn)品3
生產(chǎn)了:產(chǎn)品4
生產(chǎn)了:產(chǎn)品5
生產(chǎn)了:產(chǎn)品6
消費了：產(chǎn)品5
生產(chǎn)了:產(chǎn)品7
消費了：產(chǎn)品6
消費了：產(chǎn)品7
生產(chǎn)了:產(chǎn)品8
生產(chǎn)了:產(chǎn)品9
消費了：產(chǎn)品8
消費了：產(chǎn)品9
了解更多關(guān)注我喲！！！
創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎勵來咯，堅持創(chuàng)作打卡瓜分現(xiàn)金大獎總結(jié)
以上是生活随笔為你收集整理的Java常见的几种设计模式的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： MySQL 数据库恢复
- 下一篇： Java常见异常处理