深入剖析GOF23設計模式

一、單例模式

單例模式是一種創建型設計模式，可以保證一個類僅有一個實例，並提供了全局訪問點。

單例模式的核心是構造函數是私有的，外界無法通過構造函數來創建實例。並且提供了一個靜態方法來獲取單例對象。這樣就可以確保在整個應用中，只有一個該類的實例對象。

public class Singleton{
  private static volatile Singleton instance = null;
  private Singleton(){}
  public static Singleton getInstance() {
    if (instance == null) {
      synchronized (Singleton.class) {
        if (instance == null) {
          instance = new Singleton();
        }
      }
    }
    return instance;
  }
}

單例模式適用於全局開關、日誌記錄、線程池等場景。

二、工廠模式

工廠模式是一種創建型設計模式，可以創建一組相關的對象，而無需指定其具體類。

工廠模式分為簡單工廠模式、工廠方法模式和抽象工廠模式。

簡單工廠模式：

public interface Animal{
  void sound();
}

public class Dog implements Animal{
  public void sound(){
     System.out.println("Dog: Bark");
  }
}

public class Cat implements Animal{
  public void sound(){
     System.out.println("Cat: Meow");
  }
}

public class AnimalFactory{
  public static Animal createAnimal(String type){
     switch(type){
        case "dog":
           return new Dog();
        case "cat":
           return new Cat();
        default:
           throw new IllegalArgumentException("Invalid animal type: " + type);
    }
  }
}

工廠方法模式：

public interface Animal{
  void sound();
}

public class Dog implements Animal{
  public void sound(){
     System.out.println("Dog: Bark");
  }
}

public class Cat implements Animal{
  public void sound(){
     System.out.println("Cat: Meow");
  }
}

public interface AnimalFactory{
  Animal createAnimal();
}

public class DogFactory implements AnimalFactory{
  public Animal createAnimal(){
    return new Dog();
  }
}

public class CatFactory implements AnimalFactory{
  public Animal createAnimal(){
    return new Cat();
  }
}

抽象工廠模式：

public interface Animal{
  void sound();
}

public class Dog implements Animal{
  public void sound(){
     System.out.println("Dog: Bark");
  }
}

public class Cat implements Animal{
  public void sound(){
     System.out.println("Cat: Meow");
  }
}

public interface AnimalFactory{
  Animal createAnimal();
}

public class DomesticAnimalFactory implements AnimalFactory{
  public Animal createAnimal(){
    return new Dog();
  }
}

public class WildAnimalFactory implements AnimalFactory{
  public Animal createAnimal(){
    return new Lion();
  }
}

工廠模式適用於創建複雜對象、創建可擴展組件的場景。

三、觀察者模式

觀察者模式是一種行為型設計模式，當對象之間存在一對多關係時，當一個對象狀態變化時，所有依賴它的對象都將得到通知。

import java.util.ArrayList;
import java.util.List;

public interface Observer{
  void update(String message);
}

public class User implements Observer{
  private String name;
  
  public User(String name){
    this.name = name;
  }
  
  public void update(String message){
    System.out.println(name + ": " + message);
  }
}

public interface Subject{
  void attach(Observer observer);
  void detach(Observer observer);
  void notifyObservers(String message);
}

public class News implements Subject{
  private List observers = new ArrayList();
  
  public void attach(Observer observer){
    observers.add(observer);
  }
  
  public void detach(Observer observer){
    observers.remove(observer);
  }
  
  public void notifyObservers(String message){
    for(Observer observer : observers){
      observer.update(message);
    }
  }
  
  public void publish(String message){
    System.out.println("Publish: " + message);
    notifyObservers("News: " + message);
  }
}

觀察者模式適用於發佈訂閱模型、多個對象間解耦、動態更新

四、裝飾器模式

裝飾器模式是一種行為型設計模式，可以動態地為一個對象增加額外的職責，而無需修改它的代碼。

public interface Coffee{
  String getDescription();
  double getCost();
}

public class Espresso implements Coffee{
  public String getDescription(){
    return "Espresso";
  }
  
  public double getCost(){
    return 1.99;
  }
}

public abstract class CoffeeDecorator implements Coffee{
  protected Coffee coffee;
  
  public CoffeeDecorator(Coffee coffee){
    this.coffee = coffee;
  }
  
  public String getDescription(){
    return coffee.getDescription();
  }
  
  public double getCost(){
    return coffee.getCost();
  }
}

public class Milk extends CoffeeDecorator{
  public Milk(Coffee coffee){
    super(coffee);
  }
  
  public String getDescription(){
    return coffee.getDescription() + ", Milk";
  }
  
  public double getCost(){
    return coffee.getCost() + 0.5;
  }
}

public class Mocha extends CoffeeDecorator{
  public Mocha(Coffee coffee){
    super(coffee);
  }
  
  public String getDescription(){
    return coffee.getDescription() + ", Mocha";
  }
  
  public double getCost(){
    return coffee.getCost() + 1.0;
  }
}

裝飾器模式適用於動態地為一個對象增加額外的職責，是繼承關係的一個替代方案。

五、適配器模式

適配器模式是一種結構型設計模式，可以將一個類的接口轉換成客戶端需要的另一個接口。

public interface MediaPlayer{
  void play(String audioType, String fileName);
}

public interface AdvancedMediaPlayer{
  void playVlc(String fileName);
  void playMp4(String fileName);
}

public class VlcPlayer implements AdvancedMediaPlayer{
  public void playVlc(String fileName){
    System.out.println("Playing vlc file. Name: "+ fileName); 
  }
  public void playMp4(String fileName){}
}

public class Mp4Player implements AdvancedMediaPlayer{
  public void playVlc(String fileName){}
  public void playMp4(String fileName){
    System.out.println("Playing mp4 file. Name: "+ fileName); 
  }
}

public class MediaAdapter implements MediaPlayer{
  AdvancedMediaPlayer advancedMusicPlayer;
  
  public MediaAdapter(String audioType){
    if(audioType.equalsIgnoreCase("vlc") ){
      advancedMusicPlayer = new VlcPlayer();       
    }
    else if (audioType.equalsIgnoreCase("mp4")){
      advancedMusicPlayer = new Mp4Player();
    }
  }

  public void play(String audioType, String fileName) {
    if(audioType.equalsIgnoreCase("vlc")){
      advancedMusicPlayer.playVlc(fileName);
    }
    else if(audioType.equalsIgnoreCase("mp4")){
      advancedMusicPlayer.playMp4(fileName);
    }
  }
}

public class AudioPlayer implements MediaPlayer{
  MediaAdapter mediaAdapter; 

  public void play(String audioType, String fileName) {    
    if(audioType.equalsIgnoreCase("mp3")){
      System.out.println("Playing mp3 file. Name: " + fileName);           
    }
    else if(audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")){
      mediaAdapter = new MediaAdapter(audioType);
      mediaAdapter.play(audioType, fileName);
    }
    else{
      System.out.println("Invalid media. " + audioType + " format not supported");
    }
  }
}

適配器模式適用於已有的接口無法滿足需求的場景，通過定義新的接口轉化使用。