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

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

簡(jiǎn)而言之

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

維基百科

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

現(xiàn)實(shí)例子

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

簡(jiǎn)而言之

對(duì)客戶端來說，簡(jiǎn)單工廠模式僅僅生成一個(gè)實(shí)例，不需要暴露給客戶端人戶實(shí)例化的邏輯。

維基百科說

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

編程實(shí)例
首先我們有一個(gè)們的接口和實(shí)現(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;
    }
}

然后我們需要一個(gè)生產(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());

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

現(xiàn)實(shí)例子

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

簡(jiǎn)而言之

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

維基百科說

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

編程示例
參考上邊人事部經(jīng)理的例子。首先我們有一個(gè)面試官的接口和一些實(shí)現(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)在和人子類都可以實(shí)現(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();
    }
}

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

現(xiàn)實(shí)舉例

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

簡(jiǎn)而言之

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

維基百科說

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

編程示例

翻譯上邊門的例子. 首先我們有門的接口和幾個(gè)門的實(shí)現(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)在我們需要一個(gè)抽象工廠來幫我們決定相關(guān)對(duì)象的族。例如木門工廠需要生產(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.因此工廠幫我們確信每一個(gè)創(chuàng)建的門都不會(huì)有錯(cuò)誤的安裝的專家

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

現(xiàn)實(shí)舉例

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

簡(jiǎn)而言之

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

維基百科說

建造者模式是一種對(duì)象創(chuàng)建軟件設(shè)計(jì)模式，其目的是找到一種解決方案，以解決可伸縮構(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ù)量很快就會(huì)失去控制，并且很難理解參數(shù)的排列。另外，如果你想在未來增加更多的選項(xiàng)，這個(gè)參數(shù)列表還可以繼續(xù)增長(zhǎng)。這被稱為伸縮構(gòu)造函數(shù)反模式。

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

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

現(xiàn)實(shí)舉例

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

簡(jiǎn)而言之

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

維基百科說

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

簡(jiǎn)而言之，它允許您創(chuàng)建一個(gè)現(xiàn)有對(duì)象的副本，并根據(jù)您的需要修改它，而不是從頭開始創(chuàng)建一個(gè)對(duì)象并設(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);
    }
}

何時(shí)使用?

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

現(xiàn)實(shí)舉例

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

簡(jiǎn)而言之

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

維基百科說

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

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

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

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