Kotlin基础——优化设计模式

设计模式

使用Kotlin优化Java的设计模式写法

创建型模式

工厂方法模式

interface Computer {val cpu: String
}class PC(override val cpu: String = "Core") : Computer
class Server(override val cpu: String = "Xeon") : Computerenum class ComputerType {PC, Server
}class ComputerFactory {fun produce(type: ComputerType): Computer {return when (type) {ComputerType.PC -> PC()ComputerType.Server -> Server()}}
}

普通的工厂模式如上，调用时需要创建实例

val computer = ComputerFactory().produce(ComputerType.PC)

优化1：使用单例代替工厂类，使用object修饰

object ComputerFactory {fun produce(type: ComputerType): Computer {return when (type) {ComputerType.PC -> PC()ComputerType.Server -> Server()}}
}

这样就能省去创建过程，object会自动创建实例并调用

val computer = ComputerFactory.produce(ComputerType.PC)

优化2：使用operator重载invoke代替工厂方法名称

object ComputerFactory {operator fun invoke(type: ComputerType): Computer {return when (type) {ComputerType.PC -> PC()ComputerType.Server -> Server()}}
}

这样就能进一步省去创建过程，通过类名创建实例并调用

val computer = ComputerFactory(ComputerType.PC)

优化3：使用静态方法代替构造方法，将ComputerFactory移动到Computer接口里面

interface Computer {val cpu: Stringobject Factory {operator fun invoke(type: ComputerType): Computer {return when (type) {ComputerType.PC -> PC()ComputerType.Server -> Server()}}}
}

这样就不是通过创建实例调用，而是通过静态方法调用

val computer = Computer.Factory(ComputerType.PC)

于此同时，如果我们是Computer接口的使用者，我们不必通过继承实现新方法，可以通过扩展函数

fun Computer.Factory.fromCPU(cpu: String): ComputerType? = when (cpu) {"Core" -> ComputerType.PC"Xeon" -> ComputerType.Serverelse -> null
}

抽象工厂模式

interface Computer
class Dell : Computer
class Asus : Computer
class Acer : Computerabstract class AbstractFactory {abstract fun produce(): Computercompanion object {operator fun invoke(factory: AbstractFactory): AbstractFactory {return factory}}
}class DellFactory : AbstractFactory() {override fun produce() = Dell()
}
class AsusFactory : AbstractFactory() {override fun produce() = Asus()
}
class AcerFactory : AbstractFactory() {override fun produce() = Acer()
}

对于如上抽象工厂，调用时

val dellFactory = AbstractFactory(DellFactory())
val dell = dellFactory.produce()

优化1：使用内联函数代替抽象工厂创建过程

interface Computer
class Dell : Computer
class Asus : Computer
class Acer : Computerabstract class AbstractFactory {abstract fun produce(): Computercompanion object {inline operator fun <reified T : Computer> invoke(): AbstractFactory =when (T::class) {Dell::class -> DellFactory()Asus::class -> AsusFactory()Acer::class -> AcerFactory()else -> throw IllegalArgumentException()}}
}class DellFactory : AbstractFactory() {override fun produce() = Dell()
}
class AsusFactory : AbstractFactory() {override fun produce() = Asus()
}
class AcerFactory : AbstractFactory() {override fun produce() = Acer()
}

在使用时，可通过类型参数确认工厂类型类型

 val dellFactory = AbstractFactory<Dell>()val dell = dellFactory.produce()

构建者模式

class Robot private constructor(val code: String,val battery: String?,val height: Int?,val weight: Int?
) {class Builder(val code: String) {private var battery: String? = nullprivate var height: Int? = nullprivate var weight: Int? = nullfun setBattery(battery: String?): Builder {this.battery = batteryreturn this}fun setHeight(height: Int): Builder {this.height = heightreturn this}fun setWeight(weight: Int): Builder {this.weight = weightreturn this}fun build(): Robot {return Robot(code, battery, height, weight)}}
}

对于上面的Robot类存在三个可选属性，通过如下创建

val robot = Robot.Builder("001").setBattery("A").setHeight(100).setWeight(80).build()

优化1：通过默认参数代替可选参数

class Robot(val code: String,val battery: String? = null,val height: Int? = null,val weight: Int? = null
)

在创建时可省略后面的可选参数或者指定某个可选参数

val robot1 = Robot("001")
val robot2 = Robot("001", battery = "A")
val robot3 = Robot("001", height = 100, weight = 80)

若builder中对参数有约束调节，如机器人的重量需要根据电池决定，未传入就会抛出错误

fun build(): Robot {if (weight != null && battery == null) {throw IllegalArgumentException("When setting weight, the battery cannot be empty")}else{return Robot(code, battery, height, weight)}
}

可以同样在init中增加约束，其通过require实现（未达到条件则抛出异常，判断条件和上面相反）

class Robot(val code: String,val battery: String? = null,val height: Int? = null,val weight: Int? = null
) {init {require(weight == null || battery != null) {"When setting weight, the battery cannot be empty"}}
}

行为型模式

观察者模式

class StockUpdate : Observable() {val observers = mutableSetOf<Observer>()fun setStockChanged(price: Int) {observers.forEach {it.update(this, price)}}
}
class StockDisplay : Observer {override fun update(o: Observable?, price: Any?) {if (o is StockUpdate) {println("The lastest stock price is ${price}")}}}

上面是Java标准库里面自带的观察者模式，调用如下

val su = StockUpdate()
val sd = StockDisplay()
su.observers.add(sd)
su.setStockChanged(100)

Observer 只有一个update方法，若有多个业务，则需要进行区分

优化1：通过委托代替观察者，参数为元数据KProperty、旧值、新值

interface StockUpdateListener {fun onRise(price: Int)fun onFall(price: Int)
}class StockDisplay : StockUpdateListener {override fun onRise(price: Int) {println("The lastest stock price has rise to ${price}")}override fun onFall(price: Int) {println("The lastest stock price has fall to ${price}")}
}class StockUpdate {var listeners = mutableListOf<StockUpdateListener>()var price: Int by Delegates.observable(0) { _, old, new ->listeners.forEach {if (new > old) it.onRise(price) else it.onFall(price)}}
}

当值发送改变会自动通知到观察者

val su = StockUpdate()
val sd = StockDisplay()
su.listeners.add(sd)
su.price = 100
su.price = 98

优化2：使用Vecoable对新值进行截获，初始值为0，只有正数时才能修改

var value: Int by Delegates.vetoable(0) { property, oldValue, newValue ->newValue > 0
}
value = 1
println(value)
value = -1
println(value)

策略模式

interface SwimStrategy {fun swim()
}
class Breaststroke : SwimStrategy {override fun swim() {println("Breaststroke")}
}
class Backstroke : SwimStrategy {override fun swim() {println("Backstroke")}
}
class Freestyle : SwimStrategy {override fun swim() {println("Freestyle")}
}class Swimmer(val strategy: SwimStrategy) {fun swim() {strategy.swim()}
}

如上对于游泳，有不同的策略，在使用时指定算法

val weekendShaw = Swimmer(Freestyle())
weekendShaw.swim()
val weekdaysShaw = Swimmer(Breaststroke())
weekdaysShaw.swim()

优化1：使用高阶函数代替继承

fun breaststroke() {println("breaststroke")
}
fun backstroke() {println("backstroke")
}
fun freestyle() {println("freestyle")
}
class Swimmer(val swimming: () -> Unit) {fun swim() {swimming()}
}

使用时可通过方法引用，也可使用变量存储Lambda函数传入

val weekendShaw = Swimmer(::freestyle)
weekendShaw.swim()
val weekdaysShaw = Swimmer(::breaststroke)
weekdaysShaw.swim()

模板方法模式

abstract class CivicCenterTask {fun execute() {this.lineUp()this.askForHelp()this.evaluate()}private fun lineUp() {println("line up")}private fun evaluate() {println("evaluate")}abstract fun askForHelp()
}class PullSocialSecurity : CivicCenterTask() {override fun askForHelp() {println("PullSocialSecurity")}
}class ApplyForCitizenCard : CivicCenterTask() {override fun askForHelp() {println("ApplyForCitizenCard")}
}

如上，各个子类有不同的askForHelp()方法，调用时会根据方法实现各自的需求

val pss = PullSocialSecurity()
pss.execute()
val afcc = ApplyForCitizenCard()
afcc.execute()

优化1：使用高阶函数代替继承

class CivicCenterTask {fun execute(askForHelp: () -> Unit) {this.lineUp()askForHelp()this.evaluate()}private fun lineUp() {println("line up")}private fun evaluate() {println("evaluate")}
}
private fun pullSocialSecurity() {println("pullSocialSecurity")
}
private fun applyForCitizenCard() {println("ApplyForCitizenCard")
}

使用时传入方法引用

val task1 = CivicCenterTask()
task1.execute(::pullSocialSecurity)
val task2 = CivicCenterTask()
task1.execute(::applyForCitizenCard)

迭代器模式

通常实现迭代器模式可以通过实现Iterator接口

data class Book(val name: String)class Bookcase(val books: List<Book>) : Iterator<Book> {private val iterator: Iterator<Book>init {this.iterator = books.iterator()}override fun hasNext() = this.iterator.hasNext()override fun next() = this.iterator.next()
}

遍历时

val bookcase = Bookcase(listOf(Book("A"), Book("B"))
)
for (book in bookcase) {println()
}

优化1：通过重载iterator()代替继承

class Bookcase(val books: List<Book>) {operator fun iterator(): Iterator<Book> = this.books.iterator()
}

优化2：通过扩展函数iterator()代替继承，适用于不能修改源码的情况

data class Book(val name: String)
class Bookcase(val books: List<Book>) {
}
operator fun Bookcase.iterator(): Iterator<Book> = this.books.iterator()

还可以通过object表达式来实现

operator fun Bookcase.iterator(): Iterator<Book> = object :Iterator<Book>{val iterator = books.iterator()override fun hasNext() = iterator.hasNext()override fun next() = iterator.next()
}

责任链模式

data class ApplyEvent(val money: Int)interface ApplyHandler {val successor: ApplyHandler?fun handleEvent(event: ApplyEvent)
}class GroupLeader(override val successor: ApplyHandler?) : ApplyHandler {override fun handleEvent(event: ApplyEvent) {when {event.money <= 100 -> println("GroupLeader yes")else -> when (successor) {is ApplyHandler -> successor.handleEvent(event)else -> throw IllegalStateException()}}}
}class President(override val successor: ApplyHandler?) : ApplyHandler {override fun handleEvent(event: ApplyEvent) {when {event.money <= 500 -> println("President yes")else -> when (successor) {is ApplyHandler -> successor.handleEvent(event)else -> throw IllegalStateException()}}}
}class College(override val successor: ApplyHandler?) : ApplyHandler {override fun handleEvent(event: ApplyEvent) {when {event.money <= 1000 -> println("College yes")else -> throw IllegalStateException()}}
}

上面是常见的责任链模式，通过判断传递事件

val college = College(null)
val president = President(college)
val groupLeader = GroupLeader(president)
groupLeader.handleEvent(ApplyEvent(10))
groupLeader.handleEvent(ApplyEvent(200))

优化1：通过偏函数简化责任链，定义如下，defineAt()和isDefinedAt()判断是否符合条件，f()处理事件，orElse()传递责任链

class PartialFunction<in P1, out R>(private val defineAt: (P1) -> Boolean,private val f: (P1) -> R
) {operator fun invoke(p1: P1): R {if (defineAt(p1)) {return f(p1)} else {throw  IllegalArgumentException()}}fun isDefinedAt(p1: P1) = defineAt(p1)
}infix fun <P1, R> PartialFunction<P1, R>.orElse(that: PartialFunction<P1, R>): PartialFunction<P1, R> {return PartialFunction({ this.isDefinedAt(it) || that.isDefinedAt(it) }) {when {this.isDefinedAt(it) -> this(it)else -> that(it)}}
}

责任链定义如下，每一个责任链都是PartialFunction，传入判断条件和处理过程

data class ApplyEvent(val money: Int)val groupLeader = {val defineAt: (ApplyEvent) -> Boolean = { it.money <= 100 }val handler: (ApplyEvent) -> Unit = { println("groupLeader yes") }PartialFunction(defineAt, handler)
}()val president = {val defineAt: (ApplyEvent) -> Boolean = { it.money <= 500 }val handler: (ApplyEvent) -> Unit = { println("president yes") }PartialFunction(defineAt, handler)
}()val college = {val defineAt: (ApplyEvent) -> Boolean = { true }val handler: (ApplyEvent) -> Unit = {when {it.money < 1000 -> println("college yes")else -> println("college no")}}PartialFunction(defineAt, handler)
}()

调用过程如下，通过orElse()传递责任链

val applyChain = groupLeader orElse president orElse college
applyChain(ApplyEvent(600))

状态模式

优化1：采用密封类来约束状态

结构型模式

装饰器模式

优化1：使用委托简化装饰过程

interface MacBook {fun getCost(): Intfun getDesc(): Stringfun getProdDate(): String
}class MacBookPro : MacBook {override fun getCost() = 10000override fun getDesc() = "MacBookPro"override fun getProdDate() = "2022"
}class ProcessorUpgradeMacbookPro(val macBook: MacBook) : MacBook by macBook {override fun getCost() = macBook.getCost() + 2000override fun getDesc() = macBook.getDesc() + ",+1G Memory"
}

如上，ProcessorUpgradeMacbookPro只需要复写需要的方法，其他方法调用时会自动委托给macBook变量

val macbookPro = MacBookPro()
val processorUpgradeMacbookPro = ProcessorUpgradeMacbookPro(macbookPro)
println(processorUpgradeMacbookPro.getCost())
println(processorUpgradeMacbookPro.getDesc())

优化2：通过扩展代替装饰者

class Printer{fun drawLine(){println("————————————")}fun drawDottedLine(){println("------------")}fun drawStars(){println("************")}
}

如对上面的类，利用扩展函数装饰方法，调用前后输出字符串

fun Printer.startDraw(decorated: Printer.() -> Unit){println("start drawing")decorated()println("end drawing")
}

调用过程如下

Printer().run {startDraw { drawLine() }startDraw { drawDottedLine() }startDraw { drawStars() }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/31635.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

B. Maximum Multiple Sum

B. Maximum Multiple Sum

time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output Given an integer n&#x1d45b;, find an integer x&#x1d465; such that: 2≤x≤n2≤&#x1d465;≤&#x1d45b;.The sum of multiples of …
阅读更多...
如何使用Windows备份轻松将数据转移到新电脑？这里有详细步骤

如何使用Windows备份轻松将数据转移到新电脑？这里有详细步骤

序言 我们都知道那种买了一台新电脑，就想直接上手的感觉。我记得在过去的日子里，要花几个小时传输我的文件，并试图复制我的设置。在当今传输数据的众多方法中，Windows备份提供了一个简单可靠的解决方案。 登录到你的Microsoft帐户 Microsoft在传输过程中使用其云存储来保…
阅读更多...
英文字母表

英文字母表

目录 一 设计原型 二 后台源码 一 设计原型 二 后台源码 namespace 英文字母表 {public partial class Form1 : Form{public Form1(){InitializeComponent();}private void Form1_Load(object sender, EventArgs e){foreach (var item in panel1.Controls){if (item ! null)…
阅读更多...
LLAVA数据集下载

LLAVA数据集下载

LLAVA数据集下载 1. Data Data file nameSizellava_instruct_150k.json229 MBllava_instruct_80k.json229 MBconversation_58k.json126 MBdetail_23k.json20.5 MBcomplex_reasoning_77k.json79.6 MB 1.1 Pretraining Dataset The pretraining dataset used in this release…
阅读更多...
A股3000点失守是出局还是机会？

A股3000点失守是出局还是机会？

今天的大A失守300点&#xff0c;那么A股3000点失守是出局还是机会&#xff1f; 1、今天两市低开&#xff0c;盘中一度跌破3000点&#xff0c;最低回踩到了2985点&#xff0c;盘面出现了两个罕见现象&#xff0c;意味着即将探底回升。 2、盘面出现两个罕见现象&#xff1a; 一是…
阅读更多...
buuctf----firmware

buuctf----firmware

- -一定不能再ubutu22进行,我是在18(血泪教训) binwalk安装 buuctf firmware(binwalk和firmware-mod-kit的使用)_buu firmware-CSDN博客 参考博客 指令 sudo apt-get update sudo apt-get install python3-dev python3-setuptools python3-pip zlib1g-dev libmagic-dev pi…
阅读更多...
云计算技术高速发展，优势凸显

云计算技术高速发展，优势凸显

云计算是一种分布式计算技术&#xff0c;其特点是通过网络“云”将巨大的数据计算处理程序分解成无数个小程序&#xff0c;并通过多部服务器组成的系统进行处理和分析这些小程序&#xff0c;最后将结果返回给用户。它融合了分布式计算、效用计算、负载均衡、并行计算、网络存储…
阅读更多...
住宅IP与普通IP的区别

住宅IP与普通IP的区别

在互联网连接中&#xff0c;IP地址是识别每个网络节点的关键。在众多类型的IP地址中&#xff0c;住宅IP和普通IP是两种常见的分类。本文将深入探讨住宅IP与普通IP之间的主要区别。 一、定义与来源 住宅IP指的是由互联网服务提供商&#xff08;ISP&#xff09;直接分配给家庭或…
阅读更多...
竞赛选题 LSTM的预测算法 - 股票预测 天气预测 房价预测

竞赛选题 LSTM的预测算法 - 股票预测 天气预测 房价预测

0 简介 今天学长向大家介绍LSTM基础 基于LSTM的预测算法 - 股票预测 天气预测 房价预测 这是一个较为新颖的竞赛课题方向&#xff0c;学长非常推荐&#xff01; &#x1f9ff; 更多资料, 项目分享&#xff1a; https://gitee.com/dancheng-senior/postgraduate 1 基于 Ke…
阅读更多...
理解 Q_OBJECT 宏在 Qt 中的重要性

理解 Q_OBJECT 宏在 Qt 中的重要性

在开始使用 Qt 框架时&#xff0c;你可能会注意到所有示例类定义的首行都包含宏 Q_OBJECT。那么&#xff0c;这个预处理宏的目的是什么&#xff1f;为什么所有的 Qt 对象都需要这个宏&#xff1f;本文将详细解答这些疑问。 Q_OBJECT 宏的作用 根据 Qt 文档&#xff0c;Q_OBJE…
阅读更多...
k8s部署wordpress及性能优化

k8s部署wordpress及性能优化

镜像版本&#xff1a;wordpress mysql版本&#xff1a;mysql:8.0.27 部署wordpress&#xff1a;v1 此版本包含wordpress基础服务&#xff0c;可访问&#xff0c;但是一旦pod重新创建会丢失数据&#xff0c;文章中的图片等也会丢失&#xff0c;且只又一个pod&#xff0c;性能…
阅读更多...
高通Android 12 aapt报错问题踩坑

高通Android 12 aapt报错问题踩坑

背景 最近因为要做多module模块&#xff0c;出现aapt报错&#xff0c;于是简单记录下&#xff0c;踩坑过程。 1、我一开始项目中三个module&#xff0c;然后在build.gradle设置androidApplication plugins {alias(libs.plugins.androidApplication) }2、运行完之后都是报下面…
阅读更多...
【自动驾驶】什么是高字节？什么是低字节？

【自动驾驶】什么是高字节？什么是低字节？

文章目录 高字节和低字节的定义举例说明如何从传感器数据中组合高字节和低字节代码解析在计算机和电子工程领域，高字节和低字节是指数据字的高位部分和低位部分。一个数据字通常由多个字节组成，例如16位的数据字由2个字节组成。 高字节和低字节的定义 高字节（High Byte）：…
阅读更多...
DevEco鸿蒙开发请求网络交互设置

DevEco鸿蒙开发请求网络交互设置

首先&#xff0c;在鸿蒙项目下config.json中找到module项&#xff0c;在里面填写"reqPermissions": [{"name": "ohos.permission.INTERNET"}] 在页面对应js文件内&#xff0c;填写import fetch from system.fetch;。 GET和POST区别 GET将表单数…
阅读更多...
on ubuntu server install jupyter lab

on ubuntu server install jupyter lab

一、安装jupyter lab conda search jupyterlab 根据base的python版本&#xff0c;选择对应的版本 conda install jupyterlab3.0.14 该方法优点是可以快速的启动JupyterLab&#xff0c;缺点是需要记住大量参数写法。以下是一些常见参数的说明&#xff1a; --ip* 设置可访问的I…
阅读更多...
湖南科技大学24计算机考研情况，软工学硕考数二，分数线290分，录取均分321分！

湖南科技大学24计算机考研情况，软工学硕考数二，分数线290分，录取均分321分！

湖南科技大学&#xff08;Hunan University of Science and Technology&#xff09;坐落在伟人故里、人文圣地湘潭&#xff0c;处于长株潭核心区域&#xff0c;比邻湘潭九华经济技术开发区&#xff08;国家级&#xff09;&#xff0c;是应急管理部、国家国防科技工业局与湖南省…
阅读更多...
DVWA 靶场 Open HTTP Redirect 通关解析

DVWA 靶场 Open HTTP Redirect 通关解析

前言 DVWA代表Damn Vulnerable Web Application&#xff0c;是一个用于学习和练习Web应用程序漏洞的开源漏洞应用程序。它被设计成一个易于安装和配置的漏洞应用程序&#xff0c;旨在帮助安全专业人员和爱好者了解和熟悉不同类型的Web应用程序漏洞。 DVWA提供了一系列的漏洞场…
阅读更多...
拍卖商城开发要点源码及功能分析

拍卖商城开发要点源码及功能分析

要创建一个正规的拍卖商城平台&#xff0c;需要遵循一系列步骤&#xff0c;确保平台的合法性、专业性和用户体验。以下是一个详细的步骤指南&#xff1a; 一、明确平台定位与规划 确定拍卖商城平台的目标市场、用户群体和主要拍卖品类。 制定平台的发展规划和战略目标&#…
阅读更多...
网络爬虫设置代理服务器

网络爬虫设置代理服务器

目录 1&#xff0e;获取代理 IP 2&#xff0e;设置代理 IP 3. 检测代理 IP 的有效性 4. 处理异常 如果希望在网络爬虫程序中使用代理服务器&#xff0c;就需要为网络爬虫程序设置代理服务器。 设置代理服务器一般分为获取代理 IP 、设置代理 IP 两步。接下来&#xff0c;分…
阅读更多...
Python 设计模式(第2版) -- 第四部分（其他设计模式）

Python 设计模式(第2版) -- 第四部分（其他设计模式）

Python 设计模式(第2版) 最后介绍下其他设计模式。 模型—视图—控制器&#xff08;MVC&#xff09;-- 复合模式 根据 GoF 的定义&#xff0c;“复合模式将两个或更多模式组合成解决常见或普遍性问题的解决方案”。复合模式不是同时使用的一组模式&#xff0c;而是一个问题的…
阅读更多...
最新文章

Copyright @ 2022~2023