摘要：提供酒店相關的接口返回該時間段有效的酒店提供航班相關的接口返回該時間段有效的航班提供一個旅行對外的接口，一次返回酒店和航班信息調用旅行外觀模式享元模式享元模式主要用于減少創建對象的數量，以減少內存占用和提高性能。

組合模式看起來就像對象組的樹形結構，一個對象里面包含一個或一組其他的對象。它是屬于結構型模式。
例如，一個公司包括很多個部門，每個部門又包括很多人，這個用數據結構來表示就是樹形結構，實際上也是用到來組合模式，多個人組成一個部門，多個部門組成一個公司。

例如，我們用下面這個公司、部門、員工的例子來更好的理解組合模式。

class Company {
    private String name;
    private List depts;
}

class Dept {
    private String name;
    private List users;
}

class User {
    private String name;
}

裝飾器設計模式允許我們動態地向對象添加功能和行為，而不會影響同一類中其他現有對象的行為。并且可以根據我們的要求和選擇將此自定義功能應用于單個對象。
假如使用繼承來擴展類的行為，這發生在編譯期，該類的所有實例都獲得擴展行為。

裝飾器設計模式的特點：
它允許我們在運行時向對象（而不是類）添加功能。
它是一種結構模式，它為現有類提供了一個包裝器。
它使用抽象類或接口與組合來實現包裝器。
它創建裝飾器類，它包裝原始類并通過保持類方法的簽名不變來提供其他功能。
它最常用于應用單一責任原則，因為我們將功能劃分為具有獨特關注區域的類。

例如，我們用下面這個畫圖形的例子來更好的理解裝飾模式。

//定義一個形狀的接口
public interface Shape {
    void draw();
    void resize();
}
//一個畫圓的實現
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
    @Override
    public void resize() {
        System.out.println("Resizing Circle");
    }
}
//一個畫矩形的實現
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Rectangle");
    }
    @Override
    public void resize() {
        System.out.println("Resizing Rectangle");
    }
}
//定義一個形狀的裝飾器抽象類，并用組合模式定義一個形狀的屬性
public abstract class ShapeDecorator implements Shape {
    protected Shape decoratedShape;
    public ShapeDecorator(Shape decoratedShape) {
        super();
        this.decoratedShape = decoratedShape;
    }
}
//顏色的枚舉
public enum Color {
    RED,
    GREEN,
    BLUE
}
//線條樣式的枚舉
public enum LineStyle {
    SOLID,
    DASH,
    DOT
}
//定義一個填充顏色的實現類實現裝飾器，并重寫 draw() 方法，resize() 方法我們可以保持不變，也可以自定義，看使用場景
public class FillColorDecorator extends ShapeDecorator {
    protected Color color;
    public FillColorDecorator(Shape decoratedShape, Color color) {
        super(decoratedShape);
        this.color = color;
    }
    @Override
    public void draw() {
        decoratedShape.draw();
        System.out.println("Fill Color: " + color);
    }
    @Override
    public void resize() {
      decoratedShape.resize();
    }
}
//定義一個線條樣式的實現類實現裝飾器，并重寫 draw() 方法，resize() 方法我們可以保持不變，也可以自定義，看使用場景
public class LineStyleDecorator extends ShapeDecorator {
    protected LineStyle style;
    public LineStyleDecorator(Shape decoratedShape, LineStyle style) {
        super(decoratedShape);
        this.style = style;
    }
    @Override
    public void draw() {
        decoratedShape.draw();
        System.out.println("Line Style: " + style);
    }
    // 
    @Override
    public void resize() {
        decoratedShape.resize();
    }
}
//使用裝飾器模式
public class Client {
    public static void main(String[] args) {
        //在使用時可以任意組裝，提升代碼靈活性和擴展性。
        Shape circle = new FillColorDecorator(new LineStyleDecorator(new Circle(), LineStyle.DASH), Color.RED);
        circle.draw();
    }
}

它提供了一個可以訪問系統的接口，這個接口里面的實現可能很復雜，調用了其他多個接口，我們并不知道它里面的具體實現，隱藏了系統的復雜性。它屬于結構型模式。

它的優點：
1、減少系統相互依賴。
2、提高靈活性。
3、提高了安全性。

它的缺點：
不符合開閉原則，如果要改東西很麻煩，繼承重寫都不合適。

以旅行社網站為例，它可以預訂酒店和航班，我們來更好的理解下這個模式。

//提供酒店相關的接口
public class HotelBooker{  
    public ArrayList getHotelNamesFor(Date from, Date to)   {  
    //返回該時間段有效的酒店
    }
}
//提供航班相關的接口
public class FlightBooker{  
    public ArrayList getFlightsFor(Date from, Date to)   { 
    //返回該時間段有效的航班
    }
}
//提供一個旅行對外的接口，一次返回酒店和航班信息
public class TravelFacade{   
    private HotelBooker hotelBooker;   
    private FlightBooker flightBooker;   
    public void getFlightsAndHotels(Date from, Data to)  {      ArrayList flights = flightBooker.getFlightsFor(from, to);                       ArrayList hotels = hotelBooker.getHotelsFor(from, to);         
    }
}
//調用旅行外觀模式
public class Client{   
    public static void main(String[] args)   {   
        TravelFacade facade = new TravelFacade();         
        facade.getFlightsAndHotels(from, to);   
    }
}

享元模式主要用于減少創建對象的數量，以減少內存占用和提高性能。使許多細粒度對象的重用，使得大量對象的利用更加有效。它屬于結構型模式。

它的優點：
大大減少對象的創建，降低系統的內存，使效率提高。

它的缺點：
因為一個對象大家共享，最好就不要有狀態區分，假如有狀態的話，
需要分離出外部狀態和內部狀態，而且外部狀態具有固有化的性質，不應該隨著內部狀態的變化而變化，否則會造成系統的混亂。

例如，我們用一個畫線條的例子來更好的理解這個模式。

//定義一個畫線條的接口
public interface LineFlyweight{
    public Color getColor();
    public void draw(Point location);
}
//定義一個畫線條的實現
public class Line implements LineFlyweight{
    private Color color; 
    public Line(Color c){
        color = c;
    }
    public Color getColor(){
        return color;
    }
    public void draw(Point location){
        //實現
    }
}
//定一個畫線條的工廠類，根據顏色來獲取線條，并且把不同顏色的線存儲在一個 pool 中，方便下次直接使用
public class LineFlyweightFactory{
    private List pool; 
    public LineFlyweightFactory(){
        pool = new ArrayList();
    }
    public LineFlyweight getLine(Color c){
        //循環檢查這個顏色的線是否存在，存在直接返回
        for(LineFlyweight line: pool){
            if(line.getColor().equals(c)){
                return line;
            }
        }
        //假如不存在，就創建一個放入這個 pool 中，方便下次直接使用
        LineFlyweight line = new Line(c);
        pool.add(line);
        return line;
    }
}
//調用享元模式
public class Client{   
    public static void main(String[] args)   {  
        //調用
        LineFlyweightFactory factory = new LineFlyweightFactory(); 
        LineFlyweight line = factory.getLine(Color.RED); 
        LineFlyweight line2 = factory.getLine(Color.RED); 
        line.draw(new Point(100, 100));
        line2.draw(new Point(200, 100));
    }
}

它通過一個代理類對外提供訪問，代理類在真正調用實現類。對外部來說，并不知道真正實現類的詳情，提高類系統的安全性。我們可以在代理類里做一系列攔截，把異常的請求都提前處理掉，擴展性很高。它屬于結構型模式。

它的優點：
1、職責清晰。
2、高擴展性。
3、更安全。

它的缺點：
1、由于在客戶端和真實主題之間增加了代理對象，因此可能會造成請求的處理速度變慢。
2、實現代理模式需要額外的工作，有些代理模式的實現非常復雜。

例如，我們用下面這個代理顯示圖片的例子來更好的理解代理模式。

//定義的圖片接口
public interface Image{ 
  public void displayImage();
}
//真正的實現類
public class RealImage implements Image{   
    public RealImage(URL url)   {      
        //加載這個圖片    
        loadImage(url);   
    }   
    public void displayImage()   {       
    //顯示這個圖片 
    }   
    private void loadImage(URL url)  {      
     
    }
}
//代理類
public class ProxyImage implements Image{    
    private URL url;     
    public ProxyImage(URL url)    {       
        this.url = url;    
    }    
    //this method delegates to the real image    
    public void displayImage()   {        
        RealImage real = new RealImage(url);  
        real.displayImage();    
    }
}
//使用代理模式
public class Client {
   public static void main(String[] args) {
      Image image = new ProxyImage("test.png");
      image.display();  
   }
}

代理模式分為靜態代理和動態代理，靜態代理的真正實現類是提前寫好并且編譯好的，動態代理的真正實現類是運行是生成并且編譯的，上面的例子使用的是靜態代理。
動態代理又分為 JDK動態代理 和 CGLIB動態代理，JDK動態代理是基于接口的動態代理，CGLIB動態代理是基于類的代理。有興趣的可以找下相關資料。

責任鏈模式用于管理對象之間的算法，關系和責任，通過將多個不同處理對象鏈接在一起處理請求，降低耦合度，提高系統靈活性。它屬于行為型模式。

它的優點：
1、降低耦合度。
2、簡化了對象。
3、增強給對象指派職責的靈活性。
4、增加新的請求處理類很方便。

它的缺點：
1、系統性能將受到一定影響，而且在進行代碼調試時不太方便，可能會造成循環調用。
2、可能不容易觀察運行時的特征，不方便排錯。

例如，我們用下面這個記錄日志的例子來更好的理解責任鏈模式。

//定義一個抽象的日志接口，并且提供一個可以設置下一個處理日志對象的方法
public abstract class AbstractLogger {
   public static int INFO = 1;
   public static int DEBUG = 2;
   public static int ERROR = 3;
   protected int level;
   //責任鏈中的下一個元素
   protected AbstractLogger nextLogger;
   public void setNextLogger(AbstractLogger nextLogger){
      this.nextLogger = nextLogger;
   }
   public void logMessage(int level, String message){
      if(this.level <= level){
         write(message);
      }
      if(nextLogger !=null){
         nextLogger.logMessage(level, message);
      }
   }
    //抽象方法
   abstract protected void write(String message);
}
//定義一個標準日志的實現類
public class ConsoleLogger extends AbstractLogger {
   public ConsoleLogger(int level){
      this.level = level;
   }
   @Override
   protected void write(String message) {    
      System.out.println("Standard Console::Logger: " + message);
   }
}
//定義一個錯誤日志的實現類
public class ErrorLogger extends AbstractLogger {
   public ErrorLogger(int level){
      this.level = level;
   }
   @Override
   protected void write(String message) {    
      System.out.println("Error Console::Logger: " + message);
   }
}
//定義一個文件日志的實現類
public class FileLogger extends AbstractLogger {
   public FileLogger(int level){
      this.level = level;
   }
   @Override
   protected void write(String message) {    
      System.out.println("File::Logger: " + message);
   }
}
//使用責任鏈模式
public class Client {
    //設置責任鏈的調用順序
   private static AbstractLogger getChainOfLoggers(){
      AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
      AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
      AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);
      
      errorLogger.setNextLogger(fileLogger);
      fileLogger.setNextLogger(consoleLogger);
      return errorLogger;  
   }
 
   public static void main(String[] args) {
      AbstractLogger loggerChain = getChainOfLoggers();
      loggerChain.logMessage(AbstractLogger.INFO, "info level information.");
      loggerChain.logMessage(AbstractLogger.DEBUG, 
         "debug level information.");
      loggerChain.logMessage(AbstractLogger.ERROR, 
         "error information.");
   }
}

命令模式是請求以命令的形式包裹在對象中，并傳給調用對象。調用對象尋找可以處理該命令的合適的對象，并把該命令傳給相應的對象，該對象執行命令。它屬于行為型模式。

它的優點：
1、降低了系統耦合度。
2、新的命令可以很容易添加到系統中去。

它的缺點：
使用命令模式可能會導致某些系統有過多的具體命令類。

例如，我們用下面這個開關燈的例子來更好的理解命令模式。

// 定義執行命令接口
public interface Command{
  public void execute();
}
//開燈命令實現類
public class LightOnCommand implements Command{
  Light light;
  public LightOnCommand(Light light){
    this.light = light;
  }
  public void execute(){
    light.switchOn();
  }
}
//關燈命令實現類
public class LightOffCommand implements Command{
  Light light;
  public LightOffCommand(Light light){
    this.light = light;
  }
  public void execute(){
    light.switchOff();
  }
}
//真正開關燈的類
public class Light{
  private boolean on;
  public void switchOn(){
    on = true;
  }
  public void switchOff(){
    on = false;
  }
}
//根據不同命令執行開關燈
public class RemoteControl{
  private Command command;
  public void setCommand(Command command){
    this.command = command;
  }
  public void pressButton(){
    command.execute();
  }
}
//調用命令模式
public class Client{
  public static void main(String[] args){
    RemoteControl control = new RemoteControl();
    Light light = new Light();
    Command lightsOn = new LightsOnCommand(light);
    Command lightsOff = new LightsOffCommand(light);
    //設置開燈命令來開燈
    control.setCommand(lightsOn);
    control.pressButton();
    //設置關燈命令來關燈
    control.setCommand(lightsOff);
    control.pressButton();
  }
}

解釋器模式是給定一種語言，定義其語法以及使用該語法來表示語言中句子的解釋器。這種模式實現了一個表達式接口，該接口解釋一個特定的上下文。這種模式被用在 SQL 解析、符號處理引擎等。它屬于行為型模式。

它的優點：
1、可擴展性比較好，靈活。
2、增加了新的解釋表達式的方式。
3、易于實現簡單語法。

它的缺點：
1、可利用場景比較少。
2、對于復雜的文法比較難維護。
3、解釋器模式會引起類膨脹。
4、解釋器模式采用遞歸調用方法。

例如，我們用下面這個簡單規則表達式的例子來更好的理解解釋器模式。

//定義一個表達式接口
public interface Expression {
   public boolean interpret(String context);
}
//定義一個基本規則的實現，輸入的內容包含初始化的內容時，返回 true
public class TerminalExpression implements Expression {
   private String data;
   public TerminalExpression(String data){
      this.data = data; 
   }
   @Override
   public boolean interpret(String context) {
      if(context.contains(data)){
         return true;
      }
      return false;
   }
}
//定義一個或者規則的實現，輸入的內容包含初始化時任意一個內容時，返回 true，否則 false
public class OrExpression implements Expression {
   private Expression expr1 = null;
   private Expression expr2 = null;
   public OrExpression(Expression expr1, Expression expr2) {
      this.expr1 = expr1;
      this.expr2 = expr2;
   }
   @Override
   public boolean interpret(String context) {      
      return expr1.interpret(context) || expr2.interpret(context);
   }
}
//定義一個并且規則的實現，輸入的內容同時包含初始化時兩個內容時，返回 true，否則 false
public class AndExpression implements Expression {
   private Expression expr1 = null;
   private Expression expr2 = null;
   public AndExpression(Expression expr1, Expression expr2) { 
      this.expr1 = expr1;
      this.expr2 = expr2;
   }
 
   @Override
   public boolean interpret(String context) {      
      return expr1.interpret(context) && expr2.interpret(context);
   }
}
//調用規則表達式
public class Client {
   //規則：Robert 和 John 是男性，輸入只要滿足其中一個規則就行
   public static Expression getMaleExpression(){
      Expression robert = new TerminalExpression("Robert");
      Expression john = new TerminalExpression("John");
      return new OrExpression(robert, john);    
   }
   //規則：Julie 是一個已婚的女性，輸入只要滿足兩個規則
   public static Expression getMarriedWomanExpression(){
      Expression julie = new TerminalExpression("Julie");
      Expression married = new TerminalExpression("Married");
      return new AndExpression(julie, married);    
   }
 
   public static void main(String[] args) {
      Expression isMale = getMaleExpression();
      Expression isMarriedWoman = getMarriedWomanExpression();
 
      System.out.println("John is male? " + isMale.interpret("John"));
      System.out.println("Julie is a married women? " 
      + isMarriedWoman.interpret("Married Julie"));
   }
}

最后，還是那句話，每種設計模式有它自己的好處，也有它的壞處。在寫代碼時，多思考，想好在寫，免得返工，先從思維方式上改變。使用單一原則，一個類，一個方法只做一件事情，這樣方便維護，耦合低，可擴展。

PS:
清山綠水始于塵，博學多識貴于勤。
微信公眾號：「清塵閑聊」。
歡迎一起談天說地，聊代碼。