Kotlin设计模式之抽象工厂模式

抽象工厂模式用于创建一组相关或依赖的对象,而无需指定它们的具体类。以下是几种在Kotlin中实现抽象工厂模式的方法:

一. 基本抽象工厂模式

在这种模式中,定义一组产品接口和一个工厂接口,然后实现这些接口。

Kotlin 复制代码
// ProductA.kt
interface ProductA {
    fun use(): String
}

// ProductB.kt
interface ProductB {
    fun use(): String
}

// ConcreteProductA1.kt
class ConcreteProductA1 : ProductA {
    override fun use() = "Using Product A1"
}

// ConcreteProductA2.kt
class ConcreteProductA2 : ProductA {
    override fun use() = "Using Product A2"
}

// ConcreteProductB1.kt
class ConcreteProductB1 : ProductB {
    override fun use() = "Using Product B1"
}

// ConcreteProductB2.kt
class ConcreteProductB2 : ProductB {
    override fun use() = "Using Product B2"
}

// AbstractFactory.kt
interface AbstractFactory {
    fun createProductA(): ProductA
    fun createProductB(): ProductB
}

// ConcreteFactory1.kt
class ConcreteFactory1 : AbstractFactory {
    override fun createProductA(): ProductA = ConcreteProductA1()
    override fun createProductB(): ProductB = ConcreteProductB1()
}

// ConcreteFactory2.kt
class ConcreteFactory2 : AbstractFactory {
    override fun createProductA(): ProductA = ConcreteProductA2()
    override fun createProductB(): ProductB = ConcreteProductB2()
}

二. 使用companion object的抽象工厂

可以使用companion object来实现工厂方法,提供一种静态工厂的实现方式。

Kotlin 复制代码
// Product.kt
interface Product {
    fun use(): String
}

// ConcreteProductA.kt
class ConcreteProductA : Product {
    override fun use() = "Using Product A"
}

// ConcreteProductB.kt
class ConcreteProductB : Product {
    override fun use() = "Using Product B"
}

// AbstractFactory.kt
interface AbstractFactory {
    fun createProduct(type: String): Product
}

// ConcreteFactory.kt
class ConcreteFactory : AbstractFactory {
    companion object {
        fun createFactory(): AbstractFactory = ConcreteFactory()
    }

    override fun createProduct(type: String): Product {
        return when (type) {
            "A" -> ConcreteProductA()
            "B" -> ConcreteProductB()
            else -> throw IllegalArgumentException("Unknown product type")
        }
    }
}

三. 使用sealed class的抽象工厂

sealed class可以用于限制产品类型,从而实现抽象工厂。

Kotlin 复制代码
// SealedProduct.kt
sealed class SealedProduct {
    abstract fun use(): String

    class ProductA : SealedProduct() {
        override fun use() = "Using Product A"
    }

    class ProductB : SealedProduct() {
        override fun use() = "Using Product B"
    }
}

// SealedFactory.kt
object SealedFactory {
    fun createProduct(type: String): SealedProduct {
        return when (type) {
            "A" -> SealedProduct.ProductA()
            "B" -> SealedProduct.ProductB()
            else -> throw IllegalArgumentException("Unknown product type")
        }
    }
}

总结

  • 基本抽象工厂模式:定义多个产品接口和工厂接口,然后实现这些接口。
  • companion object抽象工厂:使用companion object提供静态工厂方法。
  • sealed class抽象工厂:使用sealed class限制产品类型。

根据具体需求选择合适的抽象工厂实现方式。

相关推荐
王嘉俊9251 小时前
设计模式--享元模式:优化内存使用的轻量级设计
java·设计模式·享元模式
bkspiderx3 小时前
C++设计模式之行为型模式:中介者模式(Mediator)
c++·设计模式·中介者模式
Meteors.5 小时前
23种设计模式——责任链模式(Chain of Responsibility Pattern)
设计模式·责任链模式
o0向阳而生0o6 小时前
107、23种设计模式之观察者模式(16/23)
观察者模式·设计模式
默默coding的程序猿7 小时前
1.单例模式有哪几种常见的实现方式?
java·开发语言·spring boot·spring·单例模式·设计模式·idea
bkspiderx8 小时前
C++设计模式之行为型模式:迭代器模式(Iterator)
c++·设计模式·迭代器模式
简小瑞10 小时前
VSCode源码解密:一行代码解决内存泄漏难题
前端·设计模式·visual studio code
Asort10 小时前
JavaScript设计模式(九)——装饰器模式 (Decorator)
前端·javascript·设计模式
rongqing201910 小时前
Google 智能体设计模式:模型上下文协议 (MCP)
设计模式
小小前端_我自坚强10 小时前
2025WebAssembly详解
前端·设计模式·前端框架