摘要：創(chuàng)建型設(shè)計模式結(jié)構(gòu)型設(shè)計模式行為型設(shè)計模式結(jié)構(gòu)型設(shè)計模式簡而言之結(jié)構(gòu)模式主要涉及對象的組成，或者是實體如何相互使用。

1.創(chuàng)建型設(shè)計模式
2.結(jié)構(gòu)型設(shè)計模式
3.行為型設(shè)計模式

簡而言之

結(jié)構(gòu)模式主要涉及對象的組成，或者是實體如何相互使用?；蛘撸硪粋€解釋是，他們幫助回答“如何構(gòu)建一個軟件組件?”

維基百科說

在軟件工程中，結(jié)構(gòu)設(shè)計模式是通過識別實體之間關(guān)系的簡單方法來簡化設(shè)計的設(shè)計模式。

現(xiàn)實舉例

考慮一下你的記憶卡上有一些圖片，你需要把它們轉(zhuǎn)移到你的電腦上。為了轉(zhuǎn)移它們，你需要某種與你的計算機(jī)端口兼容的適配器，這樣你就可以將存儲卡附加到你的電腦上。在這個例子中讀卡器就是適配器。
另一個例子是著名的電源適配器;一個三腳插頭不能連接到兩個電源插座，它需要使用一個電源適配器，使它與兩個電源插座兼容。
另一個例子是一個譯者翻譯一個人對另一個人說的話。

簡而言之

適配器模式允許您在適配器中包裝一個不兼容的對象，使其與另一個類兼容。

維基百科說

在軟件工程中，適配器模式是一種軟件設(shè)計模式，它允許將現(xiàn)有類的接口用作另一個接口。它通常用于使現(xiàn)有的類與其他類一起工作，而無需修改它們的源代碼。

編程示例

考慮一個游戲，一個獵人追捕獅子。
首先我有一個獅子(Lion)的接口和所有要實現(xiàn)類型的獅子。

public interface Lion {
    void roar();
}

public class AsianLion implements Lion {
    @Override
    public void roar() {
        System.out.println("AsianLion roar");
    }
}

public class AfricanLion implements Lion {
    @Override
    public void roar() {
        System.out.println("AfricanLion roar");
    }
}

獵人希望所有捕獲的獅子都能實現(xiàn)Lion的接口。

public class Hunter {
    public void hunt(Lion lion)
    {
        lion.roar();
    }
}

現(xiàn)在在我們的游戲里增加一個"野狗"(WildDog)，獵人也可以捕獲。但是我們不能直接這樣做，因為野狗(WildDog)有一個不同的接口。為了兼容我們的獵人(hunter),我們必須創(chuàng)建一個適配器來使之兼容。

public class WildDog {
    public void bark()
    {
        System.out.println("WildDog bark");
    }
}

public class WildDogAdapter implements Lion {
    private WildDog wildDog;

    public WildDogAdapter(WildDog wildDog) {
        this.wildDog = wildDog;
    }

    @Override
    public void roar() {
        this.wildDog.bark();
    }
}

現(xiàn)在 WildDog 可以在我們的游戲里使用 WildDogAdapter來代替.

 WildDog wildDog = new WildDog();
        WildDogAdapter adapter = new WildDogAdapter(wildDog);
        Hunter hunter = new Hunter();
        hunter.hunt(adapter);

現(xiàn)實舉例

考慮你有一個不同頁面的網(wǎng)站，你應(yīng)該允許用戶改變主題。你會怎么做?為每個主題創(chuàng)建多個頁面的多個副本，或者僅僅根據(jù)用戶的喜好創(chuàng)建多帶帶的主題并加載它們?橋式模式允許你做第二件事。

簡而言之

橋式模式是傾向于選擇組合而不是繼承。實現(xiàn)細(xì)節(jié)從層次結(jié)構(gòu)推送到另一個具有獨立層次結(jié)構(gòu)的對象。

維基百科說

橋式模式是軟件工程中使用的一種設(shè)計模式，它的意思是“將抽象與實現(xiàn)分離開來，以便兩者能夠獨立地變化”。

編程示例

翻譯一下上邊的Web頁面(Web Page)的例子。首先是獨立的WebPage層次

public interface WebPage {
    String getContent();
}

public class About implements WebPage {
    private Theme theme;

    public About(Theme theme) {
        this.theme = theme;
    }

    @Override
    public String getContent() {
        return "About page in "+theme.getColor();
    }
}

public class Career implements WebPage {
    private Theme theme;

    public Career(Theme theme) {
        this.theme = theme;
    }

    @Override
    public String getContent() {
        return "Career Page in "+theme.getColor();
    }
}

獨立的主題層次

public interface Theme {
    String getColor();
}

public class AquaTheme implements Theme {
    @Override
    public String getColor() {
        return "Light blue";
    }
}

public class DarkTheme implements Theme {
    @Override
    public String getColor() {
        return "Dark Black";
    }
}

public class LightTheme implements Theme {
    @Override
    public String getColor() {
        return "Off White";
    }
}

And both the hierarchies

Theme aquaTheme = new AquaTheme();
Theme darkTheme = new DarkTheme();

WebPage about = new About(aquaTheme);
WebPage career = new Career(aquaTheme);
System.out.println(career.getContent());
System.out.println(about.getContent());

System.out.println("");

about = new About(darkTheme);
career = new Career(darkTheme);
System.out.println(career.getContent());
System.out.println(about.getContent());

現(xiàn)實舉例

每個組織都是由雇員組成的。每個雇員都有相同的特性，即有工資，有一些職責(zé)，可以或不可以向某人報告，可以或不可能有一些下屬等。

簡而言之

組合模式允許客戶以統(tǒng)一的方式處理單個對象

維基百科說

在軟件工程中，組合模式是一個分而治之的設(shè)計模式。
組合模式描述了以相同的方式對待一組對象和單個對象。 組合的意圖是將對象“組合”到樹結(jié)構(gòu)中，以表示部分整個層次結(jié)構(gòu)。 實現(xiàn)組合模式可以讓客戶端對單個對象和組合進(jìn)行統(tǒng)一處理。

編程示例

參考我們上邊雇員的例子。我們又幾種類型的雇員。

public interface Employee {
    String getName();
    void setSalary(float salary);
    float getSalary();
    String getRole();
}

public class Developer implements Employee {
    private String name;
    private float salary;
    private String role;

    public Developer(String name, float salary) {
        this.name = name;
        this.salary = salary;
        this.role = "Developer";
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void setSalary(float salary) {
        this.salary = salary;
    }

    @Override
    public float getSalary() {
        return this.salary;
    }

    @Override
    public String getRole() {
        return role;
    }
}

public class Designer implements Employee{
    private String name;
    private float salary;
    private String role;

    public Designer(String name, float salary) {
        this.name = name;
        this.salary = salary;
        this.role = "Designer";
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void setSalary(float salary) {
        this.salary = salary;
    }

    @Override
    public float getSalary() {
        return this.salary;
    }

    @Override
    public String getRole() {
        return role;
    }
}

下面我們用組織來保存幾種不同類型的雇員。

public class Orgnization {
    private List employees = new ArrayList<>();

    public void addEmployee(Employee employee)
    {
        employees.add(employee);
    }

    public float getSalary()
    {
        float total = 0;
        for(Employee employee : employees)
        {
            total += employee.getSalary();
        }

        return total;
    }
}

使用方式如下

 Employee employee1 = new Developer("John Doe",12000);
        Employee employee2 = new Designer("Jane Doe",15000);

        Orgnization orgnization = new Orgnization();
        orgnization.addEmployee(employee1);
        orgnization.addEmployee(employee2);

        System.out.println(orgnization.getSalary());

現(xiàn)實舉例

假設(shè)你經(jīng)營一家提供多種服務(wù)的汽車服務(wù)商店。那么如何計算要收取的費用呢?您可以選擇一個服務(wù)并動態(tài)地將提供的服務(wù)的價格添加到最終成本。這里的每一種服務(wù)都是裝飾者。

簡而言之

裝飾者模式允許您通過將對象在一個裝飾者類的對象中進(jìn)行包裝，從而在運行時動態(tài)地更改對象的行為。

維基百科說

在面向?qū)ο缶幊讨?，裝飾者模式是一種設(shè)計模式，它允許將行為添加到單個對象中，無論是靜態(tài)的還是動態(tài)的，都不會影響來自同一類的其他對象的行為。 裝飾者模式通常對堅持單一責(zé)任原則非常有用，因為它允許在具有獨特關(guān)注點的類之間劃分功能。

編程示例
我們以咖啡舉例，首先我們有一個簡單的實現(xiàn)了咖啡接口的咖啡。

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

public class SimpleCoffee implements Coffee {
    @Override
    public float getCost() {
        return 10;
    }

    @Override
    public String getDescription() {
        return "simpleCoffee";
    }

    @Override
    public String toString() {
        return "SimpleCoffee";
    }
}

我們希望使代碼可擴(kuò)展，以便在需要時允許選項進(jìn)行修改。讓我們做一些附加組件(decorator)

public class MilkCoffee implements Coffee {
    private Coffee coffee;

    public MilkCoffee(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public float getCost() {
        return coffee.getCost()+2;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription()+",milk";
    }
}

public class VanillaCoffee implements Coffee{

    private Coffee coffee;

    public VanillaCoffee(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public float getCost() {
        return coffee.getCost()+3;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription()+",vanilla";
    }
}

public class WhipCoffee implements Coffee {
    private Coffee coffee;

    public WhipCoffee(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public float getCost() {
        return coffee.getCost()+5;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription()+",whip";
    }
}

Lets make a coffee now

Coffee coffee = new SimpleCoffee();
System.out.println(coffee.getCost());
System.out.println(coffee.getDescription());

coffee = new MilkCoffee(coffee);
System.out.println(coffee.getCost());
System.out.println(coffee.getDescription());

coffee = new VanillaCoffee(coffee);
System.out.println(coffee.getCost());
System.out.println(coffee.getDescription());

coffee = new WhipCoffee(coffee);
System.out.println(coffee.getCost());
System.out.println(coffee.getDescription());

現(xiàn)實舉例

你怎么打開電腦?“按下電源鍵”你說!這就是你所相信的，因為你使用的是一個簡單的界面，電腦在外部提供，在內(nèi)部它需要做很多事情來實現(xiàn)它。這個復(fù)雜子系統(tǒng)的簡單接口是一個門面。

簡而言之

門面模式提供了一個復(fù)雜子系統(tǒng)的簡化接口。

維基百科說

門面模式是為更大的代碼體(如類庫)提供簡化接口的對象。

編程示例

以我們上邊的計算機(jī)為例。首先這是我們的計算機(jī)。

public class Computer {
    public void getElectricShock()
    {
        System.out.println("Ouch");
    }

    public void makeSound()
    {
        System.out.println("Beep beep!");
    }

    public void showLoadingScreen()
    {
        System.out.println("Loading..");
    }

    public void bam()
    {
        System.out.println("Ready to be used!");
    }

    public void closeEverything()
    {
        System.out.println("closeEverything");
    }

    public void sooth()
    {
        System.out.println("Zzzzz");
    }

    public void pullCurrent()
    {
        System.out.println("Haaah");
    }
}

下面是門面

public class ComputerFacade {
    private Computer computer;

    public ComputerFacade(Computer computer) {
        this.computer = computer;
    }

    public void turnOn()
    {
        computer.getElectricShock();
        computer.makeSound();
        computer.showLoadingScreen();
        computer.bam();
    }

    public void turnOff()
    {
        computer.closeEverything();
        computer.pullCurrent();
        computer.sooth();
    }
}

下面開始使用門面

Computer computer = new Computer();
ComputerFacade facade = new ComputerFacade(computer);

facade.turnOn();
System.out.println("============================");
 facade.turnOff();

現(xiàn)實舉例

你曾經(jīng)在某個攤位上喝過新鮮的茶嗎?他們經(jīng)常做的比你要求的多并把剩下的留給其他顧客，以節(jié)省資源，例如氣體等。Flyweight模式就是分享。

簡而言之

它通過盡可能多地與類似對象共享來最小化內(nèi)存使用或計算開銷。

維基百科說

在計算機(jī)編程中，享元是一種軟件設(shè)計模式。享元是一個對象，它通過與其他類似對象共享盡可能多的數(shù)據(jù)來最小化內(nèi)存使用;當(dāng)一個簡單的重復(fù)表示使用不可接受的內(nèi)存時，它是一種使用大量對象的方法。

編程示例
翻譯一下我們上邊茶水的例子。首先我們有茶的類型和茶具。

public class KarakTea {
}

public class TeaMaker {
    private Map availableTea = new HashMap<>();

    public KarakTea make(String preference)
    {
        if(!availableTea.containsKey(preference))
        {
            availableTea.put(preference,new KarakTea());
        }

        return availableTea.get(preference);
    }
}

然后我們有茶社來接單和提供服務(wù)。

public class TeaShop {
    private TeaMaker teaMaker;
    private Map orders = new HashMap<>();

    public TeaShop(TeaMaker teaMaker) {
        this.teaMaker = teaMaker;
    }

    public void takeOrder(String teaType,int table)
    {
        orders.put(table,teaMaker.make(teaType));
    }

    public void serve()
    {
        Set> entrySet = orders.entrySet();
        for(Map.Entry entry : entrySet)
        {
            System.out.println("Serving tea to table#"+entry.getKey());
        }
    }
}

使用方式如下

TeaMaker teaMaker = new TeaMaker();
TeaShop shop = new TeaShop(teaMaker);
shop.takeOrder("less sugar", 1);
shop.takeOrder("more milk", 2);
shop.takeOrder("without sugar", 3);

shop.serve();

現(xiàn)實舉例

你曾經(jīng)用過門禁卡嗎?打開這扇門有多種選擇，即可以使用門禁卡打開，也可以通過按一個繞過安全按鈕的按鈕打開。 門的主要功能是打開，但是在它上面添加了一個代理來添加一些功能。讓我用下面的代碼示例更好地解釋一下。

簡而言之

使用代理模式，一個類代表另一個類的功能。

維基百科說

代理，在其最一般的形式中，是一個類作為其他東西的接口。 代理是由客戶端調(diào)用的包裝器或代理對象，以訪問實際服務(wù)對象。代理的使用可以簡單地轉(zhuǎn)發(fā)到實際對象，或者提供額外的邏輯。 在代理的額外功能中可以提供，例如在實際對象上的操作是資源密集型的緩存，或者在調(diào)用實際對象的操作之前檢查先決條件。

編程示例

上邊安全門的例子。首先我們有一個門的接口和一個門的實現(xiàn)

public interface Door {
    void open();
    void close();
}

public class LabDoor implements Door {
    @Override
    public void open() {
        System.out.println("Opening lab door");
    }

    @Override
    public void close() {
        System.out.println("Closing lab door");
    }
}

我們有一個來歷來確保我們想要的門。

public class SecuredDoor {
    private Door door;

    public SecuredDoor(Door door) {
        this.door = door;
    }

    public void open(String pwd) {
        if(authenticate(pwd))
        {
            door.open();
        }
        else
        {
            System.out.println("Big no! It ain"t possible.");
        }
    }

    private boolean authenticate(String pwd)
    {
        return "$ecr@t".equals(pwd);
    }

    public void close() {
        this.door.close();
    }
}

使用方式如下

Door door = new LabDoor();
SecuredDoor securedDoor = new SecuredDoor(door);

securedDoor.open("invalid");
//securedDoor.open("$ecr@t");

還有一個例子是某種形式的數(shù)據(jù)映射的實現(xiàn)。例如我最近編寫了一個MongoDB的ODM。在mongodb周圍利用魔術(shù)方法__call()我寫了一個代理，所有的方法調(diào)用都被代理到原生的mongo類。檢索的結(jié)果作為返回的數(shù)據(jù)，如果find或者findOne的數(shù)據(jù)映射到某個類，這類將會代替cursor返回。