标签：创建过程 erp slist 抽象 客户端 kotlin tle 项目 入门
前文推送
设计模式
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. 适用场景
需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性；
需要生成的产品对象的属性相互依赖，需要指定其生成顺序；
对象的创建过程独立于创建该对象的类。在建造者模式中引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类中；
隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。
标签：创建过程 erp slist 抽象 客户端 kotlin tle 项目 入门
原文地址：http://www.cnblogs.com/tgyf/p/7172956.html
