java中幾種常用的設計模式

參考https://blog.csdn.net/jiyang_1/article/details/50110931

參考https://blog.csdn.net/dean_hu/article/details/71195133

練習參考https://blog.csdn.net/Wu_Ming0821/article/details/51838078，靠譜

 

設計模式介紹：

• 創建型：簡單工廠模式（並不是23種設計模式之一）、工廠方法、抽象工廠模式、單例模式、生成器模式和原型模式
• 結構型：適配器模式adapter、橋接模式bridge、組合器模式component、裝飾器模式decorator、門面模式、亨元模式flyweight和代理模式proxy
• 行為型：命令模式command、解釋器模式、迭代器模式、中介者模式、備忘錄模式、觀察者模式、狀態模式state、策略模式、模板模式和訪問者模式

 

常用的幾種設計模式介紹

1、單例模式

如果一個類始終只能創建一個實例，則這個類被稱為單例類，這種模式就被稱為單例模式。一般建議單例模式的方法命名為：getInstance()，這個方法的返回類型肯定是單例類的類型了。getInstance方法可以有參數，這些參數可能是創建類實例所需要的參數，當然，大多數情況下是不需要的。實現單例模式的簡單例子：

 

1.  
   public class Singleton {
2.  
   public static void main(String[] args)
3.  
   {
4.  
   //創建Singleton對象不能通過構造器，只能通過getInstance方法
5.  
   Singleton s1 = Singleton.getInstance();
6.  
   Singleton s2 = Singleton.getInstance();
7.  
   //將輸出true
8.  
   System.out.println(s1 == s2);
9.  
   }
10.  
    //使用一個變量來緩存曾經創建的實例
11.  
    private static Singleton instance;
12.  
    //將構造器使用private修飾，隱藏該構造器
13.  
    private Singleton(){
14.  
    System.out.println( "Singleton被構造！");
15.  
    }
16.  
    //提供一個靜態方法，用於返回Singleton實例
17.  
    //該方法可以加入自定義的控制，保證只產生一個Singleton對象
18.  
    public static Singleton getInstance()
19.  
    {
20.  
    //如果instance為null，表明還不曾創建Singleton對象
21.  
    //如果instance不為null，則表明已經創建了Singleton對象，將不會執行該方法
22.  
    if (instance == null)
23.  
    {
24.  
    //創建一個Singleton對象，並將其緩存起來
25.  
    instance = new Singleton();
26.  
    }
27.  
    return instance;
28.  
    }
29.  
    }

2、工廠模式

 

 

簡單工廠模式的核心思想就是：有一個專門的類來負責創建實例的過程。 具體來說，把產品看着是一系列的類的集合，這些類是由某個抽象類或者接口派生出來的一個對象樹。而工廠類用來產生一個合適的對象來滿足客戶的要求。如果簡單工廠模式所涉及到的具體產品之間沒有共同的邏輯，那么我們就可以使用接口來扮演抽象產品的角色；如果具體產品之間有功能的邏輯或，我們就必須把這些共同的東西提取出來，放在一個抽象類中，然后讓具體產品繼承抽象類。為實現更好復用的目的，共同的東西總是應該抽象出來的。

1.  
   /*
2.  
   * 產品的抽象接口
3.  
   */
4.  
   public interface Food {
5.  
   /*
6.  
   * 獲得相應的食物
7.  
   */
8.  
   public void get();
9.  
   }

1.  
   /*
2.  
   * 麥香雞對抽象產品接口的實現
3.  
   */
4.  
   public class McChicken implements Food{
5.  
   /*
6.  
   * 獲取一份麥香雞
7.  
   */
8.  
   public void get(){
9.  
   System.out.println( "我要一份麥香雞");
10.  
    }
11.  
    }

1.  
   public class FoodFactory {
2.  
    
3.  
   public static Food getFood(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
4.  
   if(type.equalsIgnoreCase("mcchicken")) {
5.  
   return McChicken.class.newInstance();
6.  
    
7.  
   } else if(type.equalsIgnoreCase("chips")) {
8.  
   return Chips.class.newInstance();
9.  
   } else {
10.  
    System.out.println( "哎呀！找不到相應的實例化類啦！");
11.  
    return null;
12.  
    }
13.  
     
14.  
     
15.  
    }
16.  
    }

1.  
   /*
2.  
   * 測試客戶端
3.  
   */
4.  
   public class SimpleFactoryTest {
5.  
   public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
6.  
    
7.  
   //實例化各種食物
8.  
   Food mcChicken = FoodFactory.getFood( "McChicken");
9.  
   Food chips = FoodFactory.getFood( "Chips");
10.  
    Food eggs = FoodFactory.getFood( "Eggs");
11.  
     
12.  
    //獲取食物
13.  
    if(mcChicken!=null){
14.  
    mcChicken.get();
15.  
    }
16.  
    if(chips!=null){
17.  
    chips.get();
18.  
    }
19.  
    if(eggs!=null){
20.  
    eggs.get();
21.  
    }
22.  
     
23.  
     
24.  
    }
25.  
    }

輸出的結果如下：

哎呀！找不到相應的實例化類啦！

我要一份麥香雞

我要一份薯條

3、代理模式

 

代理模式是一種應用非常廣泛的設計模式，當客戶端代碼需要調用某個對象時，客戶端實際上不關心是否准確得到該對象，它只要一個能提供該功能的對象即可，此時我們就可返回該對象的代理（Proxy）。

 

代理就是一個Java對象代表另一個Java對象來采取行動。如：

1.  
   public class ImageProxy implements Image
2.  
   {
3.  
   //組合一個image實例，作為被代理的對象
4.  
   private Image image;
5.  
   //使用抽象實體來初始化代理對象
6.  
   public ImageProxy(Image image)
7.  
   {
8.  
   this.image = image;
9.  
   }
10.  
    /**
11.  
    * 重寫Image接口的show()方法
12.  
    * 該方法用於控制對被代理對象的訪問，
13.  
    * 並根據需要負責創建和刪除被代理對象
14.  
    */
15.  
    public void show()
16.  
    {
17.  
    //只有當真正需要調用image的show方法時才創建被代理對象
18.  
    if (image == null)
19.  
    {
20.  
    image = new BigImage();
21.  
    }
22.  
    image.show();
23.  
    }
24.  
    }

調用時，先不創建：

Image image = new ImageProxy(null);

 

Hibernate默認啟用延遲加載，當系統加載A實體時，A實體關聯的B實體並未被加載出來，A實體所關聯的B實體全部是代理對象——只有等到A實體真正需要訪問B實體時，系統才會去數據庫里抓取B實體所對應的記錄。

借助於Java提供的Proxy和InvocationHandler，可以實現在運行時生成動態代理的功能，而動態代理對象就可以作為目標對象使用，而且增強了目標對象的功能。如：

1.  
   public interface Panther
2.  
   {
3.  
   //info方法聲明
4.  
   public void info();
5.  
   //run方法聲明
6.  
   public void run();
7.  
   }

1.  
   public class GunPanther implements Panther
2.  
   {
3.  
   //info方法實現，僅僅打印一個字符串
4.  
   public void info()
5.  
   {
6.  
   System.out.println( "我是一只獵豹！");
7.  
   }
8.  
   //run方法實現，僅僅打印一個字符串
9.  
   public void run()
10.  
    {
11.  
    System.out.println( "我奔跑迅速");
12.  
    }
13.  
    }

1.  
   public class MyProxyFactory
2.  
   {
3.  
   //為指定target生成動態代理對象
4.  
   public static Object getProxy(Object target)
5.  
   throws Exception
6.  
   {
7.  
   //創建一個MyInvokationHandler對象
8.  
   MyInvokationHandler handler =
9.  
   new MyInvokationHandler();
10.  
    //為MyInvokationHandler設置target對象
11.  
    handler.setTarget(target);
12.  
    //創建、並返回一個動態代理
13.  
    return Proxy.newProxyInstance(target.getClass().getClassLoader()
14.  
    , target.getClass().getInterfaces(), handler);
15.  
    }
16.  
    }

 

1.  
   public class MyInvokationHandler implements InvocationHandler
2.  
   {
3.  
   //需要被代理的對象
4.  
   private Object target;
5.  
   public void setTarget(Object target)
6.  
   {
7.  
   this.target = target;
8.  
   }
9.  
   //執行動態代理對象的所有方法時，都會被替換成執行如下的invoke方法
10.  
    public Object invoke(Object proxy, Method method, Object[] args)
11.  
    throws Exception
12.  
    {
13.  
    TxUtil tx = new TxUtil();
14.  
    //執行TxUtil對象中的beginTx。
15.  
    tx.beginTx();
16.  
    //以target作為主調來執行method方法
17.  
    Object result = method.invoke(target , args);
18.  
    //執行TxUtil對象中的endTx。
19.  
    tx.endTx();
20.  
    return result;
21.  
    }
22.  
    }

1.  
   public class TxUtil
2.  
   {
3.  
   //第一個攔截器方法:模擬事務開始
4.  
   public void beginTx()
5.  
   {
6.  
   System.out.println( "=====模擬開始事務=====");
7.  
   }
8.  
   //第二個攔截器方法:模擬事務結束
9.  
   public void endTx()
10.  
    {
11.  
    System.out.println( "=====模擬結束事務=====");
12.  
    }
13.  
    }

測試：

 

1.  
   public static void main(String[] args)
2.  
   throws Exception
3.  
   {
4.  
   //創建一個原始的GunDog對象，作為target
5.  
   Panther target = new GunPanther();
6.  
   //以指定的target來創建動態代理
7.  
   Panther panther = (Panther)MyProxyFactory.getProxy(target);
8.  
   //調用代理對象的info()和run()方法
9.  
   panther.info();
10.  
    panther.run();
11.  
    }

4、觀測者模式

 

 

觀察者模式結構中包括四種角色：

　　一、主題：主題是一個接口，該接口規定了具體主題需要實現的方法，比如添加、刪除觀察者以及通知觀察者更新數據的方法。

　　二、觀察者：觀察者也是一個接口，該接口規定了具體觀察者用來更新數據的方法。

　　三、具體主題：具體主題是一個實現主題接口的類，該類包含了會經常發生變化的數據。而且還有一個集合，該集合存放的是觀察者的引用。

　　四：具體觀察者：具體觀察者是實現了觀察者接口的一個類。具體觀察者包含有可以存放具體主題引用的主題接口變量，以便具體觀察者讓具體主題將自己的引用添加到具體主題的集合中，讓自己成為它的觀察者，或者讓這個具體主題將自己從具體主題的集合中刪除，使自己不在時它的觀察者。

 

觀察者模式定義了對象間的一對多依賴關系，讓一個或多個觀察者對象觀察一個主題對象。當主題對象的狀態發生變化時，系統能通知所有的依賴於此對象的觀察者對象，從而使得觀察者對象能夠自動更新。

在觀察者模式中，被觀察的對象常常也被稱為目標或主題（Subject），依賴的對象被稱為觀察者（Observer）。

 

Observer，觀察者接口：

觀察者：觀察者也是一個接口，該接口規定了具體觀察者用來更新數據的方法

1.  
   public interface Observer {
2.  
   void update(Observable o, Object arg);
3.  
   }

Observable，目標或主題：

主題：主題是一個接口，該接口規定了具體主題需要實現的方法，比如添加、刪除觀察者以及通知觀察者更新數據的方法

1.  
   import java.util.ArrayList;
2.  
   import java.util.List;
3.  
   import java.util.Iterator;
4.  
    
5.  
   public abstract class Observable {
6.  
   // 用一個List來保存該對象上所有綁定的事件監聽器
7.  
   List<Observer> observers = new ArrayList<Observer>();
8.  
    
9.  
   // 定義一個方法，用於從該主題上注冊觀察者
10.  
    public void registObserver(Observer o) {
11.  
    observers.add(o);
12.  
    }
13.  
     
14.  
    // 定義一個方法，用於從該主題中刪除觀察者
15.  
    public void removeObserver(Observer o) {
16.  
    observers.add(o);
17.  
    }
18.  
     
19.  
    // 通知該主題上注冊的所有觀察者
20.  
    public void notifyObservers(Object value) {
21.  
    // 遍歷注冊到該被觀察者上的所有觀察者
22.  
    for (Iterator it = observers.iterator(); it.hasNext();) {
23.  
    Observer o = (Observer) it.next();
24.  
    // 顯式每個觀察者的update方法
25.  
    o.update( this, value);
26.  
    }
27.  
    }
28.  
    }

Product被觀察類：

具體主題：具體主題是一個實現主題接口的類，該類包含了會經常發生變化的數據。而且還有一個集合，該集合存放的是觀察者的引用。

1.  
   public class Product extends Observable {
2.  
   // 定義兩個屬性
3.  
   private String name;
4.  
   private double price;
5.  
    
6.  
   // 無參數的構造器
7.  
   public Product() {
8.  
   }
9.  
    
10.  
    public Product(String name, double price) {
11.  
    this.name = name;
12.  
    this.price = price;
13.  
    }
14.  
     
15.  
    public String getName() {
16.  
    return name;
17.  
    }
18.  
     
19.  
    // 當程序調用name的setter方法來修改Product的name屬性時
20.  
    // 程序自然觸發該對象上注冊的所有觀察者
21.  
    public void setName(String name) {
22.  
    this.name = name;
23.  
    notifyObservers(name);
24.  
    }
25.  
     
26.  
    public double getPrice() {
27.  
    return price;
28.  
    }
29.  
     
30.  
    // 當程序調用price的setter方法來修改Product的price屬性時
31.  
    // 程序自然觸發該對象上注冊的所有觀察者
32.  
    public void setPrice(double price) {
33.  
    this.price = price;
34.  
    notifyObservers(price);
35.  
    }
36.  
    }

具體觀察者：具體觀察者是實現了觀察者接口的一個類。具體觀察者包含有可以存放具體主題引用的主題接口變量，以便具體觀察者讓具體主題將自己的引用添加到具體主題的集合中，讓自己成為它的觀察者，或者讓這個具體主題將自己從具體主題的集合中刪除，使自己不在時它的觀察者。

 

NameObserver名稱觀察者：

1.  
   import javax.swing.JFrame;
2.  
   import javax.swing.JLabel;
3.  
    
4.  
   public class NameObserver implements Observer {
5.  
   // 實現觀察者必須實現的update方法
6.  
   public void update(Observable o, Object arg) {
7.  
   if (arg instanceof String) {
8.  
   // 產品名稱改變值在name中
9.  
   String name = (String) arg;
10.  
    // 啟動一個JFrame窗口來顯示被觀察對象的狀態改變
11.  
    JFrame f = new JFrame("觀察者");
12.  
    JLabel l = new JLabel("名稱改變為：" + name);
13.  
    f.add(l);
14.  
    f.pack();
15.  
    f.setVisible( true);
16.  
    System.out.println( "名稱觀察者:" + o + "物品名稱已經改變為: " + name);
17.  
    }
18.  
    }
19.  
    }

PriceObserver價格觀察者：

 

1.  
   public class PriceObserver implements Observer {
2.  
   // 實現觀察者必須實現的update方法
3.  
   public void update(Observable o, Object arg) {
4.  
   if (arg instanceof Double) {
5.  
   System.out.println( "價格觀察者:" + o + "物品價格已經改變為: " + arg);
6.  
   }
7.  
   }
8.  
   }

測試：

 

 

1.  
   public class Test {
2.  
   public static void main(String[] args) {
3.  
   // 創建一個被觀察者對象
4.  
   Product p = new Product("電視機", 176);
5.  
   // 創建兩個觀察者對象
6.  
   NameObserver no = new NameObserver();
7.  
   PriceObserver po = new PriceObserver();
8.  
   // 向被觀察對象上注冊兩個觀察者對象
9.  
   p.registObserver(no);
10.  
    p.registObserver(po);
11.  
    // 程序調用setter方法來改變Product的name和price屬性
12.  
    p.setName( "書桌");
13.  
    p.setPrice( 345f);
14.  
    }
15.  
    }

其中Java工具類提供了被觀察者抽象基類：java.util.Observable。觀察者接口：java.util.Observer。