抽象工厂模式用于创建一组相关或依赖的对象,而无需指定它们的具体类。以下是几种在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限制产品类型。
根据具体需求选择合适的抽象工厂实现方式。