Java常見的幾種設計模式

 

單例模式

簡單點說，就是一個應用程序中，某個類的實例對象只有一個，你沒有辦法去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圖

 

看不懂圖的人端着小板凳到這里來，給你舉個栗子：假設有三個人，小美（女，22），小王和小李。小美很漂亮，小王和小李是兩個程序猿，時刻關注着小美的一舉一動。有一天，小美說了一句：“誰來陪我打游戲啊。”這句話被小王和小李聽到了，結果樂壞了，蹭蹭蹭，沒一會兒，小王就沖到小美家門口了，在這里，小美是被觀察者，小王和小李是觀察者，被觀察者發出一條信息，然后觀察者們進行相應的處理，看代碼：

 

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

l

這個接口相當於小王和小李的電話號碼，小美發送通知的時候就會撥打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 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 {
   @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();
//代理吃飯(自己的飯，讓別人吃去吧)
//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("我們在做結婚前的准備工作");
 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();
}
}

 

運行結果如下：

---

生產者/消費者模式

 

什么是生產者/消費者模式？

 

某個模塊負責產生數據，這些數據由另一個模塊來負責處理（此處的模塊是廣義的，可以是類、函數、線程、進程等）。產生數據的模塊，就形象地稱為生產者；而處理數據的模塊，就稱為消費者。在生產者與消費者之間在加個緩沖區，我們形象的稱之為倉庫，生產者負責往倉庫了進商品，而消費者負責從倉庫里拿商品，這就構成了生產者消費者模式。結構圖如下：

 

生產者消費者模式有如下幾個優點：

1、解耦

　  由於有緩沖區的存在，生產者和消費者之間不直接依賴，耦合度降低。

2、支持並發

　  由於生產者與消費者是兩個獨立的並發體，他們之間是用緩沖區作為橋梁連接，生產者只需要往緩沖區里丟數據，就可以繼續生產下一個數據，而消費者只需要從緩沖區了拿數據即可，這樣就不會因為彼此的處理速度而發生阻塞。

3、支持忙閑不均

    緩沖區還有另一個好處。如果制造數據的速度時快時慢，緩沖區的好處就體現出來 了。當數據制造快的時候，消費者來不及處理，未處理的數據可以暫時存在緩沖區中。 等生產者的制造速度慢下來，消費者再慢慢處理掉。

 

生產者-消費者模型准確說應該是“生產者-倉儲-消費者”模型，這樣的模型遵循如下的規則：

1、生產者僅僅在倉儲未滿時候生產，倉滿則停止生產。
2、消費者僅僅在倉儲有產品時候才能消費，倉空則等待。
3、當消費者發現倉儲沒產品可消費時候會通知生產者生產。
4、生產者在生產出可消費產品時候，應該通知等待的消費者去消費

 此模型將要結合java.lang.Object的wait與notify、notifyAll方法來實現以上的需求。實例代碼如下：

創建所謂的“倉庫”，此類是（本質上：共同訪問的）共享數據區域

//此類是（本質上：共同訪問的）共享數據區域
public class SyncStack {
    
    private String[]  str = new String[10];
    
    private int index;
    
    //供生產者調用
    public synchronized void push(String sst){
        if(index == sst.length()){
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        this.notify();//喚醒在此對象監視器上等待的單個線程 
        str[index] = sst;
        index++;
    }
    
    //供消費者調用  
    public synchronized String pop(){
        if(index == 0){
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        this.notify();
        index--;
        String product = str[index];
        return product;
        
    }
    
    //就是定義一個返回值為數組的方法,返回的是一個String[]引用  
    public String[] pro(){
        return str;
    }
}

創建生產者：

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 = "產品" + i;
            stack.push(producter);
            System.out.println("生產了：" + producter);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
        }
    }
}

創建消費者：

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 block
                e.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(); 

    }
}

測試結果：

生產了:產品0
消費了：產品0
生產了:產品1
生產了:產品2
消費了：產品2
生產了:產品3
消費了：產品3
生產了:產品4
生產了:產品5
生產了:產品6
消費了：產品5
生產了:產品7
消費了：產品6
消費了：產品7
生產了:產品8
生產了:產品9
消費了：產品8
消費了：產品9
消費了：產品4
消費了：產品1

（完）