安卓常见设计模式3.2------工厂模式,工厂方法模式,抽象工厂模式对比(Kotlin版)

1. 都是创建型模式

工厂模式(Factory Pattern)、工厂方法模式(Factory Method Pattern)和抽象工厂模式(Abstract Factory Pattern)都是创建型设计模式,它们之间有以下区别:

  1. 工厂模式(Factory Pattern):

    工厂模式是一种创建对象的模式,它通过一个工厂类来封装对象的创建过程。客户端只需要与工厂类交互,而无需直接实例化具体的产品对象。
    工厂模式适用于创建单个产品对象的场景,它通过工厂类的静态方法或实例方法来创建具体产品对象。

  2. 工厂方法模式(Factory Method Pattern):

    工厂方法模式是一种创建单个对象的模式,它定义了一个工厂方法接口,在具体的工厂类中实现该方法来创建具体的产品对象。每个具体工厂类只负责创建一种类型的产品对象

    工厂方法模式适用于需要根据不同情况创建不同类型的产品对象的场景。

  3. 抽象工厂模式(Abstract Factory Pattern):

    抽象工厂模式是一种创建一系列相关或相互依赖的对象的模式 ,它提供了一个抽象工厂接口,该接口声明了一组创建产品对象的方法。具体的工厂类实现这些方法来创建具体的产品对象。

    抽象工厂模式适用于创建一系列相关产品的场景,每个具体工厂类负责创建特定产品族的对象。

2. 代码举例

// 工厂模式示例:

kotlin 复制代码
// 抽象产品类
abstract class Product {
    abstract fun operation()
}

// 具体产品类A
class ConcreteProductA : Product() {
    override fun operation() {
        println("ConcreteProductA operation")
    }
}

// 具体产品类B
class ConcreteProductB : Product() {
    override fun operation() {
        println("ConcreteProductB operation")
    }
}

// 工厂类
class Factory {
    fun createProduct(type: String): Product {
        return when (type) {
            "A" -> ConcreteProductA()
            "B" -> ConcreteProductB()
            else -> throw IllegalArgumentException("Invalid product type")
        }
    }
}

// 客户端代码
fun main() {
    val factory = Factory()
    val productA = factory.createProduct("A")
    productA.operation()

    val productB = factory.createProduct("B")
    productB.operation()
}

// 工厂方法模式示例:

kotlin 复制代码
// 抽象产品类
abstract class Product {
    abstract fun operation()
}

// 具体产品类A
class ConcreteProductA : Product() {
    override fun operation() {
        println("ConcreteProductA operation")
    }
}

// 具体产品类B
class ConcreteProductB : Product() {
    override fun operation() {
        println("ConcreteProductB operation")
    }
}

// 抽象工厂类
abstract class Factory {
    abstract fun createProduct(): Product

    fun performOperation() {
        val product = createProduct()
        product.operation()
    }
}

// 具体工厂类A
class ConcreteFactoryA : Factory() {
    override fun createProduct(): Product {
        return ConcreteProductA()
    }
}

// 具体工厂类B
class ConcreteFactoryB : Factory() {
    override fun createProduct(): Product {
        return ConcreteProductB()
    }
}

// 客户端代码
fun main() {
    val factoryA: Factory = ConcreteFactoryA()
    factoryA.performOperation()

    val factoryB: Factory = ConcreteFactoryB()
    factoryB.performOperation()
}

// 抽象工厂模式示例:

kotlin 复制代码
// 抽象产品接口A
interface ProductA {
    fun operationA()
}

// 具体产品类A1
class ConcreteProductA1 : ProductA {
    override fun operationA() {
        println("ConcreteProductA1 operationA")
    }
}

// 具体产品类A2
class ConcreteProductA2 : ProductA {
    override fun operationA() {
        println("ConcreteProductA2 operationA")
    }
}

// 抽象产品接口B
interface ProductB {
    fun operationB()
}

// 具体产品类B1
class ConcreteProductB1 : ProductB {
    override fun operationB() {
        println("ConcreteProductB1 operationB")
    }
}

// 具体产品类B2
class ConcreteProductB2 : ProductB {
    override fun operationB() {
        println("ConcreteProductB2 operationB")
    }
}

// 抽象工厂接口
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: AbstractFactory = ConcreteFactory1()
    val productA1: ProductA = factory1.createProductA()
    val productB1: ProductB = factory1.createProductB()
    productA1.operationA()
    productB1.operationB()

    val factory2: AbstractFactory = ConcreteFactory2()
    val productA2: ProductA = factory2.createProductA()
    val productB2: ProductB = factory2.createProductB()
    productA2.operationA()
    productB2.operationB()
}

Thank you for your reading, best regards!

相关推荐
xiangzhihong81 小时前
使用Universal Links与Android App Links实现网页无缝跳转至应用
android·ios
hqxstudying1 小时前
Java创建型模式---原型模式
java·开发语言·设计模式·代码规范
车载应用猿2 小时前
基于Android14的CarService 启动流程分析
android
没有了遇见2 小时前
Android 渐变色实现总结
android
WebInfra3 小时前
如何在程序中嵌入有大量字符串的 HashMap
算法·设计模式·架构
雨白5 小时前
Jetpack系列(四):精通WorkManager,让后台任务不再失控
android·android jetpack
mmoyula7 小时前
【RK3568 驱动开发:实现一个最基础的网络设备】
android·linux·驱动开发
Gavynlee7 小时前
plantuml用法总结
设计模式
sam.li7 小时前
WebView安全实现(一)
android·安全·webview
DKPT8 小时前
Java享元模式实现方式与应用场景分析
java·笔记·学习·设计模式·享元模式