建造者模式
定義
又叫生成器模式，它可以將復雜對象的建造過程抽象出來（抽象類別），使這個抽象過程的不同實現方法可以構造出不同表現（屬性）的對象。
當創建復雜對象的算法應該獨立于該對象的組成部分時，而且構造過程必須允許被構造的對象有不同的表示時。我們可以考慮使用建造者模式。
實現
1. Builder為創建一個Product對象的各個部件指定抽象接口。通常包含創建產品和返回產品的抽象方法，也可以是具體方法，把創建過程放到ConcreteBuilder類中。
2. ConcreteBuilder 實現Builder的接口以構造和裝配該產品的各個部件。
3. Director負責調用適當的建造者來組建產品，導演類一般不與產品類發生依賴關系，與導演類直接交互的是建造者類。
4. Product表示被構造的復雜對象。ConcreateBuilder創建該產品的內部表示并定義它的裝配過程。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
/** "Product" */ class Pizza { private String dough = ""; private String sauce = ""; private String topping = ""; public void setDough (String dough) { this.dough = dough; } public void setSauce (String sauce) { this.sauce = sauce; } public void setTopping (String topping) { this.topping = topping; } } ''/** "Abstract Builder" */'' abstract class PizzaBuilder { protected Pizza pizza; public Pizza getPizza() { return pizza; } public void createNewPizzaProduct() { pizza = new Pizza(); } public abstract void buildDough(); public abstract void buildSauce(); public abstract void buildTopping(); } /** "ConcreteBuilder" */ class HawaiianPizzaBuilder extends PizzaBuilder { public void buildDough() { pizza.setDough("cross"); } public void buildSauce() { pizza.setSauce("mild"); } public void buildTopping() { pizza.setTopping("ham+pineapple"); } } /** "ConcreteBuilder" */ class SpicyPizzaBuilder extends PizzaBuilder { public void buildDough() { pizza.setDough("pan baked"); } public void buildSauce() { pizza.setSauce("hot"); } public void buildTopping() { pizza.setTopping("pepperoni+salami"); } } ''/** "Director" */'' class Waiter { private PizzaBuilder pizzaBuilder; public void setPizzaBuilder (PizzaBuilder pb) { pizzaBuilder = pb; } public Pizza getPizza() { return pizzaBuilder.getPizza(); } public void constructPizza() { pizzaBuilder.createNewPizzaProduct(); pizzaBuilder.buildDough(); pizzaBuilder.buildSauce(); pizzaBuilder.buildTopping(); } } /** A customer ordering a pizza. */ class BuilderExample { public static void main(String[] args) { Waiter waiter = new Waiter(); PizzaBuilder hawaiian_pizzabuilder = new HawaiianPizzaBuilder(); PizzaBuilder spicy_pizzabuilder = new SpicyPizzaBuilder(); waiter.setPizzaBuilder ( hawaiian_pizzabuilder ); waiter.constructPizza(); Pizza pizza = waiter.getPizza(); } } |
客戶創建Director對象，并用它所想要的Builder對象進行配置。Director取得客戶的請求創建產品，最后取得產品。
優點
1. 可以對構造對象的過程進行精細的控制，以產生不同的產品對象。
2. 便于擴展，有新的產品時，只需增加新的ConcreteBuilder 就可以實現。
相關模式
抽象工廠模式與生成器相似，因為它也可以創建復雜對象。主要的區別是生成器模式著重于一步步構造一個復雜對象。而抽象工廠模式著重于多個系列的產品對象（簡單的或是復雜的）。
生成器在最后的一步返回產品，而對于抽象工廠來說，產品是立即返回的。
原型模式
定義
原型模式是創建型模式的一種,其特點在于通過“復制”一個已經存在的實例來返回新的實例,而不是新建實例。被復制的實例就是我們所稱的“原型”，這個原型是可定制的。
原型模式多用于創建復雜的或者耗時的實例，因為這種情況下，復制一個已經存在的實例使程序運行更高效；或者創建值相等，只是命名不一樣的同類數據。
實現
1. Client - 創建一個新的對象，然后通過clone得到另外一個對象。
2. Prototype - 定義一個clone自己的抽象方法。
3. ConcretePrototype - 實現clone方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public interface Prototype { public abstract Object clone ( ); } public class ConcretePrototype implements Prototype { public Object clone() { return super.clone(); } } public class Client { public static void main( String arg[] ) { ConcretePrototype obj1= new ConcretePrototype (); ConcretePrototype obj2 = ConcretePrototype)obj1.clone(); } } |
實例
1. 游戲中很多元素都是重復的，我們可以使用原型模式復制相同的元素。
2. 制作數據圖表時，第一次我們需要從數據庫讀取數據保存到對象中，當需要制作相同數據的其他圖表時，使用原型模式可以避免重新讀取數據庫。
相關問題和實現
1. 如果需要創建的原型數目不固定，可以創建一個原型管理器，在復制原型對象之前，客戶端先在原型管理器中查看
是否存在滿足條件的原型對象，如果有，則直接使用，如果沒有，克隆一個，這種稱作登記形式的原型模式。
2. 復制有兩種：深復制和淺復制。淺復制時，復制對象和原型對象共享對象所有的內部變量，兩個對象具有一樣的內存空間和生命周期。對原型對象的修改同時也修改了它的復制品，反之亦然。
java中只要實現Cloneable接口就可以調用Object類的clone方法實現淺復制：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
public class ShallowClone implements Cloneable { int age; Person person; public void setAge(int age){ this.age = age; } public void setPerson(String name){ person = new Person(name); } public Object clone() throws CloneNotSupportedException{ // 默認java實現的是淺復制 return super.clone(); } } public class Person { String name; public Person(String name){ this.name = name; } } public class Test { public static void main(String[] args) throws CloneNotSupportedException { ShallowClone oldShallowClone = new ShallowClone(); oldShallowClone.setAge(20); oldShallowClone.setPerson("eric"); System.out.println("oldname: " + oldShallowClone.person.name + " age: " + oldShallowClone.age); ShallowClone newShallowClone = (ShallowClone)oldShallowClone.clone(); System.out.println("newname: " + newShallowClone.person.name + " age: " + newShallowClone.age); oldShallowClone.age = 30; oldShallowClone.person.name = "frank"; System.out.println("newname: " + newShallowClone.person.name + " age: " + newShallowClone.age); } } |
輸出：
|
1
2
3
|
oldname: eric age: 20newname: eric age: 20newname: frank age: 20 |
可見淺復制復制的是對象的引用，當改變對象的值時，復制后的對象也會改變，而java的基本類型是復制的值。
下面我們實現深復制：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
public class DeepClone { int age; Person person; public void setAge(int age){ this.age = age; } public void setPerson(String name){ person = new Person(name); } public DeepClone(DeepClone deepClone){ this.age = deepClone.age; this.person = new Person(deepClone.person.name); } public DeepClone() {} public Object clone() throws CloneNotSupportedException{ return new DeepClone(this); } } public class Test { public static void main(String[] args) throws CloneNotSupportedException { DeepClone oldDeepClone = new DeepClone(); oldDeepClone.setAge(20); oldDeepClone.setPerson("eric"); System.out.println("oldname: " + oldDeepClone.person.name + " age: " + oldDeepClone.age); DeepClone newDeepClone = (DeepClone)oldDeepClone.clone(); System.out.println("newname: " + newDeepClone.person.name + " age: " + newDeepClone.age); oldDeepClone.age = 30; oldDeepClone.person.name = "frank"; System.out.println("newname: " + newDeepClone.person.name + " age: " + newDeepClone.age); } } |
輸出：
|
1
2
3
|
oldname: eric age: 20newname: eric age: 20newname: eric age: 20 |
上面的復制方法中，我們重新創建了一個對象，并且重新創建了引用，實現了深度復制。
優點
1. 復制比new性能更好。
2. 簡化或者隱藏創建對象的細節，直接復制。
