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

1.創建型設計模式
2.結構型設計模式
3.行為型設計模式

簡而言之

創建型設計模式關注的是如何實例化一個或者一組相關的對象。

維基百科

在軟件工程中，創建型設計模式是用于解決對象創建機制，嘗試在指定場景下使用合理的方式來創建對象的設計模式。基本的創建方式對導致設計問題或者增加設計的復雜度。創建型設計模式通過一些控制對象創建的手段來解決這些問題。

現實例子

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

簡而言之

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

維基百科說

在面向對象編程中(OOP),工廠是一個用于創建對象的對象，正式的工廠是一個方法或者函數，在某些方法調用的時候返回不同的原型或者對象，我們認為這個對象是新的。

編程實例
首先我們有一個們的接口和實現

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;
    }
}

然后我們需要一個生產并返回門的工廠

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());

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

現實例子

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

簡而言之

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

維基百科說

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

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

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");
    }
}

現在我們創建 HiringManager

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

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

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

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();
    }
}

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

現實舉例

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

簡而言之

一個工廠的工廠。一個工廠在不指定具體的類的情況下將獨立但相關的工程組合在一起。

維基百科說

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

編程示例

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

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";
    }
}

現在我們需要一個抽象工廠來幫我們決定相關對象的族。例如木門工廠需要生產木門和木門安裝專家，鐵門工廠需要生產鐵門和鐵門安裝專家。

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.因此工廠幫我們確信每一個創建的門都不會有錯誤的安裝的專家

何時使用
當有相關的復雜的創建邏輯的依賴的時候

現實舉例

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

簡而言之

避免構造函數污染的情況下為對象創造不同的特性。當一個對象有多個特性或者創建對象包含幾個步驟的時候使用。

維基百科說

建造者模式是一種對象創建軟件設計模式，其目的是找到一種解決方案，以解決可伸縮構造函數的反模式。

說道這里，讓我添加一點關于伸縮構造函數反模式的內容。在某些地方，我們都看到了如下的構造函數。:

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

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

程序示例
明智的選擇是使用建造者模式。首先我們要有一個我們要做的漢堡(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);

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

現實舉例

還記得多里嗎？就是那只被克隆的山羊。我們不關注細節，這里的關鍵就是克隆。

簡而言之

通過克隆的方式根據現有對象來創建新對象

維基百科說

原型模式是軟件開發中的一個創建型設計模式。當要創建的對象類型由一個原型實例決定時，使用原型模式，該實例被克隆以產生新的對象。

簡而言之，它允許您創建一個現有對象的副本，并根據您的需要修改它，而不是從頭開始創建一個對象并設置它。

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);
    }
}

何時使用?

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

現實舉例

同一時間一個國家只有一個總統。 當指責需要的時候，采取行動的是同一個總統. 在這里總統就是單例的

簡而言之

一個特定的類確保只創建一個對象。

維基百科說

在軟件工程中，單例模式是一種軟件設計模式，它將類的實例化限制為一個對象。 當需要一個對象來協調整個系統中的操作時，這很有用。

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

編程示例
創建一個單例，需要將構造函數私有，禁用可控和擴展，通過創建一個靜態的變量來保存實例。

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);