摘要：維基百科在軟件工程中，創(chuàng)建型設(shè)計模式是用于解決對象創(chuàng)建機(jī)制，嘗試在指定場景下使用合理的方式來創(chuàng)建對象的設(shè)計模式。維基百科說建造者模式是一種對象創(chuàng)建軟件設(shè)計模式，其目的是找到一種解決方案，以解決可伸縮構(gòu)造函數(shù)的反模式。

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

簡而言之

創(chuàng)建型設(shè)計模式關(guān)注的是如何實例化一個或者一組相關(guān)的對象。

維基百科

在軟件工程中，創(chuàng)建型設(shè)計模式是用于解決對象創(chuàng)建機(jī)制，嘗試在指定場景下使用合理的方式來創(chuàng)建對象的設(shè)計模式?；镜膭?chuàng)建方式對導(dǎo)致設(shè)計問題或者增加設(shè)計的復(fù)雜度。創(chuàng)建型設(shè)計模式通過一些控制對象創(chuàng)建的手段來解決這些問題。

現(xiàn)實例子

考慮一下，你需要建造一個房子，然后需要幾扇門。如果每次需要一扇門的時候，你都穿上木匠的衣服然后在房間里左門會造成很大的混亂。取而代之是你需要買一個從工廠里做好的。

簡而言之

對客戶端來說，簡單工廠模式僅僅生成一個實例，不需要暴露給客戶端人戶實例化的邏輯。

維基百科說

在面向?qū)ο缶幊讨?OOP),工廠是一個用于創(chuàng)建對象的對象，正式的工廠是一個方法或者函數(shù)，在某些方法調(diào)用的時候返回不同的原型或者對象，我們認(rèn)為這個對象是新的。

編程實例
首先我們有一個們的接口和實現(xiàn)

public interface Door {
    float getWidth();
    float getHeight();
}

public class WoodenDoor implements Door {
    private float width;
    private float height;

    public WoodenDoor(float width, float height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public float getWidth() {
        return 0;
    }

    @Override
    public float getHeight() {
        return 0;
    }
}

然后我們需要一個生產(chǎn)并返回門的工廠

public class DoorFactory {
    public static Door makeDoor(float width,float height)
    {
        return new WoodenDoor(width,height);
    }
}

使用方式如下

Door door = DoorFactory.makeDoor(1200L,2100L);
System.out.println("Door Width:"+door.getWidth());
System.out.println("Door Height:"+door.getHeight());

何時使用
當(dāng)創(chuàng)建一個不僅僅是幾條賦值語句同時包含一些邏輯的對象的時候，把創(chuàng)建對象的代碼放到一個專用的工廠中而不是到處賦值相同的代碼，這是情理之中的。

現(xiàn)實例子

考慮一個人事部經(jīng)理的例子. 不可能所有的崗位都有一個人來面試. 根據(jù)職位空缺，他將面試的步驟安排給不同的人.

簡而言之

提供一種將實例化邏輯委托給子類的方式.

維基百科說

在給予類的編程中，工廠方法模式是一個創(chuàng)建型的模式，這個模式用于解決建對象的問題而無需指定要創(chuàng)建的精確的類。通過調(diào)用工廠方法(在接口中指定并由子類實現(xiàn)，或者在基類中實現(xiàn))，或者通過派生類(而不是調(diào)用構(gòu)造函數(shù))來實現(xiàn)，這是通過創(chuàng)建對象來完成的。

編程示例
參考上邊人事部經(jīng)理的例子。首先我們有一個面試官的接口和一些實現(xiàn)。

public interface Inteviewer {
    void askQuestions();
}

public class Developer implements Inteviewer {
    @Override
    public void askQuestions() {
        System.out.println("Ask about Design Patterns");
    }
}

public class CommunityExecutive implements Inteviewer {
    @Override
    public void askQuestions() {
        System.out.println("Ask about community build");
    }
}

現(xiàn)在我們創(chuàng)建 HiringManager

public abstract class HiringManager {
    protected abstract Inteviewer makeInteviewer();

    public void takeInteview()
    {
        Inteviewer inteviewer = makeInteviewer();
        inteviewer.askQuestions();
    }
}

現(xiàn)在和人子類都可以實現(xiàn)該類來提供需要的面試官

public class DevelopmentManager extends HiringManager {
    @Override
    protected Inteviewer makeInteviewer() {
        return new Developer();
    }
}

public class CommunityManager extends HiringManager {
    @Override
    protected Inteviewer makeInteviewer() {
        return new CommunityExecutive();
    }
}

使用舉例

public class Client {
    public static void main(String[] args) {
        HiringManager manager = new DevelopmentManager();
        manager.takeInteview();

        manager = new CommunityManager();
        manager.takeInteview();
    }
}

何時使用?
當(dāng)一個類中有一些通用的處理但是子類需要在運(yùn)行時決定的時候使用。換句話說，客戶端不知道需要的精確的子類。

現(xiàn)實舉例

擴(kuò)展我們的簡單工廠模式的門的例子?？紤]到你的需求，你可能從一個木門的商店購買一個木門，從一個鐵門的商店購買一個鐵門，或者從另外的相關(guān)的商店購買一個PVC門。除此之外你可能需要一個有不同技能的伙計幫你裝門，例如木匠來裝木門，焊接工裝鐵門。正如你看到的那樣，現(xiàn)在門之間有一個依賴，木門需要木匠，鐵門需要焊接工等等。

簡而言之

一個工廠的工廠。一個工廠在不指定具體的類的情況下將獨(dú)立但相關(guān)的工程組合在一起。

維基百科說

抽象工廠模式提供了一種方式來封裝一度獨(dú)立的工廠，這些工廠有相同的主題當(dāng)時沒有指定具體的類。

編程示例

翻譯上邊門的例子. 首先我們有門的接口和幾個門的實現(xiàn)

public interface Door {
    String getDescription();
}

public class WoodenDoor implements Door {
    @Override
    public String getDescription() {
        return "I am a wooden door";
    }
}

public class IronDoor implements Door {
    @Override
    public String getDescription() {
        return "I am an iron door";
    }
}

然后每一種門我們有一些安裝專家

public interface DoorFittingExpert {
    String getDescription();
}

public class Carpenter implements DoorFittingExpert {
    @Override
    public String getDescription() {
        return "I can only fit wooden doors";
    }
}

public class Welder implements DoorFittingExpert {
    @Override
    public String getDescription() {
        return "I can only fit iron doors";
    }
}

現(xiàn)在我們需要一個抽象工廠來幫我們決定相關(guān)對象的族。例如木門工廠需要生產(chǎn)木門和木門安裝專家，鐵門工廠需要生產(chǎn)鐵門和鐵門安裝專家。

public interface DoorFactory {
    Door makeDoor();
    DoorFittingExpert makeFittingExper();
}

public class WoodenDoorFactory implements DoorFactory {
    @Override
    public Door makeDoor() {
        return new WoodenDoor();
    }

    @Override
    public DoorFittingExpert makeFittingExper() {
        return new Carpenter();
    }
}

public class IronDoorFactory implements DoorFactory {
    @Override
    public Door makeDoor() {
        return new IronDoor();
    }

    @Override
    public DoorFittingExpert makeFittingExper() {
        return new Welder();
    }
}

使用方式如下:

DoorFactory doorFactory = new WoodenDoorFactory();
        Door door = doorFactory.makeDoor();
        DoorFittingExpert expert = doorFactory.makeFittingExper();
        System.out.println("Door:"+door.getDescription());
        System.out.println("Expert:"+expert.getDescription());

正如上邊看到的一樣，木門工廠封裝了carpenter和wooden door,鐵門工廠封裝了iron door和welder.因此工廠幫我們確信每一個創(chuàng)建的門都不會有錯誤的安裝的專家

何時使用
當(dāng)有相關(guān)的復(fù)雜的創(chuàng)建邏輯的依賴的時候

現(xiàn)實舉例

設(shè)想一下你在Hardee，你要點(diǎn)餐，我們會說：Big Hardee，他們不會問任何問題就會把飯端過來。這是一個簡單工廠的例子。但是有種情況下創(chuàng)建邏輯包含幾個步驟。例如你想吃一個自助的Subway，漢堡怎么做，例如面包用什么樣的，用什么樣的醬汁，想要什么樣的奶酪。這種情況下，建造者模式將會拯救我們。

簡而言之

避免構(gòu)造函數(shù)污染的情況下為對象創(chuàng)造不同的特性。當(dāng)一個對象有多個特性或者創(chuàng)建對象包含幾個步驟的時候使用。

維基百科說

建造者模式是一種對象創(chuàng)建軟件設(shè)計模式，其目的是找到一種解決方案，以解決可伸縮構(gòu)造函數(shù)的反模式。

說道這里，讓我添加一點(diǎn)關(guān)于伸縮構(gòu)造函數(shù)反模式的內(nèi)容。在某些地方，我們都看到了如下的構(gòu)造函數(shù)。:

public Deal(int size, boolean cheese ,boolean pepperoni, boolean tomato, boolean lettuce)
{
}

正如你所看到的;構(gòu)造函數(shù)參數(shù)的數(shù)量很快就會失去控制，并且很難理解參數(shù)的排列。另外，如果你想在未來增加更多的選項，這個參數(shù)列表還可以繼續(xù)增長。這被稱為伸縮構(gòu)造函數(shù)反模式。

程序示例
明智的選擇是使用建造者模式。首先我們要有一個我們要做的漢堡(burger)

package com.suifeng.designpattern.builder;

public class Burger {
    private int size;
    private boolean cheese;
    private boolean pepperoni;
    private boolean lettuce;
    private boolean tomato;

    public Burger(BurgerBuilder builder)
    {
        this.size = builder.size;
        this.cheese=builder.cheese;
        this.pepperoni = builder.pepperoni;
        this.lettuce = builder.lettuce;
        this.tomato = builder.tomato;
    }

    @Override
    public String toString() {
        return "Burger{" +
                "size=" + size +
                ", cheese=" + cheese +
                ", pepperoni=" + pepperoni +
                ", lettuce=" + lettuce +
                ", tomato=" + tomato +
                "}";
    }

    static class BurgerBuilder{
        private int size;
        private boolean cheese;
        private boolean pepperoni;
        private boolean lettuce;
        private boolean tomato;

        public BurgerBuilder(int size) {
            this.size = size;
        }

        public BurgerBuilder addCheese()
        {
            this.cheese = true;
            return this;
        }

        public BurgerBuilder addPepperoni()
        {
            this.pepperoni = true;
            return this;
        }

        public BurgerBuilder addLettuce()
        {
            this.lettuce = true;
            return this;
        }

        public BurgerBuilder addTomato()
        {
            this.tomato = true;
            return this;
        }

        public Burger build()
        {
            return new Burger(this);
        }
    }
}

使用方式如下

Burger burger = new Burger.BurgerBuilder(12).addCheese().addLettuce().build();
        System.out.println(burger);

何時使用
當(dāng)一個對象有幾個特性并且需要避免構(gòu)造器伸縮。與工廠模式的主要不同是：工廠模式的創(chuàng)建過程只有一個步驟而建造者模式需要多個步驟。

現(xiàn)實舉例

還記得多里嗎？就是那只被克隆的山羊。我們不關(guān)注細(xì)節(jié)，這里的關(guān)鍵就是克隆。

簡而言之

通過克隆的方式根據(jù)現(xiàn)有對象來創(chuàng)建新對象

維基百科說

原型模式是軟件開發(fā)中的一個創(chuàng)建型設(shè)計模式。當(dāng)要創(chuàng)建的對象類型由一個原型實例決定時，使用原型模式，該實例被克隆以產(chǎn)生新的對象。

簡而言之，它允許您創(chuàng)建一個現(xiàn)有對象的副本，并根據(jù)您的需要修改它，而不是從頭開始創(chuàng)建一個對象并設(shè)置它。

Programmatic Example

Java中可以使用clone方法

public class Sheep implements Cloneable {

    private String name;
    private String category;

    public Sheep(String name, String category) {
        this.name = name;
        this.category = category;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCategory() {
        return category;
    }

    public void setCategory(String category) {
        this.category = category;
    }

    @Override
    public String toString() {
        return "Sheep{" +
                "name="" + name + """ +
                ", category="" + category + """ +
                "}";
    }

    public Sheep clone()
    {
        Object obj = null;

        try {
            obj =super.clone();

            return (Sheep) obj;
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        return null;
    }
}

克隆方式如下

public class Client {
    public static void main(String[] args) {
        Sheep sheep = new Sheep("Jolly","Mountain Sheep");

        Sheep dolly = sheep.clone();
        dolly.setName("Dolly");

        System.out.println(dolly);
    }
}

何時使用?

當(dāng)需要的對象與存在的對象相似的時候或者相比于克隆創(chuàng)建成本比較高的情況.

現(xiàn)實舉例

同一時間一個國家只有一個總統(tǒng)。 當(dāng)指責(zé)需要的時候，采取行動的是同一個總統(tǒng). 在這里總統(tǒng)就是單例的

簡而言之

一個特定的類確保只創(chuàng)建一個對象。

維基百科說

在軟件工程中，單例模式是一種軟件設(shè)計模式，它將類的實例化限制為一個對象。 當(dāng)需要一個對象來協(xié)調(diào)整個系統(tǒng)中的操作時，這很有用。

單例模式實際上被認(rèn)為是一種反模式，應(yīng)該避免過度使用。它并不一定是壞的，并且可以有一些有效的用例，但是應(yīng)該謹(jǐn)慎使用，因為它在您的應(yīng)用程序中引入了一個全局狀態(tài)，并且在一個地方對它進(jìn)行更改可能會影響到其他領(lǐng)域，因此調(diào)試可能變得非常困難。另一件不好的事情是，它使您的代碼緊密耦合，另外對單例對象的模擬是困難的。

編程示例
創(chuàng)建一個單例，需要將構(gòu)造函數(shù)私有，禁用可控和擴(kuò)展，通過創(chuàng)建一個靜態(tài)的變量來保存實例。

public class President {
    private static President INSTANCE ;

    private President()
    {

    }

    public static President getInstance()
    {
        if(INSTANCE == null)
        {
            INSTANCE = new President();
        }

        return INSTANCE;
    }


}

使用方式如下

 President president1 = President.getInstance();
        President president2 = President.getInstance();

        System.out.println(president1 == president2);