Kotlin编程设计模式简解三-技术精选-玖叶教程网

享元模式

享元模式是指通过共享一组相似的对象，从而减少对象的内存占用和创建时间。适用于需要创建大量相似的对象，并且这些对象之间的差别不大的情况，例如在图形编辑器中创建大量相似的图形。

interface Flyweight {
    fun operation(state: Int)
}

class ConcreteFlyweight : Flyweight {
    override fun operation(state: Int) {
        println("ConcreteFlyweight operation with state $state")
    }
}

class FlyweightFactory {
    private val flyweights = mutableMapOf<Int, Flyweight>()

    fun getFlyweight(state: Int): Flyweight {
        return flyweights.getOrPut(state) { ConcreteFlyweight() }
    }
}

策略模式

策略模式是指通过一组算法来封装不同的行为，从而让这些行为能够相互替换。适用于需要在运行时动态地选择不同的算法或行为的情况，例如在游戏中选择不同的角色或武器。

interface Strategy {
    fun algorithm()
}

class ConcreteStrategyA : Strategy {
    override fun algorithm() {
        println("ConcreteStrategyA algorithm")
    }
}

class ConcreteStrategyB : Strategy {
    override fun algorithm() {
        println("ConcreteStrategyB algorithm")
    }
}

class Context(private val strategy: Strategy) {
    fun contextInterface() {
        strategy.algorithm()
    }
}

模板方法模式

模板方法模式是指通过定义一个模板方法和一组抽象方法，来封装一组相似的算法，从而让这些算法能够相互替换。适用于需要在不同的算法之间共享一些通用的代码或逻辑的情况，例如在 GUI 编程中处理用户输入事件。

abstract class AbstractClass {
    fun templateMethod() {
        primitiveOperation1()
        primitiveOperation2()
    }

    abstract fun primitiveOperation1()
    abstract fun primitiveOperation2()
}

class ConcreteClassA : AbstractClass() {
    override fun primitiveOperation1() {
        println("ConcreteClassA primitiveOperation1")
    }

    override fun primitiveOperation2() {
        println("ConcreteClassA primitiveOperation2")
    }
}

class ConcreteClassB : AbstractClass() {
    override fun primitiveOperation1() {
        println("ConcreteClassB primitiveOperation1")
    }

    override fun primitiveOperation2() {
        println("ConcreteClassB primitiveOperation2")
    }
}

观察者模式

观察者模式是指通过定义一组观察者和一个被观察者，来实现一种发布-订阅的消息机制，从而让观察者能够接收到被观察者的状态变化。适用于需要在不同的对象之间进行松耦合的通信的情况，例如在 GUI 编程中更新界面元素。

interface Observer {
    fun update()
}

class ConcreteObserverA(private val subject: Subject) : Observer {
    override fun update() {
        println("ConcreteObserverA update")
        subject.getState()
    }
}

class ConcreteObserverB(private val subject: Subject) : Observer {
    override fun update() {
        println("ConcreteObserverB update")
        subject.getState()
    }
}

interface Subject {
    fun attach(observer: Observer)
    fun detach(observer: Observer)
    fun notifyObservers()
    fun getState()
}

class ConcreteSubject : Subject {
    private val observers = mutableListOf<Observer>()
    private var state = ""

    override fun attach(observer: Observer) {
        observers.add(observer)
    }

    override fun detach(observer: Observer) {
        observers.remove(observer)
    }

    override fun notifyObservers() {
        observers.forEach { it.update() }
    }

    override fun getState() {
        println("ConcreteSubject state is $state")
    }

    fun setState(state: String) {
        this.state = state
        notifyObservers()
    }
}

责任链模式

责任链模式是指通过定义一组处理器和一个请求对象，来实现一种链式的处理机制，从而让每个处理器能够处理请求或者将请求传递给下一个处理器。适用于需要在多个对象之间进行协作处理的情况，例如在 Web 开发中处理 HTTP 请求。

abstract class Handler {
    var successor: Handler? = null

    abstract fun handleRequest(request: Int)
}

class ConcreteHandlerA : Handler() {
    override fun handleRequest(request: Int) {
        if (request < 10) {
            println("ConcreteHandlerA handled the request")
        } else {
            successor?.handleRequest(request)
        }
    }
}

class ConcreteHandlerB : Handler() {
    override fun handleRequest(request: Int) {
        if (request >= 10 && request < 20) {
            println("ConcreteHandlerB handled the request")
        } else {
            successor?.handleRequest(request)
        }
    }
}

class ConcreteHandlerC : Handler() {
    override fun handleRequest(request: Int) {
        if (request >= 20) {
            println("ConcreteHandlerC handled the request")
        } else {
            successor?.handleRequest(request)
        }
    }
}

命令模式

命令模式是指通过定义一组命令对象和一个接收者对象，来实现一种解耦的请求-响应机制，从而让命令对象能够封装请求并将其发送给接收者对象。适用于需要在不同的对象之间进行松耦合的通信和控制的情况，例如在用户界面中处理用户输入事件。

interface Command {
    fun execute()
}

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

class ConcreteCommand(private val receiver: Receiver) : Command {
    override fun execute() {
        receiver.action()
    }
}

class Invoker {
    private var command: Command? = null

    fun setCommand(command: Command) {
        this.command = command
    }

    fun executeCommand() {
        command?.execute()
    }
}

玖叶教程网

前端编程开发入门

Kotlin编程设计模式简解三