建造者模式(Java与Kotlin版)

前文推送

设计模式

简单工厂模式(Java与Kotlin版)

工厂方法模式(Java与Kotlin版)

抽象工厂模式(Java与Kotlin版)

Kotlin基础知识

Kotlin入门第一课:从对比Java开始

Kotlin入门第二课:集合操作

Kotlin入门第三课:数据类型

初次尝试用Kotlin实现Android项目

1. 定义

建造者模式(Builder Pattern):将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

2. 结构

Product:产品角色;

Director:指挥者,利用具体建造者创建产品;

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

ConcreteBuilder:具体建造者,实现建造方法;

3. 代码

3.1 Java

Product:

 class Product {
     private String name;
     private int price;

     public void setName(String name_arg) {
         name = name_arg;
     }

     public void setPrice(int price_arg) {
         price = price_arg;
     }

     public void show() {
         System.out.println("名字: " + name + ", 价格: " + price);
     }
 }

除了两个属性的set方法,还定义了一个打印属性的show方法。

Director:

 class Director {
     AbstractBuilder builder;

     public void setBuilder(AbstractBuilder builder_arg) {
         builder = builder_arg;
     }

     public Product construct() {
         builder.buildName();
         builder.buildPrice();

         return builder.getProduct();
     }
 }

通过设置的建造者,创建产品实例并返回。

AbstractBuilder:

 abstract class AbstractBuilder {
     abstract public void buildName();
     abstract public void buildPrice();
     abstract public Product getProduct();
 }

定义了三个抽象方法,用于设置产品属性及获取实例。

ConcreteBuilder1与ConcreteBuilder2:

 class ConcreteBuilder1 extends AbstractBuilder {
     private Product product;

     public ConcreteBuilder1() {
         product = new Product();
     }

     public void buildName() {
         product.setName("套餐1");
     }

     public void buildPrice() {
         product.setPrice();
     }

     public Product getProduct() {
         return product;
     }
 }
 class ConcreteBuilder2 extends AbstractBuilder {
     private Product product;

     public ConcreteBuilder2() {
         product = new Product();
     }

     public void buildName() {
         product.setName("套餐2");
     }

     public void buildPrice() {
         product.setPrice();
     }

     public Product getProduct() {
         return product;
     }
 }

具体建造者,实现产品的创建。

输出:

建造者模式(Java与Kotlin版)

3.2 Kotlin

Product:

 class Product {
     private var name: String? = null

     fun setName(name_arg : String) {
         name = name_arg
     }

     fun setPrice(price_arg : Int) {
         price = price_arg
     }

     fun show() {
         println("名字: $name, 价格: $price")
     }
 }

Director:

 class Director {
     private var builder: AbstractBuilder? = null

     fun setBuilder(builder_arg: AbstractBuilder) {
         builder = builder_arg
     }

     fun construct(): Product {
         builder?.buildName()
         builder?.buildPrice()

         return builder!!.getProduct()
     }
 }

AbstractBuilder:

 abstract class AbstractBuilder {
     abstract fun buildName()
     abstract fun buildPrice()
     abstract fun getProduct(): Product
 }

ConcreteBuilder1与ConcreteBuilder2:

 class ConcreteBuilder1 : AbstractBuilder() {
     private val product: Product

     init {
         product = Product()
     }

     override fun buildName() {
         product.setName("套餐1")
     }

     override fun buildPrice() {
         product.setPrice()
     }

     override fun getProduct(): Product {
         return product
     }
 }
 class ConcreteBuilder2 : AbstractBuilder() {
     private val product: Product

     init {
         product = Product()
     }

     override fun buildName() {
         product.setName("套餐2")
     }

     override fun buildPrice() {
         product.setPrice()
     }

     override fun getProduct(): Product {
         return product
     }
 }

输出同上。

4. 优缺点

4.1 优点

在建造者模式中, 客户端不必知道产品内部组成的细节,将产品本身与产品的创建过程解耦,使得相同的创建过程可以创建不同的产品对象;

每一个具体建造者都相对独立,而与其他的具体建造者无关,因此可以很方便地替换具体建造者或增加新的具体建造者, 用户使用不同的具体建造者即可得到不同的产品对象 ;

可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中,使得创建过程更加清晰,也更方便使用程序来控制创建过程;

增加新的具体建造者无须修改原有类库的代码,指挥者类针对抽象建造者类编程,系统扩展方便,符合“开闭原则”。

4.2 缺点

建造者模式所创建的产品一般具有较多的共同点,其组成部分相似,如果产品之间的差异性很大,则不适合使用建造者模式,因此其使用范围受到一定的限制;

如果产品的内部变化复杂,可能会导致需要定义很多具体建造者类来实现这种变化,导致系统变得很庞大。

5. 适用场景

需要生成的产品对象有复杂的内部结构,这些产品对象通常包含多个成员属性;

需要生成的产品对象的属性相互依赖,需要指定其生成顺序;

对象的创建过程独立于创建该对象的类。在建造者模式中引入了指挥者类,将创建过程封装在指挥者类中,而不在建造者类中;

隔离复杂对象的创建和使用,并使得相同的创建过程可以创建不同的产品。

上一篇:C++ dynamic_cast实现原理


下一篇:python文件操作及os模块常用命令