一. 基本工厂方法模式

在这种模式中，定义一个接口或抽象类来创建对象。

// 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"
}

// Creator.kt
abstract class Creator {
    abstract fun createProduct(): Product
}

// ConcreteCreatorA.kt
class ConcreteCreatorA : Creator() {
    override fun createProduct(): Product = ConcreteProductA()
}

// ConcreteCreatorB.kt
class ConcreteCreatorB : Creator() {
    override fun createProduct(): Product = ConcreteProductB()
}

二. 使用companion object的工厂方法

Kotlin的companion object可以用于实现工厂方法。

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

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

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

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

三. 使用sealed class的工厂方法

sealed class可以用于限制子类的类型，从而实现工厂方法。

// 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"
    }
}

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

四. 使用enum的工厂方法

enum可以用于实现工厂方法，特别适合于有限的产品类型。

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

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

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

enum class ProductType {
    A, B
}

object EnumProductFactory {
    fun createProduct(type: ProductType): Product {
        return when (type) {
            ProductType.A -> ConcreteProductA()
            ProductType.B -> ConcreteProductB()
        }
    }
}

总结

• 基本工厂方法模式：使用抽象类或接口定义工厂方法。

• companion object工厂方法：使用Kotlin的companion object来实现静态工厂方法。

• sealed class工厂方法：使用sealed class限制子类类型。

• enum工厂方法：使用enum来实现有限产品类型的工厂方法。

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