邯郸住房及城乡建设部网站,wordpress 注册页修改,网页图,上海cms网站建设软件设计模式#xff08;Software Design Patterns#xff09;是面向对象设计中常用的解决方案#xff0c;它们为常见的软件设计问题提供了一些被证明有效的解决方案。以下是一些主要的软件设计模式及其在Kotlin中的实现示例。
创建型模式#xff08;Creational PatternsSoftware 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.partApartB builder.partBpartC builder.partC}class Builder {var partA: String? nullprivate setvar partB: String? nullprivate setvar partC: String? nullprivate setfun 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 mutableListOfObserver()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: Commandfun 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? nullfun handleRequest(request: String) {if (canHandle(request)) {process(request)} else {nextHandler?.handleRequest(request)}}protected abstract fun canHandle(request: String): Booleanprotected abstract fun process(request: String)
}class ConcreteHandlerA : Handler() {override fun canHandle(request: String) request Aoverride fun process(request: String) {println(Handler A processed $request)}
}class ConcreteHandlerB : Handler(){override fun canHandle(request: String) request Boverride fun process(request: String) {println(Handler B processed $request)}
}// 使用
fun main() {val handlerA ConcreteHandlerA()val handlerB ConcreteHandlerB()handlerA.nextHandler handlerBhandlerA.handleRequest(A)handlerA.handleRequest(B)
}这些示例展示了Kotlin中如何实现一些常见的设计模式。每个模式都有其特定的用途和场景选择适合的模式可以大大提升代码的可维护性和扩展性。
我有多年软件开发经验精通嵌入式STM32RTOSLinuxUbuntu, Android AOSP, Android APP, Java , Kotlin , C, C, Python , QT。 如果您有软件开发定制需求请联系我电子邮件: mysolutionqq.com
