主要的软件设计模式及其在Kotlin中的实现示例

软件设计模式（software design patterns）是面向对象设计中常用的解决方案，它们为常见的软件设计问题提供了一些被证明有效的解决方案。以下是一些主要的软件设计模式及其在kotlin中的实现示例。

创建型模式（creational patterns）

单例模式（singleton pattern）

确保一个类只有一个实例，并提供全局访问点。

object singleton {
    init {
        println("singleton instance created")
    }

    fun dosomething() {
        println("doing something")
    }
}

// 使用
fun main() {
    singleton.dosomething()
}

工厂模式（factory pattern）

定义一个创建对象的接口，但由子类决定要实例化的类。

interface product {
    fun use()
}

class concreteproducta : product {
    override fun use() {
        println("using product a")
    }
}

class concreteproductb : product {
    override fun use() {
        println("using product b")
    }
}

class productfactory {
    fun createproduct(type: string): product {
        return when (type) {
            "a" -> concreteproducta()
            "b" -> concreteproductb()
            else -> throw illegalargumentexception("unknown product type")
        }
    }
}

// 使用
fun main() {
    val factory = productfactory()
    val producta = factory.createproduct("a")
    producta.use()

    val productb = factory.createproduct("b")
    productb.use()
}

抽象工厂模式（abstract factory pattern）

提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体类。

interface button {
    fun click()
}

class windowsbutton : button {
    override fun click() {
        println("windows button clicked")
    }
}

class macbutton : button {
    override fun click() {
        println("mac button clicked")
    }
}

interface guifactory {
    fun createbutton(): button
}

class windowsfactory : guifactory {
    override fun createbutton(): button {
        return windowsbutton()
    }
}

class macfactory : guifactory {
    override fun createbutton(): button {
        return macbutton()
    }
}

// 使用
fun main() {
    val factory: guifactory = windowsfactory()
    val button = factory.createbutton()
    button.click()
}

建造者模式（builder pattern）

将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

class product private constructor(builder: builder) {
    val parta: string?
    val partb: string?
    val partc: string?

    init {
        parta = builder.parta
        partb = builder.partb
        partc = builder.partc
    }

    class builder {
        var parta: string? = null
            private set
        var partb: string? = null
            private set
        var partc: string? = null
            private set

        fun setparta(parta: string) = apply { this.parta = parta }
        fun setpartb(partb: string) = apply { this.partb = partb }
        fun setpartc(partc: string) = apply { this.partc = partc }

        fun build() = product(this)
    }
}

// 使用
fun main() {
    val product = product.builder()
        .setparta("a")
        .setpartb("b")
        .setpartc("c")
        .build()

    println("product parts: ${product.parta}, ${product.partb}, ${product.partc}")
}

结构型模式（structural patterns）

适配器模式（adapter pattern）

将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以协同工作。

interface target {
    fun request()
}

class adaptee {
    fun specificrequest() {
        println("specific request")
    }
}

class adapter(private val adaptee: adaptee) : target {
    override fun request() {
        adaptee.specificrequest()
    }
}

// 使用
fun main() {
    val adaptee = adaptee()
    val adapter = adapter(adaptee)
    adapter.request()
}

装饰器模式（decorator pattern）

动态地将责任附加到对象上，提供了一种灵活替代继承的方法来扩展功能。

interface component {
    fun operation()
}

class concretecomponent : component {
    override fun operation() {
        println("concrete component operation")
    }
}

open class decorator(private val component: component) : component {
    override fun operation() {
        component.operation()
    }
}

class concretedecorator(component: component) : decorator(component) {
    override fun operation() {
        super.operation()
        addedbehavior()
    }

    private fun addedbehavior() {
        println("added behavior")
    }
}

// 使用
fun main() {
    val component: component = concretedecorator(concretecomponent())
    component.operation()
}

代理模式（proxy pattern）

为另一个对象提供一个代理以控制对这个对象的访问。

interface subject {
    fun request()
}

class realsubject : subject {
    override fun request() {
        println("realsubject request")
    }
}

class proxy(private val realsubject: realsubject) : subject {
    override fun request() {
        println("proxy request")
        realsubject.request()
    }
}

// 使用
fun main() {
    val realsubject = realsubject()
    val proxy = proxy(realsubject)
    proxy.request()
}

外观模式（facade pattern）

为子系统中的一组接口提供一个一致的界面，使得子系统更容易使用。

class subsystema {
    fun operationa() {
        println("subsystem a operation")
    }
}

class subsystemb {
    fun operationb() {
        println("subsystem b operation")
    }
}

class facade {
    private val subsystema = subsystema()
    private val subsystemb = subsystemb()

    fun operation() {
        subsystema.operationa()
        subsystemb.operationb()
    }
}

// 使用
fun main() {
    val facade = facade()
    facade.operation()
}

行为型模式（behavioral patterns）

策略模式（strategy pattern）

定义一系列算法，把它们一个个封装起来，并且使它们可以相互替换。

interface strategy {
    fun execute()
}

class concretestrategya : strategy {
    override fun execute() {
        println("executing strategy a")
    }
}

class concretestrategyb : strategy {
    override fun execute() {
        println("executing strategy b")
    }
}

class context(private var strategy: strategy) {
    fun setstrategy(strategy: strategy) {
        this.strategy = strategy
    }

    fun executestrategy() {
        strategy.execute()
    }
}

// 使用
fun main() {
    val context = context(concretestrategya())
    context.executestrategy()

    context.setstrategy(concretestrategyb())
    context.executestrategy()
}

观察者模式（observer pattern）

定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。

interface observer {
    fun update()
}

class concreteobserver : observer {
    override fun update() {
        println("observer updated")
    }
}

class subject {
    private val observers = mutablelistof<observer>()

    fun addobserver(observer: observer) {
        observers.add(observer)
    }

    fun removeobserver(observer: observer) {
        observers.remove(observer)
    }

    fun notifyobservers() {
        for (observer in observers) {
            observer.update()
        }
    }
}

// 使用
fun main() {
    val subject = subject()
    val observer = concreteobserver()

    subject.addobserver(observer)
    subject.notifyobservers()

    subject.removeobserver(observer)
    subject.notifyobservers()
}

命令模式（command pattern）

将请求封装成对象，从而使得您可以用不同的请求对客户进行参数化。

interface command {
    fun execute()
}

class concretecommand(private val receiver: receiver) : command {
    override fun execute() {
        receiver.action()
    }
}

class receiver {
    fun action() {
        println("receiver action")
    }
}

class invoker {
    private lateinit var command: command

    fun setcommand(command: command) {
        this.command = command
    }

    fun executecommand() {
        command.execute()
    }
}

// 使用
fun main() {
    val receiver = receiver()
    val command = concretecommand(receiver)
    val invoker = invoker()

    invoker.setcommand(command)
    invoker.executecommand()
}

责任链模式（chain of responsibility pattern）

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合。

abstract class handler {
    var nexthandler: handler? = null

    fun handlerequest(request: string) {
        if (canhandle(request)) {
            process(request)
        } else {
            nexthandler?.handlerequest(request)
        }
    }

    protected abstract fun canhandle(request: string): boolean
    protected abstract fun process(request: string)
}

class concretehandlera : handler() {
    override fun canhandle(request: string) = request == "a"
    override fun process(request: string) {
        println("handler a processed $request")
    }
}

class concretehandlerb : handler()

 {
    override fun canhandle(request: string) = request == "b"
    override fun process(request: string) {
        println("handler b processed $request")
    }
}

// 使用
fun main() {
    val handlera = concretehandlera()
    val handlerb = concretehandlerb()
    handlera.nexthandler = handlerb

    handlera.handlerequest("a")
    handlera.handlerequest("b")
}

这些示例展示了kotlin中如何实现一些常见的设计模式。每个模式都有其特定的用途和场景，选择适合的模式可以大大提升代码的可维护性和扩展性。

我有多年软件开发经验，精通嵌入式stm32，rtos，linux，ubuntu, android aosp, android app, java , kotlin , c, c++, python , qt。 如果您有软件开发定制需求，请联系我，电子邮件: mysolution@qq.com