建造者模式(Java與Kotlin版)

 

前文推送html

設計模式編程

簡單工廠模式(Java與Kotlin版)設計模式

工廠方法模式(Java與Kotlin版)ide

抽象工廠模式(Java與Kotlin版)post

 

Kotlin基礎知識測試

Kotlin入門第一課:從對比Java開始ui

Kotlin入門第二課:集合操做spa

Kotlin入門第三課:數據類型設計

初次嘗試用Kotlin實現Android項目3d

 

1. 定義

建造者模式(Builder Pattern):將一個複雜對象的構建與它的表示分離,使得一樣的構建過程能夠建立不一樣的表示。

 

2. 結構

Product:產品角色;

Director:指揮者,利用具體建造者建立產品;

AbstractBuilder:抽象建造者,定義抽象的建造方法;

ConcreteBuilder:具體建造者,實現建造方法;

 

3. 代碼

3.1 Java

Product:

 1 class Product {
 2     private String name;
 3     private int price;
 4 
 5     public void setName(String name_arg) {
 6         name = name_arg;
 7     }
 8 
 9     public void setPrice(int price_arg) {
10         price = price_arg;
11     }
12 
13     public void show() {
14         System.out.println("名字: " + name + ", 價格: " + price);
15     }
16 }

除了兩個屬性的set方法,還定義了一個打印屬性的show方法。

Director:

 1 class Director {
 2     AbstractBuilder builder;
 3 
 4     public void setBuilder(AbstractBuilder builder_arg) {
 5         builder = builder_arg;
 6     }
 7 
 8     public Product construct() {
 9         builder.buildName();
10         builder.buildPrice();
11 
12         return builder.getProduct();
13     }
14 }

經過設置的建造者,建立產品實例並返回。

AbstractBuilder:

1 abstract class AbstractBuilder {
2     abstract public void buildName();
3     abstract public void buildPrice();
4     abstract public Product getProduct();
5 }

定義了三個抽象方法,用於設置產品屬性及獲取實例。

ConcreteBuilder1與ConcreteBuilder2:

 1 class ConcreteBuilder1 extends AbstractBuilder {
 2     private Product product;
 3 
 4     public ConcreteBuilder1() {
 5         product = new Product();
 6     }
 7 
 8     public void buildName() {
 9         product.setName("套餐1");
10     }
11 
12     public void buildPrice() {
13         product.setPrice(1);
14     }
15 
16     public Product getProduct() {
17         return product;
18     }
19 }
 1 class ConcreteBuilder2 extends AbstractBuilder {
 2     private Product product;
 3 
 4     public ConcreteBuilder2() {
 5         product = new Product();
 6     }
 7 
 8     public void buildName() {
 9         product.setName("套餐2");
10     }
11 
12     public void buildPrice() {
13         product.setPrice(2);
14     }
15 
16     public Product getProduct() {
17         return product;
18     }
19 }

具體建造者,實現產品的建立。

測試代碼:

 1 public class BuilderPattern {
 2     public static void main(String[] args) {
 3         System.out.println("Builder Pattern");
 4 
 5         Product product;
 6 
 7         Director director = new Director();
 8 
 9         AbstractBuilder builder1 = new ConcreteBuilder1();
10         director.setBuilder(builder1);
11         product = director.construct();
12         product.show();
13 
14         AbstractBuilder builder2 = new ConcreteBuilder2();
15         director.setBuilder(builder2);
16         product = director.construct();
17         product.show();
18     }
19 }

輸出:

 

 

3.2 Kotlin

Product:

 1 class Product {
 2     private var name: String? = null
 3     private var price: Int = 0
 4 
 5     fun setName(name_arg : String) {
 6         name = name_arg
 7     }
 8 
 9     fun setPrice(price_arg : Int) {
10         price = price_arg
11     }
12 
13     fun show() {
14         println("名字: $name, 價格: $price")
15     }
16 }

Director:

 1 class Director {
 2     private var builder: AbstractBuilder? = null
 3 
 4     fun setBuilder(builder_arg: AbstractBuilder) {
 5         builder = builder_arg
 6     }
 7 
 8     fun construct(): Product {
 9         builder?.buildName()
10         builder?.buildPrice()
11 
12         return builder!!.getProduct()
13     }
14 }

AbstractBuilder:

1 abstract class AbstractBuilder {
2     abstract fun buildName()
3     abstract fun buildPrice()
4     abstract fun getProduct(): Product
5 }

ConcreteBuilder1與ConcreteBuilder2:

 1 class ConcreteBuilder1 : AbstractBuilder() {
 2     private val product: Product
 3 
 4     init {
 5         product = Product()
 6     }
 7 
 8     override fun buildName() {
 9         product.setName("套餐1")
10     }
11 
12     override fun buildPrice() {
13         product.setPrice(1)
14     }
15 
16     override fun getProduct(): Product {
17         return product
18     }
19 }
 1 class ConcreteBuilder2 : AbstractBuilder() {
 2     private val product: Product
 3 
 4     init {
 5         product = Product()
 6     }
 7 
 8     override fun buildName() {
 9         product.setName("套餐2")
10     }
11 
12     override fun buildPrice() {
13         product.setPrice(2)
14     }
15 
16     override fun getProduct(): Product {
17         return product
18     }
19 }

測試代碼:

 1 fun main(array: Array<String>) {
 2     println("Builder Pattern")
 3 
 4     var product: Product? = null
 5 
 6     val director = Director()
 7 
 8     val builder1 = ConcreteBuilder1()
 9     director.setBuilder(builder1)
10     product = director.construct()
11     product.show()
12 
13     val builder2 = ConcreteBuilder2()
14     director.setBuilder(builder2)
15     product = director.construct()
16     product.show()
17 }

輸出同上。

 

4. 優缺點

4.1 優勢

在建造者模式中,客戶端沒必要知道產品內部組成的細節,將產品自己與產品的建立過程解耦,使得相同的建立過程能夠建立不一樣的產品對象;

每個具體建造者都相對獨立,而與其餘的具體建造者無關,所以能夠很方便地替換具體建造者或增長新的具體建造者,用戶使用不一樣的具體建造者便可獲得不一樣的產品對象;

能夠更加精細地控制產品的建立過程。將複雜產品的建立步驟分解在不一樣的方法中,使得建立過程更加清晰,也更方便使用程序來控制建立過程;

增長新的具體建造者無須修改原有類庫的代碼,指揮者類針對抽象建造者類編程,系統擴展方便,符合「開閉原則」。

 

4.2 缺點

建造者模式所建立的產品通常具備較多的共同點,其組成部分類似,若是產品之間的差別性很大,則不適合使用建造者模式,所以其使用範圍受到必定的限制;

若是產品的內部變化複雜,可能會致使須要定義不少具體建造者類來實現這種變化,致使系統變得很龐大。

 

5. 適用場景

須要生成的產品對象有複雜的內部結構,這些產品對象一般包含多個成員屬性;

須要生成的產品對象的屬性相互依賴,須要指定其生成順序;

對象的建立過程獨立於建立該對象的類。在建造者模式中引入了指揮者類,將建立過程封裝在指揮者類中,而不在建造者類中;

隔離複雜對象的建立和使用,並使得相同的建立過程能夠建立不一樣的產品。

相關文章
相關標籤/搜索