【持續更新】簡單記錄一下常用的設計模式

設計模式

單例模式

• Double Check Lock

public static Singleton getInstance(){
  if(mInstance == null){
    synchronized(Singleton.class){
      if(mInstance == null){
        mInstance = new Singleton();
      }
    }
  }
  retuen mInstance;
}

• 靜態內部類

  public static Singleton getInstance(){
    retuen SingletonHolder.sInstance;
  }

  private static class SingletonHolder{
    private static final Singleton sInstance = new Singleton();
  }

​

Builder模式

1. 存儲參數
2. 設置參數，return this
3. new 對象，傳遞參數
4. 返回

原型模式

• 使用
  
  • 重寫clone()
  • 淺拷貝：拷貝對象無法修改原型對象的字段，保證了安全性（除了引用型字段，多以也要拷貝引用性字段）
  • 深拷貝： 對拷貝對象的引用型字段也要拷貝

工廠方法模式

//抽象產品類
public abstract class Dialog(){
  public abstract void show();
}

public class DialogA extends Dialog{
  @Override
  public void show(){
    //showA
  }
}

//抽象工廠
public abstract class Factory{
  public abstract <T extends Dialog>T createDialog(Class<T> clazz);
}

public class DialogAFactory extends Factory{
  public <T extends Dialog>T createDialog(Class<T> clazz){
    Dialog dialog = null;
    try{
      dialog = (Dialog)Class.forName(clazz.getName()).newInstance();
    }catch(Exception e){
      ...
    }
    return (T)dialog;

  }
} 

//使用
public static void main(String[] args){
  Factory factory = new DialogFactory();
  DialogA a = factory.createDialog(DialogA.class);
  a.show();
}

抽象工廠模式

• 角色
  
  • 抽身產品接口
  • 具體產品類
  • 抽象工廠類
  • 具體工廠類：每一個產品不同組成不同具體工廠
• 面向接口編程，但是工廠類過多，不易拓展

策略模式

• 角色
  
  • 策略的抽象
  • 具體的策略實現
  • 操作策略的具體實現
• 代碼

//策略抽象接口
public interface CalculateStrategy{
  int calculatePrice(int km);
}
//具體策略
public class BusStrategy implements CalculateStrategy{

  @Override
  public int calculatePrice(int km){
    //...
    return busPrice;
  }

}

//Context角色
public class Context{
    private CalculateStrategy cs;
    public void seCalculateStrategy(CalculateStrategy cs){
      this.cs = cs;
    }

    public int calculatePrice(int km){
      return cs.calculatePrice(km);
    }

    public static void main(String[] args){
      Context context = new Context();
      context.setCalculateStrategy(new BusStrategy());
      context.calculatePrice(15);
    }

}

狀態模式

• 角色
  
  • 抽象狀態類或接口：設置狀態下的行爲
  • 具體狀態類或接口：不同狀態不同行爲
  • Context環境類
• 代碼:

//抽象狀態：定義行爲
public interface UserState{
    public void forward();

    public void comment();
}

//具體狀態：已登錄
public class LoginedState implements UserState{
  @Override
  public void forward(){
    //轉發
  }
  public void comment(){
    //評論
  }
}

//具體狀態：未登錄
public class LogoutState implements UserState{
  @Override
  public void forward(){
    //去登陸
  }
  public void comment(){
    //去登陸
  }
}
//使用
public class LoginContext{
  private UserState mUserState = new LogoutState();
  private LoginContext(){}

  private static LoginContext mLoginContext = new LoginContext();
  public static LoginContext getInstance(){
    return mLoginContext();
  }

  public void setState(UserState userState){
    mUserState = userState;
  }

  public void forward(){
    mUserState.forward();
  }
  public void comment(){
    mUserState.comment();
  }

}

責任鏈模式

• 角色
  
  • 抽象處理者
  • 抽象請求者
  • 具體處理者
  • 具體請求者
• 代碼

//抽象處理者
public abstract class AbstractHandler{
  protect AbstractHandler nextHandler;

  public final void handleRequest(AbstractRequest request){
    if(getHandlerLevel() == request.getRequestLevel()){
        handleRequest(request);
    }else{
      if(nextHandler != null){
        nextHandler.handleRequest(request);
      }else{
        System.out.println("All of handler can not handle the request");
      }
    }

  }

  protected abstract int getHandlerLevel();
  protected abstract void handleRequest(AbstractRequest request);

}

//抽象請求者
public abstract class AbstractRequest{
  private Object obj;
  public AbstractRequest (Object obj){
    this.obj = obj;
  }

  public Object getContent(){
    return obj;
  }
  public abstract int getRequestLevel();

}

//具體處理者
public class Handler1 extends AbstractHandler{
  @Override
  protected int getHandleLevel(){
    return 1;
  }

  @Override
  protected void handleRequest(AbstractRequest request){
    System.out.println("handler1 handle the request!"+request.getRequestLevel);
  }

}

//具體請求者
public class Request1 extends AbstractRequest{
  public Request1(Object obj){
    super(obj);
  }

  @Override
  public int getReqestLevel(){
    return 1;
  }
}

//使用
public static void main(String[] args){
  AbstractHandler handler1 = new Handler1();
  AbstractHandler handler2 = new Handler2();

  handler1.nextHandler = handler2;
  handler1.handlerRequest(new Request1("Request1"));
}

解釋器模式

• 角色
  
  • 抽象表達式，抽象的解釋方法
  • 終結符表達式
  • 非終結符表達式
  • 環境類Context
  • 客戶類Client
• 一般很少用

命令模式

• 角色
  
  • 接收者，具體邏輯
  • 命令抽象接口
  • 具體命令
  • 請求者
  • 客戶端
• 將請求封裝成一個對象，從而使用不同請求把客戶端參數化：取消、日誌、事務

觀察者模式

• 角色
  
  • 抽象主題，被觀察者Observable
  • 具體主題，Concrete Observable
  • 抽象觀察者，Obsever
  • 具體觀察者
• 對象間一種一對多的依賴關係，每當一個對象改變狀態，則所有依賴於它的對象都會通知並被自動更新
• 代碼：

//具體主題
public class Website extends Observable{
  public void postNewPublication(String content){
    setChanged();
    notifyObserver(content);
  }
}

//具體觀察者
public class Subscriber extends Observer{
  @Override
    public void update(observable 0,Object content){
      System.out.println("更新的內容是："+content);
    }
}

//使用
main：
    Website web = new Website();
    Subscriber sub = new Subscriber();
    web.addObserver(sub);
    web.postNewPublication("內容更新了！");