一、簡介

　　創建型模式：這些設計模式提供了一種在創建對象的同時隱藏創建邏輯的方式，而不是使用 new 運算符直接實例化對象。這使得程序在判斷針對某個給定實例需要創建哪些對象時更加靈活。創建型模式包括：工廠模式（Factory Pattern），抽象工廠模式（Abstract Factory Pattern），單例模式（Singleton Pattern），建造者模式（Builder Pattern），原型模式（Prototype Pattern）。

?

二、工廠模式（Factory Pattern）

　　1、概念

　　　工廠模式（Factory Pattern）是 Java 中最常用的設計模式之一。這種類型的設計模式屬于創建型模式，它提供了一種創建對象的最佳方式。在工廠模式中，我們在創建對象時不會對客戶端暴露創建邏輯，并且是通過使用一個共同的接口來指向新創建的對象。

　　2、簡介

　　　意圖：定義一個創建對象的接口，讓其子類自己決定實例化哪一個工廠類，工廠模式使其創建過程延遲到子類進行。

　　　主要解決：主要解決接口選擇的問題。

　　　何時使用：我們明確地計劃不同條件下創建不同實例時。

　　　如何解決：讓其子類實現工廠接口，返回的也是一個抽象的產品。

　　　應用實例：?您需要一輛汽車，可以直接從工廠里面提貨，而不用去管這輛汽車是怎么做出來的，以及這個汽車里面的具體實現。

　　　優點：?

　　　　（1）、一個調用者想創建一個對象，只要知道其名稱就可以了。

　　　　（2）、擴展性高，如果想增加一個產品，只要擴展一個工廠類就可以。

　　　　（3）、屏蔽產品的具體實現，調用者只關心產品的接口。

　　　缺點：每次增加一個產品時，都需要增加一個具體類和對象實現工廠，使得系統中類的個數成倍增加，在一定程度上增加了系統的復雜度，同時也增加了系統具體類的依賴。這并不是什么好事。

　　　使用場景：?

　　　　（1）、日志記錄器：記錄可能記錄到本地硬盤、系統事件、遠程服務器等，用戶可以選擇記錄日志到什么地方。

　　　　（2）、數據庫訪問，當用戶不知道最后系統采用哪一類數據庫，以及數據庫可能有變化時。

　　　　（3）、設計一個連接服務器的框架，需要三個協議，"POP3"、"IMAP"、"HTTP"，可以把這三個作為產品類，共同實現一個接口。

　　　注意事項：作為一種創建類模式，在任何需要生成復雜對象的地方，都可以使用工廠方法模式。有一點需要注意的地方就是復雜對象適合使用工廠模式，而簡單對象，特別是只需要通過 new 就可以完成創建的對象，無需使用工廠模式。如果使用工廠模式，就需要引入一個工廠類，會增加系統的復雜度。

　　3、實例

　　　我們將創建一個?Shape?接口和實現?Shape?接口的實體類。然后定義工廠類?ShapeFactory。FactoryPatternDemo，我們的演示類使用?ShapeFactory?來獲取?Shape?對象。它將向?ShapeFactory?傳遞信息（CIRCLE / RECTANGLE / SQUARE），以便獲取它所需對象的類型。

　　　　

　　　　（1）、創建 Shape 接口；

public interface Shape {void draw(); }

　　　　（2）、創建實現接口的實體類；

public class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("三角形");} } public class Circle implements Shape {@Overridepublic void draw() {System.out.println("圓形");} } public class Square implements Shape { @Override public void draw() { System.out.println("矩形"); } }

　　　　（3）、創建一個工廠，用于生成基于給定信息的實體類的對象；

public class ShapeFactory {//使用 getShape 方法獲取形狀類型的對象public Shape getShape(String shapeType){if(shapeType == null){return null;} if(shapeType.equalsIgnoreCase("CIRCLE")){return new Circle();} else if(shapeType.equalsIgnoreCase("RECTANGLE")){return new Rectangle();} else if(shapeType.equalsIgnoreCase("SQUARE")){return new Square();}return null;} }

　　　　（4）、使用該工廠，通過傳遞類型信息來獲取實體類的對象；

public class FactoryPatternDemo {public static void main(String[] args) {ShapeFactory shapeFactory = new ShapeFactory();//獲取 Circle 的對象，并調用它的 draw 方法Shape shape1 = shapeFactory.getShape("CIRCLE");//調用 Circle 的 draw 方法 shape1.draw();//獲取 Rectangle 的對象，并調用它的 draw 方法Shape shape2 = shapeFactory.getShape("RECTANGLE");//調用 Rectangle 的 draw 方法 shape2.draw();//獲取 Square 的對象，并調用它的 draw 方法Shape shape3 = shapeFactory.getShape("SQUARE");//調用 Square 的 draw 方法 shape3.draw();} }

　　　　（5）、驗證結果；

圓形 三角形 矩形

?

三、抽象工廠模式（Abstract Factory Pattern）

　　1、概念

　　　抽象工廠模式（Abstract Factory Pattern）是圍繞一個超級工廠創建其他工廠。該超級工廠又稱為其他工廠的工廠。這種類型的設計模式屬于創建型模式，它提供了一種創建對象的最佳方式。在抽象工廠模式中，接口是負責創建一個相關對象的工廠，不需要顯式指定它們的類。每個生成的工廠都能按照工廠模式提供對象。

　　2、簡介

　　　意圖：提供一個創建一系列相關或相互依賴對象的接口，而無需指定它們具體的類。

　　　主要解決：主要解決接口選擇的問題。

　　　何時使用：系統的產品有多于一個的產品族，而系統只消費其中某一種產品時。

　　　如何解決：在一個產品族里面，定義多個產品。

　　　應用實例：工作了，為了參加一些聚會，肯定有兩套或多套衣服吧，比如說有商務裝（成套，一系列具體產品）、時尚裝（成套，一系列具體產品），甚至對于一個家庭來說，可能有商務女裝、商務男裝、時尚女裝、時尚男裝，這些也都是成套的，即一系列具體產品。假設一種情況，在您的家中，某一個衣柜（具體工廠）只能存放某一種這樣的衣服（成套，一系列具體產品），每次拿這種成套的衣服時也自然要從這個衣柜中取出了。所有的衣柜（具體工廠）都是衣柜類中的的（抽象工廠）某一個，而每一件成套的衣服又包括具體的上衣（某一具體產品），褲子（某一具體產品），這些具體的上衣其實也都屬于上衣類（抽象產品），具體的褲子也都屬于褲子類（另一個抽象產品）。

　　　優點：當一個產品族中的多個對象被設計成一起工作時，它能保證客戶端始終只使用同一個產品族中的對象。

　　　缺點：產品族擴展非常困難，要增加一個系列的某一產品，既要在抽象的 Creator 里加代碼，又要在具體的里面加代碼。

　　　使用場景：?1、QQ 換皮膚，一整套一起換。 2、生成不同操作系統的程序。

　　　注意事項：產品族難擴展，產品等級易擴展。

　　3、實例

　　　我們將創建?Shape?和?Color?接口和實現這些接口的實體類。然后創建抽象工廠類?AbstractFactory。接著定義工廠類?ShapeFactory?和?ColorFactory，這兩個工廠類都是擴展了?AbstractFactory。然后創建一個工廠創造器/生成器類?FactoryProducer。最后創建演示類AbstractFactoryPatternDemo，我們的演示類使用?FactoryProducer?來獲取?AbstractFactory?對象。它將向?AbstractFactory?傳遞形狀信息?Shape（CIRCLE / RECTANGLE / SQUARE），以便獲取它所需對象的類型。同時它還向?AbstractFactory?傳遞顏色信息?Color（RED / GREEN / BLUE），以便獲取它所需對象的類型。

　　　　

　　　　（1）、創建 Shape 接口及其實現類

public interface Shape {void draw(); } public class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("這是三角形");} } public class Square implements Shape {@Overridepublic void draw() {System.out.println("這是矩形");} } public class Circle implements Shape {@Overridepublic void draw() {System.out.println("這是圓形");} }

　　　　（2）、創建 Color 接口及其實現類

public interface Color {void fill(); } public class Red implements Color {@Overridepublic void fill() {System.out.println("這是紅色");} } public class Blue implements Color {@Overridepublic void fill() {System.out.println("這是藍色");} } public class Black implements Color {@Overridepublic void fill() {System.out.println("這是黑色");} }

　　　　（3）、為 Color 和 Shape 對象創建抽象類來獲取工廠。

public abstract class AbstractFactory {public abstract Color getColor(String color);public abstract Shape getShape(String shape) ; }

　　　　（4）、創建擴展了 AbstractFactory 的工廠類，基于給定的信息生成實體類的對象。

public class ShapeFactory extends AbstractFactory {@Overridepublic Shape getShape(String shapeType){if(shapeType == null){return null;} if(shapeType.equalsIgnoreCase("CIRCLE")){return new Circle();} else if(shapeType.equalsIgnoreCase("RECTANGLE")){return new Rectangle();} else if(shapeType.equalsIgnoreCase("SQUARE")){return new Square();}return null;}@Overridepublic Color getColor(String color) {return null;} } public class ColorFactory extends AbstractFactory {@Overridepublic Shape getShape(String shapeType){return null;}@OverrideColor getColor(String color) {if(color == null){return null;} if(color.equalsIgnoreCase("RED")){return new Red();} else if(color.equalsIgnoreCase("Black")){return new Black();} else if(color.equalsIgnoreCase("BLUE")){return new Blue();}return null;} }

　　　　（5）、創建一個工廠創造器/生成器類，通過傳遞形狀或顏色信息來獲取工廠。

public class FactoryProducer {public static AbstractFactory getFactory(String choice){if(choice.equalsIgnoreCase("SHAPE")){return new ShapeFactory();} else if(choice.equalsIgnoreCase("COLOR")){return new ColorFactory();}return null;} }

　　　　（6）、使用 FactoryProducer 來獲取 AbstractFactory，通過傳遞類型信息來獲取實體類的對象。

public class AbstractFactoryPatternDemo {public static void main(String[] args) {//獲取形狀工廠AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");//獲取形狀為 Circle 的對象Shape shape1 = shapeFactory.getShape("CIRCLE");//調用 Circle 的 draw 方法 shape1.draw();//獲取形狀為 Rectangle 的對象Shape shape2 = shapeFactory.getShape("RECTANGLE");//調用 Rectangle 的 draw 方法 shape2.draw();//獲取形狀為 Square 的對象Shape shape3 = shapeFactory.getShape("SQUARE");//調用 Square 的 draw 方法 shape3.draw();//獲取顏色工廠AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");//獲取顏色為 Red 的對象Color color1 = colorFactory.getColor("RED");//調用 Red 的 fill 方法 color1.fill();//獲取顏色為 Black 的對象Color color2 = colorFactory.getColor("Black");//調用 Black 的 fill 方法 color2.fill();//獲取顏色為 Blue 的對象Color color3 = colorFactory.getColor("BLUE");//調用 Blue 的 fill 方法 color3.fill();} }

　　　　（7）、演示結果

這是圓形 這是三角形 這是矩形 這是紅色 這是黑色 這是藍色

?

四、單例模式（Singleton Pattern）

　　1、概念

　　　單例模式（Singleton Pattern）是 Java 中最簡單的設計模式之一。這種類型的設計模式屬于創建型模式，它提供了一種創建對象的最佳方式。這種模式涉及到一個單一的類，該類負責創建自己的對象，同時確保只有單個對象被創建。這個類提供了一種訪問其唯一的對象的方式，可以直接訪問，不需要實例化該類的對象。

　　2、簡介

　　　意圖：保證一個類僅有一個實例，并提供一個訪問它的全局訪問點。

　　　主要解決：一個全局使用的類頻繁地創建與銷毀。

　　　何時使用：當您想控制實例數目，節省系統資源的時候。

　　　如何解決：判斷系統是否已經有這個單例，如果有則返回，如果沒有則創建。

　　　關鍵代碼：構造函數是私有的。

　　　應用實例：

　　　　（1）、Windows 是多進程多線程的，在操作一個文件的時候，就不可避免地出現多個進程或線程同時操作一個文件的現象，所以所有文件的處理必須通過唯一的實例來進行。

　　　　（2）、一些設備管理器常常設計為單例模式，比如一個電腦有兩臺打印機，在輸出的時候就要處理不能兩臺打印機打印同一個文件。

　　　優點：?

　　　　（1）、在內存里只有一個實例，減少了內存的開銷，尤其是頻繁的創建和銷毀實例。

　　　　（2）、避免了對資源的多重占用（比如寫文件操作）。

　　　缺點：沒有接口，不能繼承，與單一職責原則沖突，一個類應該只關心內部邏輯，而不關心外面怎么樣來實例化。

　　　使用場景：?

　　　　（1）、要求生產唯一序列號。

　　　　（2）、WEB 中的計數器，不用每次刷新都在數據庫里加一次，用單例先緩存起來。

　　　　（3）、創建的一個對象需要消耗的資源過多，比如 I/O 與數據庫的連接等。

　　　注意事項：

　　　　（1）、單例類只能有一個實例。

　　　　（2）、單例類必須自己創建自己的唯一實例。

　　　　（3）、單例類必須給所有其他對象提供這一實例。

　　　　（4）、getInstance() 方法中需要使用同步鎖 synchronized (Singleton.class) 防止多線程同時進入造成 instance 被多次實例化。

　　3、實例

　　　我們將創建一個?SingleObject?類。SingleObject?類有它的私有構造函數和本身的一個靜態實例。SingleObject?類提供了一個靜態方法，供外界獲取它的靜態實例。創建演示類SingletonPatternDemo，我們的演示類使用?SingleObject?類來獲取?SingleObject?對象。

　　　　

　　　　（1）、創建一個 SingleObject 類。

public class SingleObject {//創建 SingleObject 的一個對象private static SingleObject instance = new SingleObject();//讓構造函數為 private，這樣該類就不會被實例化private SingleObject(){}//獲取唯一可用的對象public static SingleObject getInstance(){return instance;}public void showMessage(){System.out.println("Hello World!");} }

　　　　（2）、創建?SingletonPatternDemo 類，從?SingleObject 類獲取唯一的對象

public class SingletonPatternDemo {public static void main(String[] args) {//不合法的構造函數//編譯時錯誤：構造函數 SingleObject() 是不可見的//SingleObject object = new SingleObject();//獲取唯一可用的對象SingleObject object = SingleObject.getInstance();//顯示消息 object.showMessage();} }

　　　　（3）、驗證實例

Hello World!

?

五、建造者模式（Builder Pattern）

　　1、概念

　　　建造者模式（Builder Pattern）使用多個簡單的對象一步一步構建成一個復雜的對象。這種類型的設計模式屬于創建型模式，它提供了一種創建對象的最佳方式。一個 Builder 類會一步一步構造最終的對象。該 Builder 類是獨立于其他對象的。

　　2、簡介

　　　意圖：將一個復雜的構建與其表示相分離，使得同樣的構建過程可以創建不同的表示。

　　　主要解決：主要解決在軟件系統中，有時候面臨著"一個復雜對象"的創建工作，其通常由各個部分的子對象用一定的算法構成；由于需求的變化，這個復雜對象的各個部分經常面臨著劇烈的變化，但是將它們組合在一起的算法卻相對穩定。

　　　何時使用：一些基本部件不會變，而其組合經常變化的時候。

　　　如何解決：將變與不變分離開。

　　　應用實例：?

　　　　（1）、去肯德基，漢堡、可樂、薯條、炸雞翅等是不變的，而其組合是經常變化的，生成出所謂的"套餐"。

　　　　（2）、JAVA 中的 StringBuilder。

　　　優點：?

　　　　（1）、建造者獨立，易擴展。

　　　　（2）、便于控制細節風險。

　　　缺點：?

　　　　（1）、產品必須有共同點，范圍有限制。

　　　　（2）、如內部變化復雜，會有很多的建造類。

　　　使用場景：?

　　　　（1）、需要生成的對象具有復雜的內部結構。

　　　　（2）、需要生成的對象內部屬性本身相互依賴。

　　　注意事項：與工廠模式的區別是：建造者模式更加關注與零件裝配的順序。

?　　3、實例

　　　我們假設一個快餐店的商業案例，其中，一個典型的套餐可以是一個漢堡（Burger）和一杯冷飲（Cold drink）。漢堡（Burger）可以是素食漢堡（Veg Burger）或雞肉漢堡（Chicken Burger），它們是包在紙盒中。冷飲（Cold drink）可以是可口可樂（coke）或百事可樂（pepsi），它們是裝在瓶子中。我們將創建一個表示食物條目（比如漢堡和冷飲）的?Item?接口和實現?Item?接口的實體類，以及一個表示食物包裝的?Packing?接口和實現?Packing?接口的實體類，漢堡是包在紙盒中，冷飲是裝在瓶子中。然后我們創建一個?Meal?類，帶有?Item?的?ArrayList?和一個通過結合?Item?來創建不同類型的?Meal?對象的?MealBuilder。最后創建演示類 BuilderPatternDemo，我們的演示類使用?MealBuilder?來創建一個?Meal。

　　　　

　　　　（1）、創建一個表示食物條目（Item）和食物包裝（Packing）的接口

public interface Item {public String name();public Packing packing();public float price(); } public interface Packing {public String pack(); }

　　　（2）、創建 Packing 接口的實現類

public class Wrapper implements Packing {@Overridepublic String pack() {return "Wrapper";} } public class Bottle implements Packing {@Overridepublic String pack() {return "Bottle";} }

　　　　（3）、創建實現 Item 接口的抽象類，該類提供了默認的功能。

public abstract class Burger implements Item {@Overridepublic Packing packing() {return new Wrapper();}@Overridepublic abstract float price(); } public abstract class ColdDrink implements Item {@Overridepublic Packing packing() {return new Bottle();}@Overridepublic abstract float price(); }

　　　　（4）、創建擴展了 Burger 和 ColdDrink 的實體類。

public class VegBurger extends Burger {@Overridepublic float price() {return 25.0f;}@Overridepublic String name() {return "Veg Burger";} } public class ChickenBurger extends Burger {@Overridepublic float price() {return 50.5f;}@Overridepublic String name() {return "Chicken Burger";} } public class Coke extends ColdDrink {@Overridepublic float price() {return 30.0f;}@Overridepublic String name() {return "Coke";} } public class Pepsi extends ColdDrink {@Overridepublic float price() {return 35.0f;}@Overridepublic String name() {return "Pepsi";} }

　　　　（5）、創建一個 Meal 類，帶有上面定義的 Item 對象。

import java.util.ArrayList; import java.util.List;public class Meal {private List<Item> items = new ArrayList<Item>(); public void addItem(Item item){items.add(item);}public float getCost(){float cost = 0.0f;for (Item item : items) {cost += item.price();} return cost;}public void showItems(){for (Item item : items) {System.out.print("Item : "+item.name());System.out.print(", Packing : "+item.packing().pack());System.out.println(", Price : "+item.price());} } }

　　　　（6）、創建一個 MealBuilder 類，實際的 builder 類負責創建 Meal 對象。

public class MealBuilder {public Meal prepareVegMeal (){Meal meal = new Meal();meal.addItem(new VegBurger());meal.addItem(new Coke());return meal;} public Meal prepareNonVegMeal (){Meal meal = new Meal();meal.addItem(new ChickenBurger());meal.addItem(new Pepsi());return meal;} }

　　　　（7）、BuiderPatternDemo 使用 MealBuider 來演示建造者模式（Builder Pattern）。

public class BuilderPatternDemo {public static void main(String[] args) {MealBuilder mealBuilder = new MealBuilder();Meal vegMeal = mealBuilder.prepareVegMeal();System.out.println("Veg Meal");vegMeal.showItems();System.out.println("Total Cost: " +vegMeal.getCost());Meal nonVegMeal = mealBuilder.prepareNonVegMeal();System.out.println("\nNon-Veg Meal");nonVegMeal.showItems();System.out.println("Total Cost: " +nonVegMeal.getCost());} }

　　　　（8）、演示結果

Veg Meal Item : Veg Burger, Packing : Wrapper, Price : 25.0 Item : Coke, Packing : Bottle, Price : 30.0 Total Cost: 55.0Non-Veg Meal Item : Chicken Burger, Packing : Wrapper, Price : 50.5 Item : Pepsi, Packing : Bottle, Price : 35.0 Total Cost: 85.5

?

六、原型模式（Prototype Pattern）

　　1、概念

　　　原型模式（Prototype Pattern）是用于創建重復的對象，同時又能保證性能。這種類型的設計模式屬于創建型模式，它提供了一種創建對象的最佳方式。這種模式是實現了一個原型接口，該接口用于創建當前對象的克隆。當直接創建對象的代價比較大時，則采用這種模式。

　　2、簡介

　　　意圖：用原型實例指定創建對象的種類，并且通過拷貝這些原型創建新的對象。

　　　主要解決：在運行期建立和刪除原型。

　　　何時使用：?

　　　　（1）、當一個系統應該獨立于它的產品創建、構成和表示時。

　　　　（2）、當要實例化的類是在運行時刻指定時，例如，通過動態裝載。

　　　　（3）、為了避免創建一個與產品類層次平行的工廠類層次時。

　　　　（4）、當一個類的實例只能有幾個不同狀態組合中的一種時。建立相應數目的原型并克隆它們可能比每次用合適的狀態手工實例化該類更方便一些。

　　　如何解決：利用已有的一個原型對象，快速地生成和原型對象一樣的實例。

　　　優點：?

　　　　（1）、性能提高。

　　　　（2）、逃避構造函數的約束。

　　　缺點：?

　　　　（1）、配備克隆方法需要對類的功能進行通盤考慮，這對于全新的類不是很難，但對于已有的類不一定很容易，特別當一個類引用不支持串行化的間接對象，或者引用含有循環結構的時候。

　　　　（2）、必須實現 Cloneable 接口。

　　　使用場景：?

　　　　（1）、資源優化場景。

　　　　（2）、類初始化需要消化非常多的資源，這個資源包括數據、硬件資源等。

　　　　（3）、性能和安全要求的場景。

　　　　（4）、通過 new 產生一個對象需要非常繁瑣的數據準備或訪問權限，則可以使用原型模式。

　　　　（5）、一個對象多個修改者的場景。

　　　　（6）、一個對象需要提供給其他對象訪問，而且各個調用者可能都需要修改其值時，可以考慮使用原型模式拷貝多個對象供調用者使用。

　　　　（7）、在實際項目中，原型模式很少單獨出現，一般是和工廠方法模式一起出現，通過 clone 的方法創建一個對象，然后由工廠方法提供給調用者。原型模式已經與 Java 融為渾然一體，大家可以隨手拿來使用。

　　　注意事項：與通過對一個類進行實例化來構造新對象不同的是，原型模式是通過拷貝一個現有對象生成新對象的。淺拷貝實現 Cloneable，重寫，深拷貝是通過實現 Serializable 讀取二進制流。

　　3、實例

　　　我們將創建一個抽象類?Shape?和擴展了?Shape?類的實體類。下一步是定義類?ShapeCache，該類把 shape 對象存儲在一個?Hashtable?中，并在請求的時候返回它們的克隆。最后創建演示類PrototypePatternDemo，我們的演示類使用?ShapeCache?類來獲取?Shape?對象。

　　　　

　　　　（1）、創建一個實現了?Clonable?接口的抽象類 Shape；

public abstract class Shape implements Cloneable {private String id;protected String type;abstract void draw();public String getType(){return type;}public String getId() {return id;}public void setId(String id) {this.id = id;}public void setType(String type) {this.type = type;}public Object clone() {Object clone = null;try {clone = super.clone();} catch (CloneNotSupportedException e) {e.printStackTrace();}return clone;} }

　　　　（2）、創建擴展了上面抽象類的實體類

public class Rectangle extends Shape {public Rectangle(){type = "Rectangle";}@Overridepublic void draw() {System.out.println("這是三角形");} } public class Square extends Shape {public Square(){type = "Square";}@Overridepublic void draw() {System.out.println("這是矩形");} } public class Circle extends Shape {public Circle(){type = "Circle";}@Overridepublic void draw() {System.out.println("這是圓形");} }

　　　　（3）、創建一個類，從數據庫獲取實體類，并把它們存儲在一個?Hashtable?中

import java.util.Hashtable;public class ShapeCache {private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>();public static Shape getShape(String shapeId) {Shape cachedShape = shapeMap.get(shapeId);return (Shape) cachedShape.clone();}// 對每種形狀都運行數據庫查詢，并創建該形狀// shapeMap.put(shapeKey, shape);// 例如，我們要添加三種形狀public static void loadCache() {Circle circle = new Circle();circle.setId("1");shapeMap.put(circle.getId(),circle);Square square = new Square();square.setId("2");shapeMap.put(square.getId(),square);Rectangle rectangle = new Rectangle();rectangle.setId("3");shapeMap.put(rectangle.getId(),rectangle);} }

　　　　（4）、PrototypePatternDemo?使用?ShapeCache?類來獲取存儲在?Hashtable?中的形狀的克隆。

public class PrototypePatternDemo {public static void main(String[] args) {ShapeCache.loadCache();Shape clonedShape = (Shape) ShapeCache.getShape("1");System.out.println("Shape : " + clonedShape.getType()); Shape clonedShape2 = (Shape) ShapeCache.getShape("2");System.out.println("Shape : " + clonedShape2.getType()); Shape clonedShape3 = (Shape) ShapeCache.getShape("3");System.out.println("Shape : " + clonedShape3.getType()); } }

　　　　（5）、驗證輸出

Shape : Circle Shape : Square Shape : Rectangle

?

創建型模式的介紹就到此結束了，如有錯誤，還望各位大佬指正；

轉載于:https://www.cnblogs.com/WHL5/p/9183113.html

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

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

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