Kotlin教程笔记(51) - 改良设计模式 - 构建者模式

简介: 本教程详细讲解Kotlin语法,适合希望深入了解Kotlin的开发者。对于快速学习Kotlin语法,推荐查看“简洁”系列教程。本文重点介绍了构建者模式在Kotlin中的应用与改良,包括如何使用具名可选参数简化复杂对象的创建过程,以及如何在初始化代码块中对参数进行约束和校验。

本系列学习教程笔记属于详细讲解Kotlin语法的教程,需要快速学习Kotlin语法的小伙伴可以查看“简洁” 系列的教程

快速入门请阅读如下简洁教程:
Kotlin学习教程(一)
Kotlin学习教程(二)
Kotlin学习教程(三)
Kotlin学习教程(四)
Kotlin学习教程(五)
Kotlin学习教程(六)
Kotlin学习教程(七)
Kotlin学习教程(八)
Kotlin学习教程(九)
Kotlin学习教程(十)

Kotlin教程笔记(51) - 改良设计模式 - 构建者模式

imgKotlin - 改良设计模式 - 构建者模式

一、前言

构建者模式
作用:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。
核心操作:私有化复杂对象(Product)的类构造器,设计并创建 Builder 类。

二、使用构建者模式

例子:组装电脑
重点:多构造器、构建者模式
应用开发过程中,总会遇到创建复杂对象(Product)的情况,以组装电脑为例,从硬件到软件,需要配置的参数非常多,即构造器需要传入 n 个参数,于是我们可能会写出如下代码:

/**

  • 电脑类
    *
  • @author GitLqr
    */
    class Computer(
    val mainboard: String, // 主板
    val cpu: String, // 处理器
    val ram: String, // 内存
    val battery: String, // 电源
    val gpu: String?, // 显卡
    val hardDisk: String?, // 硬盘
    val networkInterface: String?, // 网线接口
    val cdDriver: String?, // 光驱
    val os: String?, // 系统
    val chassis: String?, // 机箱
    val mouse: String?, // 鼠标
    val keyboard: String?, // 键盘
    val monitor: String? // 显示器
    )

// 使用
val nbComputer = Computer(
"超微X8QB6-F", "Intel Xeon E7-8870", "海盗船(CORSAIR) 复仇者LPX DDR4 2133 64GB 7000",
"西门子豪华供电柜", "Leadtek/丽台Quadro Plex 7000", "WD_BLACK SN850 2T",
"Intel/英特尔 万兆光纤网卡 EXPX9501AFXLR", "ThinkPad 43N3215 Blu-ray Burner Ultrabay",
"Windows 11", "游戏悍将太极施洛华世奇", "RAPOO雷柏 3710 2.4G激光无线鼠标",
"Optimus Maximus 多功能 概念式键盘", "Sharp/夏普 LB-1085 108英寸 FULL HD专业液晶显示器"
)
但是并不是所有的参数都是必须的,在 Java 中,我们一般会通过 重载构造器 来减少对象创建时需要传入的参数个数,在 Kotlin 中,重载构造器 就是定义次级构造器:

/**

  • 电脑类(重载构造器)
    *
  • @author GitLqr
    */
    class Computer(
    val mainboard: String, // 主板
    val cpu: String, // 处理器
    val ram: String, // 内存
    val battery: String, // 电源
    val gpu: String?, // 显卡
    val hardDisk: String?, // 硬盘
    val networkInterface: String?, // 网线接口
    val cdDriver: String?, // 光驱
    val os: String?, // 系统
    val chassis: String?, // 机箱
    val mouse: String?, // 鼠标
    val keyboard: String?, // 键盘
    val monitor: String? // 显示器
    ) {
    // 次构造器需要调用主构造器传参
    constructor(mainboard: String, cpu: String, ram: String, battery: String) :
         this(mainboard, cpu, ram, battery, null, null, null, null, null, null, null, null, null)
    
    }

// 使用
val simpleComputer = Computer("超微X8QB6-F", "Intel Xeon E7-8870", "海盗船(CORSAIR) 复仇者LPX DDR4 2133 64GB 7000", "西门子豪华供电柜")
但是 重载构造器 这种方案并不好,一旦重载的多了,代码就会变得很难维护,于是,在 Java 中,对于创建复杂对象这种情景,一般会使用 构建者模式 来处理,在使用 构建者模式 时需要遵循以下几点套路:

Product:私有化复杂对象的类构造器(确保使用者无法直接通过构造器创建实例)
Builder:
必传参数 通过 构造器 传入
可选参数 通过一系列 Setter 传入
提供一个 build() 方法返回一个 Product 对象
下面我们就用 构建者模式 来改造上面的代码:

/**

  • 电脑类(构建者模式)
    *
  • @author GitLqr
    */
    class Computer private constructor( // 私有化复杂对象的类构造器
    val mainboard: String, // 主板
    val cpu: String, // 处理器
    val ram: String, // 内存
    val battery: String, // 电源
    val gpu: String?, // 显卡
    val hardDisk: String?, // 硬盘
    val networkInterface: String? // 网线接口
    ...
    ) {
    // 【必传参数】通过 构造器 传入
    class Builder(val mainboard: String, val cpu: String, val ram: String, val battery: String) {

     var gpu: String? = null
     var hardDisk: String? = null
     var networkInterface: String? = null
     ...
    
     fun setGpu(gpu: String): Builder {
         this.gpu = gpu
         return this
     }
    
     fun setHardDisk(hardDisk: String): Builder {
         this.hardDisk = hardDisk
         return this
     }
    
     fun setNetworkInterface(networkInterface: String): Builder {
         this.networkInterface = networkInterface
         return this
     }
    
     ...
    
     // 别忘了,还要有一个 build() 方法,用来创建复杂对象并返回
     fun build(): Computer {
         return Computer(mainboard, cpu, ram, battery, gpu, hardDisk, networkInterface, ...)
     }
    

    }
    }

// 使用
val computer =
Computer.Builder("超微X8QB6-F", "Intel Xeon E7-8870", "海盗船(CORSAIR) 复仇者LPX DDR4 2133 64GB 7000", "西门子豪华供电柜")
.setGpu("Leadtek/丽台Quadro Plex 7000")
.setHardDisk("WD_BLACK SN850 2T")
.setNetworkInterface("Intel/英特尔 万兆光纤网卡 EXPX9501AFXLR")
.build()
总结一下 构建者模式 的优缺点:

优点:
结合 链式调用 设计,代码上更加美观
对于可选参数的设置,更加语义化
缺点:
当可选参数比较多时,Builder 代码比较冗长
在使用 Builder 时可能会忘记 build() 方法的调用
在创建 Product 对象之前,必须先创建 Builder 对象,会增加额外的开销

三、改良构建者模式

例子:组装电脑
重点:构建者模式本质上是模拟了具名的可选参数
Kotlin 作为更好的 Java,拥有更多现代语言的特性,具名可选参数 就是众多特性之一,我们完全可以使用这个特性来改良(或者说是取代)构建者模式。

Kotlin 的 具名可选参数 有以下特点:

在具体化一个参数的取值时,可以通过带上它的参数名,而不是它在所有参数中的位置决定
由于参数可以设置默认值,这允许我们可以只给出部分参数的取值,而不必是所有的参数
下面我们用 Kotlin 的 具名可选参数 来改造上面的代码:

/**

  • 电脑类(构建者模式)改良:带默认值的具名可选参数
    *
  • @author GitLqr
    */
    class Computer(
    val mainboard: String, // 主板
    val cpu: String, // 处理器
    val ram: String, // 内存
    val battery: String, // 电源
    val gpu: String? = null, // 显卡
    val hardDisk: String? = null, // 硬盘
    val networkInterface: String? = null, // 网线接口
    val cdDriver: String? = null, // 光驱
    val os: String? = null, // 系统
    val chassis: String? = null, // 机箱
    val mouse: String? = null, // 鼠标
    val keyboard: String? = null, // 键盘
    val monitor: String? = null // 显示器
    )

// 使用
val computer = Computer(
"超微X8QB6-F", "Intel Xeon E7-8870", "海盗船(CORSAIR) 复仇者LPX DDR4 2133 64GB 7000", "西门子豪华供电柜",
gpu = "Leadtek/丽台Quadro Plex 7000",
os = "Windows 11",
mouse = "RAPOO雷柏 3710 2.4G激光无线鼠标",
keyboard = "Optimus Maximus 多功能 概念式键盘",
monitor = "Sharp/夏普 LB-1085 108英寸 FULL HD专业液晶显示器"
)
总结一下 具名可选参数 的优点:

代码简洁优雅,无论是 Product 的类结构,或者是创建一个 Product 实例
创建 Product 实例时,显式指定参数名即可,无须按顺序传入
所有参数均使用 val 声明,相比 Builder 中使用 var 更加安全

四、对参数进行约束

构建者模式还有另一个作用,就是在 build() 方法中可以对参数进行约束,比如,如果一台电脑有指定操作系统(os),可是它没有硬盘(hardDisk),这显然是不对的,若使用构建者模式,则可以在 build() 方法中做如下条件约束:

/**

  • 构建者模式:在 build() 方法中对参数进行约束、校验
    *
  • @author GitLqr
    */
    class Computer private constructor( ... ) {
    class Builder( ... ) {
     ...
     fun build(): Computer {
         if (os != null && hardDisk == null) {
             throw IllegalArgumentException("没有硬盘安装不了操作系统")
         }
         return Computer(...)
     }
    
    }
    }
    那么改用 具名可选参数 这种方案之后,如果需要给参数添加约束条件时该怎么办呢?可以在 init 代码块中进行约束条件判断,这时顺便介绍一下 Kotlin 提供的 require() 方法,相当于是 Java 中的 assert:

/**

  • 具名可选参数:在 init{} 代码块中对参数进行约束、校验
    *
  • @author GitLqr
    */
    class Computer(
    val mainboard: String, // 主板
    val cpu: String, // 处理器
    val ram: String, // 内存
    val battery: String, // 电源
    val gpu: String? = null, // 显卡
    val hardDisk: String? = null, // 硬盘
    val networkInterface: String? = null, // 网线接口
    val cdDriver: String? = null, // 光驱
    val os: String? = null, // 系统
    val chassis: String? = null, // 机箱
    val mouse: String? = null, // 鼠标
    val keyboard: String? = null, // 键盘
    val monitor: String? = null // 显示器
    ) {
    init {

     // if (os != null && hardDisk == null) {
     //     throw IllegalArgumentException("没有硬盘安装不了操作系统")
     // }
    
     require(!(os != null && hardDisk == null)) {
         "没有硬盘安装不了操作系统"
     }
    

    }
    }
    所以,综上所述,在 Kotlin 中,大可不必使用构建者模式~

《Effective Java》中是这样介绍构建者模式的:本质上 builder 模式模拟了具名的可选参数,就像 Ada 和 Python 中的一样。

相关实践学习
部署Stable Diffusion玩转AI绘画(GPU云服务器)
本实验通过在ECS上从零开始部署Stable Diffusion来进行AI绘画创作,开启AIGC盲盒。
相关文章
|
3天前
|
人工智能 Scala Kotlin
Kotlin教程笔记(8) - 运算符与中缀表达式
Kotlin教程笔记(8) - 运算符与中缀表达式
|
4天前
|
设计模式 Java Kotlin
Kotlin教程笔记(54) - 改良设计模式 - 迭代器模式
Kotlin教程笔记(54) - 改良设计模式 - 迭代器模式
19 2
|
4天前
|
设计模式 算法 Kotlin
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
21 1
|
4天前
|
设计模式 安全 Java
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
Kotlin教程笔记(57) - 改良设计模式 - 单例模式
|
4天前
|
设计模式 JavaScript Scala
Kotlin教程笔记(55) - 改良设计模式 - 责任链模式
Kotlin教程笔记(55) - 改良设计模式 - 责任链模式
18 0
|
2月前
|
JSON 调度 数据库
Android面试之5个Kotlin深度面试题:协程、密封类和高阶函数
本文首发于公众号“AntDream”,欢迎微信搜索“AntDream”或扫描文章底部二维码关注,和我一起每天进步一点点。文章详细解析了Kotlin中的协程、扩展函数、高阶函数、密封类及`inline`和`reified`关键字在Android开发中的应用,帮助读者更好地理解和使用这些特性。
26 1
|
3月前
|
Android开发 开发者 Kotlin
告别AsyncTask:一招教你用Kotlin协程重构Android应用,流畅度飙升的秘密武器
【9月更文挑战第13天】随着Android应用复杂度的增加,有效管理异步任务成为关键。Kotlin协程提供了一种优雅的并发操作处理方式,使异步编程更简单直观。本文通过具体示例介绍如何使用Kotlin协程优化Android应用性能,包括网络数据加载和UI更新。首先需在`build.gradle`中添加coroutines依赖。接着,通过定义挂起函数执行网络请求,并在`ViewModel`中使用`viewModelScope`启动协程,结合`Dispatchers.Main`更新UI,避免内存泄漏。使用协程不仅简化代码,还提升了程序健壮性。
86 1
|
4月前
|
调度 Android开发 开发者
【颠覆传统!】Kotlin协程魔法:解锁Android应用极速体验,带你领略多线程优化的无限魅力!
【8月更文挑战第12天】多线程对现代Android应用至关重要,能显著提升性能与体验。本文探讨Kotlin中的高效多线程实践。首先,理解主线程(UI线程)的角色,避免阻塞它。Kotlin协程作为轻量级线程,简化异步编程。示例展示了如何使用`kotlinx.coroutines`库创建协程,执行后台任务而不影响UI。此外,通过协程与Retrofit结合,实现了网络数据的异步加载,并安全地更新UI。协程不仅提高代码可读性,还能确保程序高效运行,不阻塞主线程,是构建高性能Android应用的关键。
62 4
|
5月前
|
安全 Android开发 Kotlin
Android经典面试题之Kotlin延迟初始化的by lazy和lateinit有什么区别?
**Kotlin中的`by lazy`和`lateinit`都是延迟初始化技术。`by lazy`用于只读属性,线程安全,首次访问时初始化;`lateinit`用于可变属性,需手动初始化,非线程安全。`by lazy`支持线程安全模式选择,而`lateinit`适用于构造函数后初始化。选择依赖于属性特性和使用场景。**
156 5
Android经典面试题之Kotlin延迟初始化的by lazy和lateinit有什么区别?
|
5月前
|
安全 Android开发 Kotlin
Android经典面试题之Kotlin中常见作用域函数
**Kotlin作用域函数概览**: `let`, `run`, `with`, `apply`, `also`. `let`安全调用并返回结果; `run`在上下文中执行代码并返回结果; `with`执行代码块,返回结果; `apply`配置对象后返回自身; `also`附加操作后返回自身
62 8