工厂模式是一种创建对象的设计模式，它提供了一种创建对象的方式，将对象的创建和使用分离。在Kotlin中，常见的工厂模式有简单工厂模式、工厂方法模式和抽象工厂模式。下面我将分别展示这三种模式的实现。
简单工厂模式
简单工厂模式定义了一个工厂类，用于创建产品对象。它不属于GoF的23种设计模式，但它是工厂模式的基础。
- 定义产品接口：所有具体产品都要实现这个接口。
- 创建具体产品类：实现产品接口。
- 创建工厂类：提供一个创建产品对象的方法。
示例代码如下：
// 产品接口
interface Product {
fun use()
}
// 具体产品类1
class ConcreteProduct1 : Product {
override fun use() {
println("Using ConcreteProduct1")
}
}
// 具体产品类2
class ConcreteProduct2 : Product {
override fun use() {
println("Using ConcreteProduct2")
}
}
// 工厂类
class SimpleFactory {
companion object {
fun createProduct(productType: String): Product? {
return when (productType) {
"1" -> ConcreteProduct1()
"2" -> ConcreteProduct2()
else -> null
}
}
}
}
使用示例：
fun main() {
val product1 = SimpleFactory.createProduct("1")
product1?.use()
val product2 = SimpleFactory.createProduct("2")
product2?.use()
}
工厂方法模式
工厂方法模式将对象的创建延迟到子类中，每个子类负责创建特定的产品对象。
- 定义产品接口：同简单工厂模式。
- 创建具体产品类：同简单工厂模式。
- 定义工厂接口：包含一个创建产品对象的抽象方法。
- 创建具体工厂类：实现工厂接口，创建特定的产品对象。
示例代码如下：
// 产品接口
interface Product {
fun use()
}
// 具体产品类1
class ConcreteProduct1 : Product {
override fun use() {
println("Using ConcreteProduct1")
}
}
// 具体产品类2
class ConcreteProduct2 : Product {
override fun use() {
println("Using ConcreteProduct2")
}
}
// 工厂接口
interface Factory {
fun createProduct(): Product
}
// 具体工厂类1
class ConcreteFactory1 : Factory {
override fun createProduct(): Product {
return ConcreteProduct1()
}
}
// 具体工厂类2
class ConcreteFactory2 : Factory {
override fun createProduct(): Product {
return ConcreteProduct2()
}
}
使用示例：
fun main() {
val factory1 = ConcreteFactory1()
val product1 = factory1.createProduct()
product1.use()
val factory2 = ConcreteFactory2()
val product2 = factory2.createProduct()
product2.use()
}
抽象工厂模式
抽象工厂模式提供了一个创建一系列相关产品对象的接口，每个具体工厂类负责创建一组特定的产品对象。
- 定义产品族接口：如产品A接口和产品B接口。
- 创建具体产品类：实现产品族接口。
- 定义抽象工厂接口：包含创建不同产品的抽象方法。
- 创建具体工厂类：实现抽象工厂接口，创建一组相关的产品对象。
示例代码如下：
// 产品A接口
interface ProductA {
fun useA()
}
// 产品B接口
interface ProductB {
fun useB()
}
// 具体产品A1类
class ConcreteProductA1 : ProductA {
override fun useA() {
println("Using ConcreteProductA1")
}
}
// 具体产品A2类
class ConcreteProductA2 : ProductA {
override fun useA() {
println("Using ConcreteProductA2")
}
}
// 具体产品B1类
class ConcreteProductB1 : ProductB {
override fun useB() {
println("Using ConcreteProductB1")
}
}
// 具体产品B2类
class ConcreteProductB2 : ProductB {
override fun useB() {
println("Using ConcreteProductB2")
}
}
// 抽象工厂接口
interface AbstractFactory {
fun createProductA(): ProductA
fun createProductB(): ProductB
}
// 具体工厂类1
class ConcreteFactory1 : AbstractFactory {
override fun createProductA(): ProductA {
return ConcreteProductA1()
}
override fun createProductB(): ProductB {
return ConcreteProductB1()
}
}
// 具体工厂类2
class ConcreteFactory2 : AbstractFactory {
override fun createProductA(): ProductA {
return ConcreteProductA2()
}
override fun createProductB(): ProductB {
return ConcreteProductB2()
}
}
使用示例：
fun main() {
val factory1 = ConcreteFactory1()
val productA1 = factory1.createProductA()
val productB1 = factory1.createProductB()
productA1.useA()
productB1.useB()
val factory2 = ConcreteFactory2()
val productA2 = factory2.createProductA()
val productB2 = factory2.createProductB()
productA2.useA()
productB2.useB()
}
在上述代码中，AbstractFactory 定义了创建 ProductA 和 ProductB 的抽象方法，ConcreteFactory1 和 ConcreteFactory2 是具体的工厂实现类，分别创建不同组合的产品对象。通过这种方式，客户端可以根据需要选择不同的具体工厂来创建一系列相关的产品 。
当前文章价值3.09元，扫一扫支付后添加微信提供帮助！（如不能解决您的问题，可以申请退款）
评论已关闭！