(轉(zhuǎn)載)常用設(shè)計(jì)模式學(xué)習(xí)筆記

本文為本人觀看博客文章所作筆記,僅供本人學(xué)習(xí)記錄使用慈俯,詳細(xì)文章請看這里,如有侵權(quán)請聯(lián)系我刪除

創(chuàng)建型模式

簡單工廠

選擇不一樣的參數(shù)栏尚,生成不一樣的產(chǎn)品 可用switch()來做參數(shù)選擇

public class FoodFactory {

    public static Food makeFood(String name) {
        if (name.equals("noodle")) {
            Food noodle = new LanZhouNoodle();
            noodle.addSpicy("more");
            return noodle;
        } else if (name.equals("chicken")) {
            Food chicken = new HuangMenChicken();
            chicken.addCondiment("potato");
            return chicken;
        } else {
            return null;
       }
    }
}

工廠模式

(需要兩個(gè)或者兩個(gè)以上的工廠) 客戶端根據(jù)不同的參數(shù)生成對應(yīng)的工廠實(shí)例 起愈, 該工廠再生成不用的產(chǎn)品

public interface FoodFactory {
    Food makeFood(String name);
}
public class ChineseFoodFactory implements FoodFactory {

    @Override
    public Food makeFood(String name) {
        if (name.equals("A")) {
            return new ChineseFoodA();
        } else if (name.equals("B")) {
            return new ChineseFoodB();
        } else {
            return null;
        }
    }
}
public class AmericanFoodFactory implements FoodFactory {

    @Override
    public Food makeFood(String name) {
        if (name.equals("A")) {
            return new AmericanFoodA();
        } else if (name.equals("B")) {
            return new AmericanFoodB();
        } else {
            return null;
        }
    }
}

public class APP {
    public static void main(String[] args) {
        // 先選擇一個(gè)具體的工廠
        FoodFactory factory = new ChineseFoodFactory();
        // 由第一步的工廠產(chǎn)生具體的對象,不同的工廠造出不一樣的對象
        Food food = factory.makeFood("A");
    }
}

抽象工廠

當(dāng)涉及到產(chǎn)品族的時(shí)候译仗,就需要引入抽象工廠模式了抬虽。

一個(gè)經(jīng)典的例子是造一臺電腦。我們先不引入抽象工廠模式纵菌,看看怎么實(shí)現(xiàn)阐污。

因?yàn)殡娔X是由許多的構(gòu)件組成的,我們將 CPU 和主板進(jìn)行抽象咱圆,然后 CPU 由 CPUFactory 生產(chǎn)笛辟,主板由 MainBoardFactory 生產(chǎn),然后序苏,我們再將 CPU 和主板搭配起來組合在一起手幢,如下圖:

factory-1

這個(gè)時(shí)候的客戶端調(diào)用是這樣的:

// 得到 Intel 的 CPU
CPUFactory cpuFactory = new IntelCPUFactory();
CPU cpu = intelCPUFactory.makeCPU();

// 得到 AMD 的主板
MainBoardFactory mainBoardFactory = new AmdMainBoardFactory();
MainBoard mainBoard = mainBoardFactory.make();

// 組裝 CPU 和主板
Computer computer = new Computer(cpu, mainBoard);

單獨(dú)看 CPU 工廠和主板工廠,它們分別是前面我們說的工廠模式忱详。這種方式也容易擴(kuò)展围来,因?yàn)橐o電腦加硬盤的話,只需要加一個(gè) HardDiskFactory 和相應(yīng)的實(shí)現(xiàn)即可匈睁,不需要修改現(xiàn)有的工廠监透。

但是,這種方式有一個(gè)問題航唆,那就是如果 Intel 家產(chǎn)的 CPU 和 AMD 產(chǎn)的主板不能兼容使用胀蛮,那么這代碼就容易出錯(cuò),因?yàn)榭蛻舳瞬⒉恢浪鼈儾患嫒莘鸬悖簿蜁e(cuò)誤地出現(xiàn)隨意組合醇滥。

下面就是我們要說的產(chǎn)品族的概念黎比,它代表了組成某個(gè)產(chǎn)品的一系列附件的集合:

abstract-factory-2

當(dāng)涉及到這種產(chǎn)品族的問題的時(shí)候超营,就需要抽象工廠模式來支持了鸳玩。我們不再定義 CPU 工廠演闭、主板工廠窝革、硬盤工廠、顯示屏工廠等等漆诽,我們直接定義電腦工廠,每個(gè)電腦工廠負(fù)責(zé)生產(chǎn)所有的設(shè)備,這樣能保證肯定不存在兼容問題楞捂。

abstract-factory-3

這個(gè)時(shí)候,對于客戶端來說,不再需要單獨(dú)挑選 CPU廠商帖蔓、主板廠商、硬盤廠商等埋酬,直接選擇一家品牌工廠,品牌工廠會負(fù)責(zé)生產(chǎn)所有的東西祝峻,而且能保證肯定是兼容可用的。

public static void main(String[] args) {
    // 第一步就要選定一個(gè)“大廠”
    ComputerFactory cf = new AmdFactory();
    // 從這個(gè)大廠造 CPU
    CPU cpu = cf.makeCPU();
    // 從這個(gè)大廠造主板
    MainBoard board = cf.makeMainBoard();
      // 從這個(gè)大廠造硬盤
      HardDisk hardDisk = cf.makeHardDisk();

    // 將同一個(gè)廠子出來的 CPU、主板、硬盤組裝在一起
    Computer result = new Computer(cpu, board, hardDisk);
}

當(dāng)然,抽象工廠的問題也是顯而易見的闸盔,比如我們要加個(gè)顯示器针贬,就需要修改所有的工廠蔫巩,給所有的工廠都加上制造顯示器的方法。這有點(diǎn)違反了對修改關(guān)閉,對擴(kuò)展開放這個(gè)設(shè)計(jì)原則嗦锐。

單例模式

餓漢模式最簡單:

public class Singleton {
    // 首先,將 new Singleton() 堵死
    private Singleton() {};
    // 創(chuàng)建私有靜態(tài)實(shí)例外驱,意味著這個(gè)類第一次使用的時(shí)候就會進(jìn)行創(chuàng)建
    private static Singleton instance = new Singleton();

    public static Singleton getInstance() {
        return instance;
    }
    // 瞎寫一個(gè)靜態(tài)方法。這里想說的是,如果我們只是要調(diào)用 Singleton.getDate(...),
    // 本來是不想要生成 Singleton 實(shí)例的,不過沒辦法瞬哼,已經(jīng)生成了
    public static Date getDate(String mode) {return new Date();}
}

很多人都能說出餓漢模式的缺點(diǎn)较性,可是我覺得生產(chǎn)過程中,很少碰到這種情況:你定義了一個(gè)單例的類结胀,不需要其實(shí)例赞咙,可是你卻把一個(gè)或幾個(gè)你會用到的靜態(tài)方法塞到這個(gè)類中。

飽漢模式最容易出錯(cuò):

public class Singleton {
    // 首先把跨,也是先堵死 new Singleton() 這條路
    private Singleton() {}
    // 和餓漢模式相比人弓,這邊不需要先實(shí)例化出來,注意這里的 volatile着逐,它是必須的
    private static volatile Singleton instance = null;

    public static Singleton getInstance() {
        if (instance == null) {
            // 加鎖
            synchronized (Singleton.class) {
                // 這一次判斷也是必須的崔赌,不然會有并發(fā)問題
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

雙重檢查意蛀,指的是兩次檢查 instance 是否為 null。

volatile 在這里是需要的健芭,希望能引起讀者的關(guān)注县钥。

很多人不知道怎么寫,直接就在 getInstance() 方法簽名上加上 synchronized慈迈,這就不多說了若贮,性能太差。

嵌套類最經(jīng)典痒留,以后大家就用它吧:

public class Singleton3 {

    private Singleton3() {}
    // 主要是使用了 嵌套類可以訪問外部類的靜態(tài)屬性和靜態(tài)方法 的特性
    private static class Holder {
        private static Singleton3 instance = new Singleton3();
    }
    public static Singleton3 getInstance() {
        return Holder.instance;
    }
}

注意谴麦,很多人都會把這個(gè)嵌套類說成是靜態(tài)內(nèi)部類,嚴(yán)格地說伸头,內(nèi)部類和嵌套類是不一樣的匾效,它們能訪問的外部類權(quán)限也是不一樣的。

最后恤磷,我們說一下枚舉面哼,枚舉很特殊,它在類加載的時(shí)候會初始化里面的所有的實(shí)例扫步,而且 JVM 保證了它們不會再被實(shí)例化魔策,所以它天生就是單例的。

雖然我們平時(shí)很少看到用枚舉來實(shí)現(xiàn)單例河胎,但是在 RxJava 的源碼中闯袒,有很多地方都用了枚舉來實(shí)現(xiàn)單例。

建造者模式

經(jīng)常碰見的 XxxBuilder 的類仿粹,通常都是建造者模式的產(chǎn)物搁吓。建造者模式其實(shí)有很多的變種,但是對于客戶端來說吭历,我們的使用通常都是一個(gè)模式的:

Food food = new FoodBuilder().a().b().c().build();
Food food = Food.builder().a().b().c().build();

套路就是先 new 一個(gè) Builder堕仔,然后可以鏈?zhǔn)降卣{(diào)用一堆方法,最后再調(diào)用一次 build() 方法晌区,我們需要的對象就有了摩骨。

package com.wxx.pattern;

class User {
    // 下面是“一堆”的屬性
    private String name;
    private String password;
    private String nickName;
    private int age;

    private User(String name, String password, String nickName, int age) {
        this.name = name;
        this.password = password;
        this.nickName = nickName;
        this.age = age;
    }

    public  static  UserBuilder build(){
        return new UserBuilder();
    }


  public  static   class UserBuilder{
      // 下面是和 User 一模一樣的一堆屬性
      private String name;
      private String password;
      private String nickName;
      private int age;


      private UserBuilder() {
      }
      // 鏈?zhǔn)秸{(diào)用設(shè)置各個(gè)屬性值,返回 this朗若,即 UserBuilder
      public UserBuilder name(String name) {
          this.name = name;
          return this;
      }

      public UserBuilder password(String password) {
          this.password = password;
          return this;
      }

      public UserBuilder nickName(String nickName) {
          this.nickName = nickName;
          return this;
      }

      public UserBuilder age(int age) {
          this.age = age;
          return this;
      }


      // build() 方法負(fù)責(zé)將 UserBuilder 中設(shè)置好的屬性“復(fù)制”到 User 中
      // 當(dāng)然恼五,可以在 “復(fù)制” 之前做點(diǎn)檢驗(yàn)

      public User build(){
          if(name == null || password == null){
              throw new RuntimeException("用戶名和密碼不能為空");
          }

          if (age <= 0 || age >= 150) {
              throw new RuntimeException("年齡不合法");
          }
          // 還可以做賦予”默認(rèn)值“的功能
          if (nickName == null) {
              nickName = name;
          }

          return new User(name, password, nickName, age);
      }
  }
}


//客戶端中的調(diào)用
 public static void main(String[] args) {
        User d =  User.build().name("foo").password("1244").age(25).build();
    }

原型模式

原型模式很簡單:有一個(gè)原型實(shí)例,基于這個(gè)原型實(shí)例產(chǎn)生新的實(shí)例哭懈,也就是“克隆”了灾馒。

Object 類中有一個(gè) clone() 方法,它用于生成一個(gè)新的對象遣总,當(dāng)然睬罗,如果我們要調(diào)用這個(gè)方法轨功,java 要求我們的類必須先實(shí)現(xiàn) Cloneable 接口,此接口沒有定義任何方法容达,但是不這么做的話古涧,在 clone() 的時(shí)候,會拋出 CloneNotSupportedException 異常花盐。

protected native Object clone() throws CloneNotSupportedException;

java 的克隆是淺克隆羡滑,碰到對象引用的時(shí)候,克隆出來的對象和原對象中的引用將指向同一個(gè)對象算芯。通常實(shí)現(xiàn)深克隆的方法是將對象進(jìn)行序列化柒昏,然后再進(jìn)行反序列化。

創(chuàng)建型模式總結(jié)

  • 簡單工廠模式最簡單也祠;
  • 工廠模式在簡單工廠模式的基礎(chǔ)上增加了選擇工廠的維度昙楚,需要第一步選擇合適的工廠近速;
  • 抽象工廠模式有產(chǎn)品族的概念诈嘿,如果各個(gè)產(chǎn)品是存在兼容性問題的,就要用抽象工廠模式削葱。
  • 單例模式就不說了奖亚,為了保證全局使用的是同一對象,一方面是安全性考慮析砸,一方面是為了節(jié)省資源昔字;
  • 建造者模式專門對付屬性很多的那種類,為了讓代碼更優(yōu)美首繁;
  • 原型模式用得最少作郭,了解和 Object 類中的 clone() 方法相關(guān)的知識即可。

結(jié)構(gòu)型模式

創(chuàng)建型模式用于創(chuàng)建一個(gè)對象弦疮,而結(jié)構(gòu)型模式旨在通過改變代碼結(jié)構(gòu)來達(dá)到解耦的目的夹攒,使得我們的代碼更容易擴(kuò)展和解耦。

代理模式

既然說是代理胁塞,那就要對客戶端隱藏真實(shí)實(shí)現(xiàn)咏尝,由代理來負(fù)責(zé)客戶端的所有請求。當(dāng)然啸罢,代理只是個(gè)代理编检,它不會完成實(shí)際的業(yè)務(wù)邏輯,而是一層皮而已扰才,但是對于客戶端來說允懂,它必須表現(xiàn)得就是客戶端需要的真實(shí)實(shí)現(xiàn)。

public interface FoodService {
 Food makeChicken();
 Food makeNoodle();
}

public class FoodServiceImpl implements FoodService {
 public Food makeChicken() {
 Food f = new Chicken()
 f.setChicken("1kg");
 f.setSpicy("1g");
 f.setSalt("3g");
 return f;
 }
 public Food makeNoodle() {
 Food f = new Noodle();
 f.setNoodle("500g");
 f.setSalt("5g");
 return f;
 }
}

// 代理要表現(xiàn)得“就像是”真實(shí)實(shí)現(xiàn)類衩匣,所以需要實(shí)現(xiàn) FoodService
public class FoodServiceProxy implements FoodService {

 // 內(nèi)部一定要有一個(gè)真實(shí)的實(shí)現(xiàn)類蕾总,當(dāng)然也可以通過構(gòu)造方法注入
 private FoodService foodService = new FoodServiceImpl();

 public Food makeChicken() {
 System.out.println("我們馬上要開始制作雞肉了");

 // 如果我們定義這句為核心代碼的話酣倾,那么,核心代碼是真實(shí)實(shí)現(xiàn)類做的谤专,
 // 代理只是在核心代碼前后做些“無足輕重”的事情
 Food food = foodService.makeChicken();

 System.out.println("雞肉制作完成啦躁锡,加點(diǎn)胡椒粉"); // 增強(qiáng)
 food.addCondiment("pepper");

 return food;
 }
 public Food makeNoodle() {
 System.out.println("準(zhǔn)備制作拉面~");
 Food food = foodService.makeNoodle();
 System.out.println("制作完成啦")
 return food;
 }
}

客戶端調(diào)用,注意置侍,我們要用代理來實(shí)例化接口:

// 這里用代理類來實(shí)例化
FoodService foodService = new FoodServiceProxy();
foodService.makeChicken();
proxy

代理模式說白了就是做 “方法包裝” 或做 “方法增強(qiáng)”映之。在面向切面編程中,其實(shí)就是動態(tài)代理的過程蜡坊。比如 Spring 中杠输,我們自己不定義代理類,但是 Spring 會幫我們動態(tài)來定義代理秕衙,然后把我們定義在 @Before蠢甲、@After、@Around 中的代碼邏輯動態(tài)添加到代理中据忘。

說到動態(tài)代理鹦牛,又可以展開說,Spring 中實(shí)現(xiàn)動態(tài)代理有兩種勇吊,一種是如果我們的類定義了接口曼追,如 UserService 接口和 UserServiceImpl 實(shí)現(xiàn),那么采用 JDK 的動態(tài)代理汉规,感興趣的讀者可以去看看 java.lang.reflect.Proxy 類的源碼礼殊;另一種是我們自己沒有定義接口的,Spring 會采用 CGLIB 進(jìn)行動態(tài)代理针史,它是一個(gè) jar 包晶伦,性能還不錯(cuò)。

適配器模式

適配器模式總體來說分三種:默認(rèn)適配器模式啄枕、對象適配器模式婚陪、類適配器模式。先不急著分清楚這幾個(gè)射亏,先看看例子再說近忙。

默認(rèn)適配器模式

首先,我們先看看最簡單的適配器模式默認(rèn)適配器模式(Default Adapter)是怎么樣的智润。

我們用 Appache commons-io 包中的 FileAlterationListener 做例子及舍,此接口定義了很多的方法,用于對文件或文件夾進(jìn)行監(jiān)控窟绷,一旦發(fā)生了對應(yīng)的操作锯玛,就會觸發(fā)相應(yīng)的方法。

public interface FileAlterationListener {
    void onStart(final FileAlterationObserver observer);
    void onDirectoryCreate(final File directory);
    void onDirectoryChange(final File directory);
    void onDirectoryDelete(final File directory);
    void onFileCreate(final File file);
    void onFileChange(final File file);
    void onFileDelete(final File file);
    void onStop(final FileAlterationObserver observer);
}

此接口的一大問題是抽象方法太多了,如果我們要用這個(gè)接口攘残,意味著我們要實(shí)現(xiàn)每一個(gè)抽象方法拙友,如果我們只是想要監(jiān)控文件夾中的文件創(chuàng)建文件刪除事件,可是我們還是不得不實(shí)現(xiàn)所有的方法歼郭,很明顯遗契,這不是我們想要的。

所以病曾,我們需要下面的一個(gè)適配器牍蜂,它用于實(shí)現(xiàn)上面的接口,但是所有的方法都是空方法泰涂,這樣鲫竞,我們就可以轉(zhuǎn)而定義自己的類來繼承下面這個(gè)類即可。

public class FileAlterationListenerAdaptor implements FileAlterationListener {

    public void onStart(final FileAlterationObserver observer) {
    }

    public void onDirectoryCreate(final File directory) {
    }

    public void onDirectoryChange(final File directory) {
    }

    public void onDirectoryDelete(final File directory) {
    }

    public void onFileCreate(final File file) {
    }

    public void onFileChange(final File file) {
    }

    public void onFileDelete(final File file) {
    }

    public void onStop(final FileAlterationObserver observer) {
    }
}

比如我們可以定義以下類逼蒙,我們僅僅需要實(shí)現(xiàn)我們想實(shí)現(xiàn)的方法就可以了:

public class FileMonitor extends FileAlterationListenerAdaptor {
    public void onFileCreate(final File file) {
        // 文件創(chuàng)建
        doSomething();
    }

    public void onFileDelete(final File file) {
        // 文件刪除
        doSomething();
    }
}

當(dāng)然从绘,上面說的只是適配器模式的其中一種,也是最簡單的一種是牢,無需多言僵井。下面,再介紹“正統(tǒng)的”適配器模式妖泄。

對象適配器模式

來看一個(gè)《Head First 設(shè)計(jì)模式》中的一個(gè)例子驹沿,我稍微修改了一下,看看怎么將雞適配成鴨蹈胡,這樣雞也能當(dāng)鴨來用。因?yàn)榕竽瑁F(xiàn)在鴨這個(gè)接口罚渐,我們沒有合適的實(shí)現(xiàn)類可以用,所以需要適配器驯妄。

public interface Duck {
 public void quack(); // 鴨的呱呱叫
 public void fly(); // 飛
}

public interface Cock {
 public void gobble(); // 雞的咕咕叫
 public void fly(); // 飛
}

public class WildCock implements Cock {
 public void gobble() {
 System.out.println("咕咕叫");
 }
 public void fly() {
 System.out.println("雞也會飛哦");
 }
}

鴨接口有 fly() 和 quare() 兩個(gè)方法荷并,雞 Cock 如果要冒充鴨,fly() 方法是現(xiàn)成的青扔,但是雞不會鴨的呱呱叫源织,沒有 quack() 方法。這個(gè)時(shí)候就需要適配了:

// 毫無疑問微猖,首先谈息,這個(gè)適配器肯定需要 implements Duck,這樣才能當(dāng)做鴨來用
public class CockAdapter implements Duck {

 Cock cock;
 // 構(gòu)造方法中需要一個(gè)雞的實(shí)例凛剥,此類就是將這只雞適配成鴨來用
 public CockAdapter(Cock cock) {
 this.cock = cock;
 }

 // 實(shí)現(xiàn)鴨的呱呱叫方法
 @Override
 public void quack() {
 // 內(nèi)部其實(shí)是一只雞的咕咕叫
 cock.gobble();
 }

 @Override
 public void fly() {
 cock.fly();
 }
}

客戶端調(diào)用很簡單了:

public static void main(String[] args) {
 // 有一只野雞
 Cock wildCock = new WildCock();
 // 成功將野雞適配成鴨
 Duck duck = new CockAdapter(wildCock);
 ...
}

到這里侠仇,大家也就知道了適配器模式是怎么回事了。無非是我們需要一只鴨,但是我們只有一只雞逻炊,這個(gè)時(shí)候就需要定義一個(gè)適配器互亮,由這個(gè)適配器來充當(dāng)鴨,但是適配器里面的方法還是由雞來實(shí)現(xiàn)的余素。

adapter-1

釋義:我現(xiàn)在手中只有SomeThing 但是我想用Target對象 我該如何是好豹休?

  1. 在適配器中注入我擁有的對象SomeThing ,即被適配對象桨吊;
  2. 在適配器中實(shí)現(xiàn)用自己的方法來目標(biāo)方法慕爬,即可達(dá)到目的;

類適配器模式

廢話少說屏积,直接上圖:

adapter-1

看到這個(gè)圖医窿,大家應(yīng)該很容易理解的吧,通過繼承的方法炊林,適配器自動獲得了所需要的大部分方法姥卢。這個(gè)時(shí)候,客戶端使用更加簡單渣聚,直接 Target t = new SomeAdapter(); 就可以了独榴。

適配器模式總結(jié)

  1. 類適配和對象適配的異同

    一個(gè)采用繼承,一個(gè)采用組合奕枝;

    類適配屬于靜態(tài)實(shí)現(xiàn)棺榔,對象適配屬于組合的動態(tài)實(shí)現(xiàn),對象適配需要多實(shí)例化一個(gè)對象隘道。

    總體來說症歇,對象適配用得比較多。

  2. 適配器模式和代理模式的異同

    比較這兩種模式谭梗,其實(shí)是比較對象適配器模式和代理模式忘晤,在代碼結(jié)構(gòu)上,它們很相似激捏,都需要一個(gè)具體的實(shí)現(xiàn)類的實(shí)例设塔。但是它們的目的不一樣,代理模式做的是增強(qiáng)原方法的活远舅;適配器做的是適配的活闰蛔,為的是提供“把雞包裝成鴨,然后當(dāng)做鴨來使用”图柏,而雞和鴨它們之間原本沒有繼承關(guān)系序六。

    adapter-5

裝飾模式

首先,我們先看一個(gè)簡單的圖爆办,看這個(gè)圖的時(shí)候难咕,了解下層次結(jié)構(gòu)就可以了:

decorator-1

我們來說說裝飾模式的出發(fā)點(diǎn),從圖中可以看到,接口 Component 其實(shí)已經(jīng)有了 ConcreteComponentAConcreteComponentB 兩個(gè)實(shí)現(xiàn)類了余佃,但是暮刃,如果我們要增強(qiáng)這兩個(gè)實(shí)現(xiàn)類的話,我們就可以采用裝飾模式爆土,用具體的裝飾器來裝飾實(shí)現(xiàn)類椭懊,以達(dá)到增強(qiáng)的目的。

最近大街上流行起來了“快樂檸檬”步势,我們把快樂檸檬的飲料分為三類:紅茶氧猬、綠茶、咖啡坏瘩,在這三大類的基礎(chǔ)上盅抚,又增加了許多的口味,什么金桔檸檬紅茶倔矾、金桔檸檬珍珠綠茶妄均、芒果紅茶、芒果綠茶哪自、芒果珍珠紅茶丰包、烤珍珠紅茶、烤珍珠芒果綠茶壤巷、椰香胚芽咖啡邑彪、焦糖可可咖啡等等,每家店都有很長的菜單胧华,但是仔細(xì)看下寄症,其實(shí)原料也沒幾樣,但是可以搭配出很多組合撑柔,如果顧客需要瘸爽,很多沒出現(xiàn)在菜單中的飲料他們也是可以做的。

在這個(gè)例子中铅忿,紅茶、綠茶灵汪、咖啡是最基礎(chǔ)的飲料檀训,其他的像金桔檸檬、芒果享言、珍珠峻凫、椰果、焦糖等都屬于裝飾用的览露。當(dāng)然荧琼,在開發(fā)中,我們確實(shí)可以像門店一樣,開發(fā)這些類:LemonBlackTea命锄、LemonGreenTea堰乔、MangoBlackTea、MangoLemonGreenTea......但是脐恩,很快我們就發(fā)現(xiàn)镐侯,這樣子干肯定是不行的,這會導(dǎo)致我們需要組合出所有的可能驶冒,而且如果客人需要在紅茶中加雙份檸檬怎么辦苟翻?三份檸檬怎么辦?

不說廢話了骗污,上代碼崇猫。

首先,定義飲料抽象基類:

public abstract class Beverage {
 // 返回描述
 public abstract String getDescription();
 // 返回價(jià)格
 public abstract double cost();
}

然后是三個(gè)基礎(chǔ)飲料實(shí)現(xiàn)類需忿,紅茶诅炉、綠茶和咖啡:

public class BlackTea extends Beverage {
 public String getDescription() {
 return "紅茶";
 }
 public double cost() {
 return 10;
 }
}
public class GreenTea extends Beverage {
 public String getDescription() {
 return "綠茶";
 }
 public double cost() {
 return 11;
 }
}
...// 咖啡省略

定義調(diào)料季研,也就是裝飾者的基類铲汪,此類必須繼承自 Beverage:

// 調(diào)料
public abstract class Condiment extends Beverage {

}

然后我們來定義檸檬、芒果等具體的調(diào)料沪猴,它們屬于裝飾者擅这,毫無疑問澈魄,這些調(diào)料肯定都需要繼承調(diào)料 Condiment 類:

public class Lemon extends Condiment {
 private Beverage bevarage;
 // 這里很關(guān)鍵,需要傳入具體的飲料仲翎,如需要傳入沒有被裝飾的紅茶或綠茶痹扇,
 // 當(dāng)然也可以傳入已經(jīng)裝飾好的芒果綠茶,這樣可以做芒果檸檬綠茶
 public Lemon(Beverage bevarage) {
 this.bevarage = bevarage;
 }
 public String getDescription() {
 // 裝飾
 return bevarage.getDescription() + ", 加檸檬";
 }
 public double cost() {
 // 裝飾
 return beverage.cost() + 2; // 加檸檬需要 2 元
 }
}

public class Mango extends Condiment {
 private Beverage bevarage;
 public Mango(Beverage bevarage) {
 this.bevarage = bevarage;
 }
 public String getDescription() {
 return bevarage.getDescription() + ", 加芒果";
 }
 public double cost() {
 return beverage.cost() + 3; // 加芒果需要 3 元
 }
}
...// 給每一種調(diào)料都加一個(gè)類

看客戶端調(diào)用:

public static void main(String[] args) {
 // 首先溯香,我們需要一個(gè)基礎(chǔ)飲料鲫构,紅茶、綠茶或咖啡
 Beverage beverage = new GreenTea();
 // 開始裝飾
 beverage = new Lemon(beverage); // 先加一份檸檬
 beverage = new Mongo(beverage); // 再加一份芒果

 System.out.println(beverage.getDescription() + " 價(jià)格:¥" + beverage.cost());
 //"綠茶, 加檸檬, 加芒果 價(jià)格:¥16"
}

如果我們需要 芒果-珍珠-雙份檸檬-紅茶

Beverage beverage = new Mongo(new Pearl(new Lemon(new Lemon(new BlackTea()))));

是不是很變態(tài)玫坛?

看看下圖可能會清晰一些:


decorator-2

到這里结笨,大家應(yīng)該已經(jīng)清楚裝飾模式了吧。

門面模式

門面模式(也叫外觀模式湿镀,F(xiàn)acade Pattern)在許多源碼中有使用炕吸,比如 slf4j 就可以理解為是門面模式的應(yīng)用。這是一個(gè)簡單的設(shè)計(jì)模式赫模,我們直接上代碼再說吧蒸矛。

首先胸嘴,我們定義一個(gè)接口:

public interface Shape {
   void draw();
}

定義幾個(gè)實(shí)現(xiàn)類:

public class Circle implements Shape {
    @Override
    public void draw() {
       System.out.println("Circle::draw()");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
       System.out.println("Rectangle::draw()");
    }
}

客戶端調(diào)用:

public static void main(String[] args) {
    // 畫一個(gè)圓形
      Shape circle = new Circle();
      circle.draw();

      // 畫一個(gè)長方形
      Shape rectangle = new Rectangle();
      rectangle.draw();
}

我們先定義一個(gè)門面:

public class ShapeMaker {
   private Shape circle;
   private Shape rectangle;
   private Shape square;

   public ShapeMaker() {
      circle = new Circle();
      rectangle = new Rectangle();
      square = new Square();
   }

  /**
   * 下面定義一堆方法劣像,具體應(yīng)該調(diào)用什么方法,由這個(gè)門面來決定
   */

   public void drawCircle(){
      circle.draw();
   }
   public void drawRectangle(){
      rectangle.draw();
   }
   public void drawSquare(){
      square.draw();
   }
}

看看現(xiàn)在客戶端怎么調(diào)用:

public static void main(String[] args) {
  ShapeMaker shapeMaker = new ShapeMaker();

  // 客戶端調(diào)用現(xiàn)在更加清晰了
  shapeMaker.drawCircle();
  shapeMaker.drawRectangle();
  shapeMaker.drawSquare();        
}

門面模式的優(yōu)點(diǎn)顯而易見驾讲,客戶端不再需要關(guān)注實(shí)例化時(shí)應(yīng)該使用哪個(gè)實(shí)現(xiàn)類席赂,直接調(diào)用門面提供的方法就可以了,因?yàn)殚T面類提供的方法的方法名對于客戶端來說已經(jīng)很友好了颅停。

總結(jié)

  • 代理模式是做方法增強(qiáng)的
  • 適配器模式是把雞包裝成鴨這種用來適配接口的
  • 裝飾模式從名字上就看得出來,適合于裝飾類或者說是增強(qiáng)類的場景
  • 門面模式的優(yōu)點(diǎn)是客戶端不需要關(guān)心實(shí)例化過程纸肉,只要調(diào)用需要的方法即可

行為型模式

行為型模式關(guān)注的是各個(gè)類之間的相互作用喊熟,將職責(zé)劃分清楚,使得我們的代碼更加地清晰芥牌。

策略模式

策略模式太常用了烦味,所以把它放到最前面進(jìn)行介紹。它比較簡單壁拉,我就不廢話谬俄,直接用代碼說事吧。

下面設(shè)計(jì)的場景是弃理,我們需要畫一個(gè)圖形溃论,可選的策略就是用紅色筆來畫,還是綠色筆來畫痘昌,或者藍(lán)色筆來畫钥勋。

首先,先定義一個(gè)策略接口:

public interface Strategy {
   public void draw(int radius, int x, int y);
}

然后我們定義具體的幾個(gè)策略:

public class RedPen implements Strategy {
   @Override
   public void draw(int radius, int x, int y) {
      System.out.println("用紅色筆畫圖辆苔,radius:" + radius + ", x:" + x + ", y:" + y);
   }
}
public class GreenPen implements Strategy {
   @Override
   public void draw(int radius, int x, int y) {
      System.out.println("用綠色筆畫圖笔诵,radius:" + radius + ", x:" + x + ", y:" + y);
   }
}
public class BluePen implements Strategy {
   @Override
   public void draw(int radius, int x, int y) {
      System.out.println("用藍(lán)色筆畫圖,radius:" + radius + ", x:" + x + ", y:" + y);
   }
}

使用策略的類:

public class Context {
 private Strategy strategy;

 public Context(Strategy strategy){
 this.strategy = strategy;
 }

 public int executeDraw(int radius, int x, int y){
 return strategy.draw(radius, x, y);
 }
}

放到一張圖上姑子,讓大家看得清晰些:

strategy-1

觀察者模式

觀察者模式對于我們來說,真是再簡單不過了测僵。無外乎兩個(gè)操作街佑,觀察者訂閱自己關(guān)心的主題和主題有數(shù)據(jù)變化后通知觀察者們谢翎。

首先,需要定義主題沐旨,每個(gè)主題需要持有觀察者列表的引用森逮,用于在數(shù)據(jù)變更的時(shí)候通知各個(gè)觀察者:

public class Subject {
    private List<Observer> observers = new ArrayList<Observer>();
    private int state;
    public int getState() {
        return state;
    }
    public void setState(int state) {
        this.state = state;
        // 數(shù)據(jù)已變更,通知觀察者們
        notifyAllObservers();
    }
    // 注冊觀察者
    public void attach(Observer observer) {
        observers.add(observer);
    }
    // 通知觀察者們
    public void notifyAllObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

定義觀察者接口:

public abstract class Observer {
    protected Subject subject;
    public abstract void update();
}

其實(shí)如果只有一個(gè)觀察者類的話磁携,接口都不用定義了褒侧,不過,通常場景下谊迄,既然用到了觀察者模式闷供,我們就是希望一個(gè)事件出來了,會有多個(gè)不同的類需要處理相應(yīng)的信息统诺。比如粮呢,訂單修改成功事件啄寡,我們希望發(fā)短信的類得到通知挺物、發(fā)郵件的類得到通知姻乓、處理物流信息的類得到通知等蹋岩。

我們來定義具體的幾個(gè)觀察者類:

public class BinaryObserver extends Observer {
    // 在構(gòu)造方法中進(jìn)行訂閱主題
    public BinaryObserver(Subject subject) {
        this.subject = subject;
        // 通常在構(gòu)造方法中將 this 發(fā)布出去的操作一定要小心
        this.subject.attach(this);
    }
    // 該方法由主題類在數(shù)據(jù)變更的時(shí)候進(jìn)行調(diào)用
    @Override
    public void update() {
        String result = Integer.toBinaryString(subject.getState());
        System.out.println("訂閱的數(shù)據(jù)發(fā)生變化剪个,新的數(shù)據(jù)處理為二進(jìn)制值為:" + result);
    }
}

public class HexaObserver extends Observer {
    public HexaObserver(Subject subject) {
        this.subject = subject;
        this.subject.attach(this);
    }
    @Override
    public void update() {
        String result = Integer.toHexString(subject.getState()).toUpperCase();
        System.out.println("訂閱的數(shù)據(jù)發(fā)生變化乎折,新的數(shù)據(jù)處理為十六進(jìn)制值為:" + result);
    }
}

客戶端使用也非常簡單:

public static void main(String[] args) {
    // 先定義一個(gè)主題
    Subject subject1 = new Subject();
    // 定義觀察者
    new BinaryObserver(subject1);
    new HexaObserver(subject1);

    // 模擬數(shù)據(jù)變更骂澄,這個(gè)時(shí)候坟冲,觀察者們的 update 方法將會被調(diào)用
    subject.setState(11);
}

output:

訂閱的數(shù)據(jù)發(fā)生變化,新的數(shù)據(jù)處理為二進(jìn)制值為:1011
訂閱的數(shù)據(jù)發(fā)生變化琳猫,新的數(shù)據(jù)處理為十六進(jìn)制值為:B

參考

https://javadoop.com/post/design-pattern

最后編輯于
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
  • 序言:七十年代末,一起剝皮案震驚了整個(gè)濱河市账千,隨后出現(xiàn)的幾起案子蕊爵,更是在濱河造成了極大的恐慌桦山,老刑警劉巖会放,帶你破解...
    沈念sama閱讀 216,402評論 6 499
  • 序言:濱河連續(xù)發(fā)生了三起死亡事件咧最,死亡現(xiàn)場離奇詭異矢沿,居然都是意外死亡捣鲸,警方通過查閱死者的電腦和手機(jī)栽惶,發(fā)現(xiàn)死者居然都...
    沈念sama閱讀 92,377評論 3 392
  • 文/潘曉璐 我一進(jìn)店門外厂,熙熙樓的掌柜王于貴愁眉苦臉地迎上來汁蝶,“玉大人穿仪,你說我怎么就攤上這事啊片∽瞎龋” “怎么了笤昨?”我有些...
    開封第一講書人閱讀 162,483評論 0 353
  • 文/不壞的土叔 我叫張陵瞒窒,是天一觀的道長崇裁。 經(jīng)常有香客問我拔稳,道長巴比,這世上最難降的妖魔是什么轻绞? 我笑而不...
    開封第一講書人閱讀 58,165評論 1 292
  • 正文 為了忘掉前任,我火速辦了婚禮晰赞,結(jié)果婚禮上掖鱼,老公的妹妹穿的比我還像新娘戏挡。我一直安慰自己褐墅,他們只是感情好,可當(dāng)我...
    茶點(diǎn)故事閱讀 67,176評論 6 388
  • 文/花漫 我一把揭開白布答捕。 她就那樣靜靜地躺著拱镐,像睡著了一般沃琅。 火紅的嫁衣襯著肌膚如雪益眉。 梳的紋絲不亂的頭發(fā)上郭脂,一...
    開封第一講書人閱讀 51,146評論 1 297
  • 那天朱庆,我揣著相機(jī)與錄音娱颊,去河邊找鬼箱硕。 笑死剧罩,一個(gè)胖子當(dāng)著我的面吹牛惠昔,可吹牛的內(nèi)容都是我干的镇防。 我是一名探鬼主播来氧,決...
    沈念sama閱讀 40,032評論 3 417
  • 文/蒼蘭香墨 我猛地睜開眼中狂,長吁一口氣:“原來是場噩夢啊……” “哼胃榕!你這毒婦竟也來了勤晚?” 一聲冷哼從身側(cè)響起,我...
    開封第一講書人閱讀 38,896評論 0 274
  • 序言:老撾萬榮一對情侶失蹤膜赃,失蹤者是張志新(化名)和其女友劉穎跳座,沒想到半個(gè)月后疲眷,有當(dāng)?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體狂丝,經(jīng)...
    沈念sama閱讀 45,311評論 1 310
  • 正文 獨(dú)居荒郊野嶺守林人離奇死亡几颜,尸身上長有42處帶血的膿包…… 初始之章·張勛 以下內(nèi)容為張勛視角 年9月15日...
    茶點(diǎn)故事閱讀 37,536評論 2 332
  • 正文 我和宋清朗相戀三年蛋哭,在試婚紗的時(shí)候發(fā)現(xiàn)自己被綠了谆趾。 大學(xué)時(shí)的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片沪蓬。...
    茶點(diǎn)故事閱讀 39,696評論 1 348
  • 序言:一個(gè)原本活蹦亂跳的男人離奇死亡,死狀恐怖,靈堂內(nèi)的尸體忽然破棺而出峡眶,到底是詐尸還是另有隱情辫樱,我是刑警寧澤狮暑,帶...
    沈念sama閱讀 35,413評論 5 343
  • 正文 年R本政府宣布搬男,位于F島的核電站彭沼,受9級特大地震影響姓惑,放射性物質(zhì)發(fā)生泄漏于毙。R本人自食惡果不足惜,卻給世界環(huán)境...
    茶點(diǎn)故事閱讀 41,008評論 3 325
  • 文/蒙蒙 一脖旱、第九天 我趴在偏房一處隱蔽的房頂上張望夯缺。 院中可真熱鬧踊兜,春花似錦捏境、人聲如沸垫言。這莊子的主人今日做“春日...
    開封第一講書人閱讀 31,659評論 0 22
  • 文/蒼蘭香墨 我抬頭看了看天上的太陽担忧。三九已至瓶盛,卻和暖如春示罗,著一層夾襖步出監(jiān)牢的瞬間蚜点,已是汗流浹背绍绘。 一陣腳步聲響...
    開封第一講書人閱讀 32,815評論 1 269
  • 我被黑心中介騙來泰國打工脯倒, 沒想到剛下飛機(jī)就差點(diǎn)兒被人妖公主榨干…… 1. 我叫王不留藻丢,地道東北人悠反。 一個(gè)月前我還...
    沈念sama閱讀 47,698評論 2 368
  • 正文 我出身青樓斋否,卻偏偏與公主長得像茵臭,于是被迫代替她去往敵國和親旦委。 傳聞我的和親對象是個(gè)殘疾皇子雏亚,可洞房花燭夜當(dāng)晚...
    茶點(diǎn)故事閱讀 44,592評論 2 353

推薦閱讀更多精彩內(nèi)容