前文推送html
設計模式編程
Kotlin基礎知識測試
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. 適用場景
須要生成的產品對象有複雜的內部結構,這些產品對象一般包含多個成員屬性;
須要生成的產品對象的屬性相互依賴,須要指定其生成順序;
對象的建立過程獨立於建立該對象的類。在建造者模式中引入了指揮者類,將建立過程封裝在指揮者類中,而不在建造者類中;
隔離複雜對象的建立和使用,並使得相同的建立過程能夠建立不一樣的產品。