软件设计模式(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