? 對于工廠模式，個人學習需要掌握

• 注意答案的重點標黑了。對于工廠模式、建造者模式，掌握，我下面這幾點就很棒棒。

一、工廠模式

1、什么是工廠模式：【關鍵字factory】

答：創建對象時，不直接new，而是交由一個工廠類/工廠接口的工廠方法負責創建。

2、工廠模式的意義

答：將實例化對象的代碼提取出來，放到一個類(工廠類)中統一管理和維護；實現了創建者和調用者的分離，達到和主項目的依賴關系的解耦。從而提高項目的擴展和維護性。

3、工廠模式包括哪三種

答：簡單工廠模式、工廠方法模式、抽象工廠模式

4、工廠模式的使用對比[簡單工廠模式和工廠方法模式對比]：

答：簡單工廠模式：雖然某種程度上不符合設計原則，但實際使用最多；工廠方法模式：不修改已有類的前提下，通過增加新的工廠類實現擴展；抽象工廠模式：不可以增加產品，可以增加產品族。

★ 雖然簡單工廠模式不符合理論中的開閉原則，但是工廠方法模式定義的大量子類工廠實現類，管理也非常麻煩，實際開發中使用的最多是簡單工廠模式.

5、抽象工廠是什么

答：是工廠的工廠，超級工廠。適合生產一個穩定的產品族，采用抽象工廠模式不需要關心構建過程，只關心什么產品由什么工廠生產即可。

6、工廠模式的應用場景：

• jdk中calendar的getInstance方法----簡單工廠模式
• JDBC中的Connection對象的獲取
• Spring中的IOC容器創建管理bean對象
• 反射中Class對象的newInstance方法

---

二、建造者模式

1、什么是建造者模式：【關鍵字builder】

答：又叫生成器模式，是一種對象構建模式。將一個復雜對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示。

2、四種角色是什么

答：

（1) Product(產品角色)：一個具體的產品對象。

（2) Builder(抽象建造者): 創建一個產品對象的各個部件的接口/抽象類。

（3) ConcreteBuilder(具體建造者): 實現或繼承抽象建造者接口，具體地構建和裝配各個部件。

（4) Director(指揮者): 構建一個使用Builder接口的對象。它主要是用于創建一個復雜的對象。負責指揮構建一個工程，決定了工程如何構建，按照什么順序構建。

舉例：建造房子:

需要建房子：這一過程為打樁、砌墻、封頂。不管是普通房子也好，別墅也好都 需要經歷這些過程，下面我們使用建造者模式(Builder Pattern)來完成.

1、產品角色：Product-房子，定義了房子的屬性

2、抽象建造者：Builder-抽象的工人，定義了一些建造房子組件的方法和接口

3、具體建造者：ConcreteBuilder-具體的工人，實現了建造房子組件

4、指揮者：Director-房子的指揮設計者，：負責指揮構建一個工程，決定了工程如何構建，按照什么順序構建

3、建造者模式在JDK的應用和源碼分析 (java.lang.StringBuilder中的建造者模式)

答：源碼中建造者模式角色分析：

(1) Appendable接口，是抽象建造者, 定義了抽象方法，定義了多個append方法(抽象方法)

(2) AbstractStringBuilder抽象類，實現了 Appendable接口方法，AbstractStringBuilder 是建造者，只是不能實例化

(3)StringBuilder 繼承了AbstractStringBuilder，即充當了指揮者角色，同時充當了具體的建造者，建造方法的實現是由 AbstractStringBuilder 完成, 而StringBuilder 繼承了 AbstractStringBuilder

4、建造者模式的優缺點：

答：優點：(1) 產品的建造和表示分離，實現了解耦。使用建造者模式可以使客戶端不必知道產品內部組成的細節;

? (2) 用戶使用不同的具體建造者即可得到不同的產品對象;

? (3) 增加新的具體建造者無需修改原有類庫代碼，符合“開閉原則”

缺點：建造者模式所創建的產品一般具有較多的共同點，其組成部分相似；如果產品之間的差異性很大，則不適合使用建造者模式

5、抽象工廠模式VS建造者模式

答：抽象工廠模式實現對產品家族的創建，一個產品家族是這樣的一系列產品，采用抽象工廠模式不需要關心構建過程，只關心什么產品 由什么工廠生產即可。而建造者模式則是要求按照指定的藍圖建造產品，它的主要目的是通過組裝零配件而產生一個新產品。

一、工廠設計模式

1、作用和意義：實現了創建者和調用者的分離。

★ 工廠模式的意義：將實例化對象的代碼提取出來，放到一個類(工廠類)中統一管理和維護，達到和主項目的依賴關系的解耦。從而提高項目的擴展和維護性。

2、三種工廠模式：

簡單工廠模式、工廠方法模式、抽象工廠模式

3、 設計模式的依賴抽象原則：

? 創建對象實例時，不要直接 new 類, 而是把這個new 類的動作放在一個工廠的方法中，并返回。

? 不要讓類繼承具體類，而是繼承抽象類或者是實現interface(接口)

? 不要覆蓋基類中已經實現的方法

4、核心本質：

實例化對象不使用new，用工廠方法代替 factory
將選擇實現類，創建對象統一管理和控制。從而將調用者跟我們的實現類解耦

■ 簡單工廠模式（靜態工廠模式）

用來生產同一等級結構中的任意產品（對于增加新的產品，需要擴展已有代碼）

★ 對于簡單工廠模式的舉例：消費者買車

情況一：在沒有使用簡單工廠模式下，消費者(Consumer類)要買車，需要自己 new來構建一輛自己想要買的車。【需要消費者自己制作車 (new 構建 車對象)，則消費者是需要車的內部細節，才能new出車對象】

情況二：使用簡單工廠模式下，消費者只需要調用汽車工廠（CarFactory類）的獲取車的方法，就可以買車了，不用關系車的創建的各種細節。而汽車工廠（CarFactory類）作用就是來制作車 (new 構建 車對象)的，并為外界提供獲取車對象的方法。

public class Consumer {public static void main(String[] args) {// 1、沒有使用簡單工廠模式的情況：// Car car = new WuLing();// Car car1 = new Tesla();// 2、使用工廠創建Car car = CarFactory.getCar("wuling");Car car1 = CarFactory.getCar("tesila");car.name();car1.name();} }public interface Car {void name(); }public class WuLing implements Car{@Overridepublic void name() {System.out.println("五菱宏光");} }public class Tesla implements Car{@Overridepublic void name() {System.out.println("特斯拉");} }// 靜態工廠模式 // 開閉原則 public class CarFactory {// 方法一： 不滿足開閉原則public static Car getCar(String car){if(car.equals("wuling")){return new WuLing();}else if(car.equals("tesila")){return new Tesla();}else {return null;}}// 方法二：public static Car geyWuling(){return new WuLing();}public static Car geyTesla(){return new Tesla();}}

□ 弊端：增加一個新的產品，做不到不修改代碼。

例如：擴展一個大眾的汽車，則需要修改工廠類(CarFactory)的Car(String car)方法的代碼，不符合開閉原則【對擴展開發，對修改關閉】。

• 解決：工廠方法模式

■ 工廠方法模式：

用來生產同一等級結構中的固定產品（支持增加任意產品）

public class Consumer {public static void main(String[] args) {Car car = new WulingFactory().getCar();Car car1 = new TeslaFactory().getCar();car.name();car1.name();Car car2 = new MoBaiFactory().getCar();car2.name();} }public interface Car {void name(); }public class WuLing implements Car {@Overridepublic void name() {System.out.println("五菱宏光");} }public class Tesla implements Car {@Overridepublic void name() {System.out.println("特斯拉");} }// 工廠方法模式 public interface CarFactory {Car getCar(); }public class WulingFactory implements CarFactory{@Overridepublic Car getCar() {return new WuLing();} }public class TeslaFactory implements CarFactory{@Overridepublic Car getCar() {return new Tesla();} }

■ 工廠方法模式：通過將簡單工廠模式原先的工廠類抽象成接口，然后根據車的種類，決定了抽象工廠接口的子類工廠實現類，并在子類工廠實現類內創建對應車種類的對象。

• 舉例：現在多了一個車的品牌，叫寶馬，相應的車工廠就有寶馬工廠(實現工廠接口)，在寶馬車工廠實現了制作寶馬車的方法。

3、理論和實際應用對比【對比簡單工廠模式和工廠方法模式】

1、結構復雜度：simple>method

2、代碼復雜度：simple>method

3、編程復雜度：simple>method

4、管理上的復雜度：simple>method

★ 雖然簡單工廠模式不符合理論中的開閉原則，但是工廠方法模式定義的大量子類工廠實現類，管理也非常麻煩，實際開發中使用的最多是簡單工廠模式

4、抽象工廠模式：“工廠的工廠，超級工廠。適合生產一個穩定的產品族”

圍繞一個超級工廠創建其他工廠。該超級工廠又稱為其他工廠的工廠

(1) 定義：

抽象工廠模式提供了一個創建一系列相關或者相互依賴對象的接口，無需指定他們的具體的類（針對整個產品族，產品等級數量相對固定的產品族）

(2) 適用場景：

• 客戶端（應用層）不依賴于產品類實例如何被創建、實現等細節
• 強調一系列相關的產品對象（屬于同一產品族）一起使用創建對象需要大量的重復代碼
• 提供一個產品類的庫，所有的產品以同樣的接口出現，從而使得客戶端不依賴于具體實現

■ 抽象工廠模式-其實就是工廠方法模式的抽象，體現在將原先的工廠定義為超級工廠接口，且包含的屬性成員也是接口。

1、定義一個超級工廠接口IProductFactory：包含兩個產品接口(接口屬性成員)-手機產品接口IphoneProduct、路由器產品接口IRouterProduct 【產品族】

2、然后超級工廠接口有具體的實現子類-小米工廠XiaomiFactory、華為工廠HuaweiFactory

3、對于超級工廠接口定義的接口屬性成員有對應的實現子類

• 然后手機產品接口IphoneProduct有具體的實現子類-小米手機實現子類XiaomiPhone、華為手機實現子類HuaweiPhone

• 同樣路由器產品接口IRouterProduct 也有具體的實現子類-小米路由實現子類XiaomiRouter、華為路由實現子類HuaweiRouter

// 手機產品接口 public interface IphoneProduct {void start();void shutdown();void callup();void sendSMS(); }// 小米手機 public class XiaomiPhone implements IphoneProduct{@Overridepublic void start() {System.out.println("開啟小米手機");}@Overridepublic void shutdown() {System.out.println("關閉小米手機");}@Overridepublic void callup() {System.out.println("小米手機打電話");}@Overridepublic void sendSMS() {System.out.println("小米手機發短信");} }// 華為手機 public class HuaweiPhone implements IphoneProduct{@Overridepublic void start() {System.out.println("開啟華為手機");}@Overridepublic void shutdown() {System.out.println("關閉華為手機");}@Overridepublic void callup() {System.out.println("華為手機打電話");}@Overridepublic void sendSMS() {System.out.println("華為手機發短信");} }// 路由器產品接口 public interface IRouterProduct {void start();void shutdown();void openWifi();void setting(); }// 小米路由器 public class XiaomiRouter implements IRouterProduct{@Overridepublic void start() {System.out.println("啟動小米路由器");}@Overridepublic void shutdown() {System.out.println("關閉小米路由器");}@Overridepublic void openWifi() {System.out.println("打開小米Wi-Fi");}@Overridepublic void setting() {System.out.println("小米設置");} }// 華為路由器 public class HuaweiRouter implements IRouterProduct{@Overridepublic void start() {System.out.println("啟動華為路由器");}@Overridepublic void shutdown() {System.out.println("關閉華為路由器");}@Overridepublic void openWifi() {System.out.println("打開華為Wi-Fi");}@Overridepublic void setting() {System.out.println("華為設置");} }// 抽象產品工廠 public interface IProductFactory {// 生產手機IphoneProduct iphoneProduct();// 生產路由器IRouterProduct irouterProduct();}public class XiaomiFactory implements IProductFactory{@Overridepublic IphoneProduct iphoneProduct() {return new XiaomiPhone();}@Overridepublic IRouterProduct irouterProduct() {return new XiaomiRouter();} }public class HuaweiFactory implements IProductFactory{@Overridepublic IphoneProduct iphoneProduct() {return new HuaweiPhone();}@Overridepublic IRouterProduct irouterProduct() {return new HuaweiRouter();} }public class Client {public static void main(String[] args) {System.out.println("小米系列產品--------------------");// 小米工廠XiaomiFactory xiaomiFactory = new XiaomiFactory();IphoneProduct iphoneProduct = xiaomiFactory.iphoneProduct();iphoneProduct.callup();iphoneProduct.sendSMS();IRouterProduct iRouterProduct = xiaomiFactory.irouterProduct();iRouterProduct.openWifi();System.out.println("華為系列產品--------------------");// 小米工廠HuaweiFactory huaweiFactory = new HuaweiFactory();iphoneProduct = huaweiFactory.iphoneProduct();iphoneProduct.callup();iphoneProduct.sendSMS();iRouterProduct = huaweiFactory.irouterProduct();iRouterProduct.openWifi();} }

(3) 抽象工廠模式優缺點：

優點

• 具體產品在應用層的代碼隔離，無需關心創建的細節

• 將一個系列的產品統一到一起創建

缺點：

• 規定了所有可能被創建的產品集合，產品族中擴展新的產品困難；

• 增加了系統的抽象性和理解難度

5、工廠模式小結：

• 簡單工廠模式：雖然某種程度上不符合設計原則，但實際使用最多

• 工廠方法模式：不修改已有類的前提下，通過增加新的工廠類實現擴展

• 抽象工廠模式：不可以增加產品，可以增加產品族

6、工廠模式的應用場景：

• jdk中calendar的getInstance方法----簡單工廠模式

• JDBC中的Connection對象的獲取

• Spring中的IOC容器創建管理bean對象

• 反射中Class對象的newInstance方法

二、建造者模式

它提供了一種創建對象的最佳方式

1、定義：

將一個復雜對象的構建與它的表示分離，使得同樣的構建過程可以創建不同的表示。

建造者模式（Builder Pattern） 又叫生成器模式，是一種對象構建模式。它可以將復雜對象的建造過程抽象出來（抽象類別），使這個抽象過程的不同實現方法可以構造出不同表現（屬性）的對象。

2、主要作用：

在用戶不知道 對象的建造過程和細節的情況下就可以直接創建復雜的對象。

用戶只需要給出指定復雜對象的類型和內容，建造者牧師負責按順序創建復雜對象（把內部的建造過程和細節隱藏起來）

3、四種角色[★ 結合第四點的建造房子理解]

1) Product(產品角色)：一個具體的產品對象。

2) Builder(抽象建造者): 創建一個Product對象的各個部件指定的 接口/抽象類。

3) ConcreteBuilder(具體建造者): 實現接口，構建和裝配各個部件。

4) Director(指揮者): 構建一個使用Builder接口的對象。它主要是用于創建一個復雜的對象。

它主要有兩個作用，一是：隔離了客戶與對象的生產過程，二是：負責控制產品對象的生產過程。

4、舉例：建造房子

需要建房子：這一過程為打樁、砌墻、封頂。不管是普通房子也好，別墅也好都 需要經歷這些過程，下面我們使用建造者模式(Builder Pattern)來完成.

1、產品角色：Product-房子，定義了房子的屬性

2、抽象建造者：Builder-抽象的工人，定義了一些建造房子組件的方法和接口

3、具體建造者：ConcreteBuilder-具體的工人，實現了建造房子組件

4、指揮者：Director-房子的指揮設計者，：核心負責指揮構建一個工程，決定了工程如何構建，按照什么順序構建

// 產品：房子[定義了房子的屬性] public class Product {private String buildA;private String buildB;private String buildC;private String buildD;public String getBuildA() {return buildA;}public void setBuildA(String buildA) {this.buildA = buildA;}public String getBuildB() {return buildB;}public void setBuildB(String buildB) {this.buildB = buildB;}public String getBuildC() {return buildC;}public void setBuildC(String buildC) {this.buildC = buildC;}public String getBuildD() {return buildD;}public void setBuildD(String buildD) {this.buildD = buildD;}@Overridepublic String toString() {return "Product{" +"buildA='" + buildA + '\'' +", buildB='" + buildB + '\'' +", buildC='" + buildC + '\'' +", buildD='" + buildD + '\'' +'}';} }// 抽象的建造者[抽象的工人]：只是定義一些方法和接口 public abstract class Builder {abstract void buildA(); // 地基abstract void buildB(); // 鋼筋工程abstract void buildC(); // 鋪電線abstract void buildD(); // 粉刷// 完工：得到產品abstract Product getProduct(); }// 具體的建造者[工人]: public class Worker extends Builder {private Product product;public Worker() {product = new Product();// 工人負責創建產品}@Overridevoid buildA() {product.setBuildA("地基");System.out.println("地基");}@Overridevoid buildB() {product.setBuildB("鋼筋工程");System.out.println("鋼筋工程");}@Overridevoid buildC() {product.setBuildC("鋪電線");System.out.println("鋪電線");}@Overridevoid buildD() {product.setBuildD("粉刷");System.out.println("粉刷");}@OverrideProduct getProduct() {return product;} }// 指揮者：核心負責指揮構建一個工程，工程如何構建，按照什么順序構建，由他決定 public class Director {// 指揮工人按照順序建房子public Product build(Builder builder){builder.buildA();builder.buildB();builder.buildC();builder.buildD();return builder.getProduct();} }public class Test {public static void main(String[] args) {// 指揮Director director = new Director();// 指揮 具體的工人 完成產品Product build = director.build(new Worker());System.out.println(build.toString());} }

5、建造者模式在JDK的應用和源碼分析 (java.lang.StringBuilder中的建造者模式)

■ 源碼中建造者模式角色分析

? Appendable接口，是抽象建造者, 定義了抽象方法，定義了多個append方法(抽象方法)

? AbstractStringBuilder抽象類，實現了 Appendable接口方法，AbstractStringBuilder 是建造者，只是不能實例化

? StringBuilder 繼承了AbstractStringBuilder，即充當了指揮者角色，同時充當了具體的建造者，建造方法的實現是由 AbstractStringBuilder 完成, 而StringBuilder 繼承了 AbstractStringBuilder

6、建造者模式的優缺點

優點：

• 產品的建造和表示分離，實現了解耦。使用建造者模式可以使客戶端不必知道產品內部組成的細節
• 用戶使用不同的具體建造者即可得到不同的產品對象
• 將復雜產品的創建步驟分解在不同的方法中，是得創建過程更加清晰
• 具體的建造者之間是相互獨立的，這有利于系統的擴展。增加新的具體建造者無需修改原有類庫代碼，符合“開閉原則”

缺點：

• 建造者模式所創建的產品一般具有較多的共同點，其組成部分相似；如果產品之間的差異性很大，則不適合使用建造者模式，因此其使用范圍受到一定的限制
• 如果產品的內部變化復雜，可能會導致需要定義很多具體建造者類來實現這種變化，導致系統變的很龐大

7、抽象工廠模式VS建造者模式

抽象工廠模式實現對產品家族的創建，一個產品家族是這樣的一系列產品：具有不同分類維度的產品組合，采用抽象工廠模式不需要關心構建過程，只關心什么產品 由什么工廠生產即可。

而建造者模式則是要求按照指定的藍圖建造產品，它的主要目的是通過組裝零配件而產生一個新產品。

參考內容來源：《尚硅谷Java設計模式（圖解+框架源碼剖析）》 https://www.bilibili.com/video/BV1G4411c7N4
《【狂神說Java】通俗易懂的23種設計模式教學（停更）》https://www.bilibili.com/video/BV1mc411h719?p=5

如果本文對你有幫助的話記得給一樂點個贊哦，感謝！

總結

以上是生活随笔為你收集整理的设计模式之---工厂模式、建造者模式的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。