收藏设计模式

Android设计模式:工厂设计模式

2021-11-01  本文已影响0人  搬码人

目录

  • 简单工厂模式
  • 工厂方法模式
  • 抽象工厂模式

简单工厂模式

简单工厂模式是所有工厂模式的基础,不属于23种设计模式范畴。
背景:吃水果:一个工厂生产多种产品

package 设计模式1

/**
 *@Description
 *@Author PC
 *@QQ 1578684787
 */

    /**
     * 抽象产品类
     */
    interface Product{
        fun show()
    }
    /**
     * 具体的产品类A
     */
    class ProductA:Product{
        override fun show() {
            println("产品A")
        }
    }
    /**
     * 具体的产品类B
     */
    class ProductB:Product{
        override fun show() {
            println("产品B")
        }
    }

    /**
     * 工厂类
     */

    object ProductFactory{
        fun createProduct(type:String):Product{
            lateinit var product:Product
            when(type){
                "A" -> product = ProductA()
                "B" -> product = ProductB()
            }

            return product
        }
    }

    /**
     * 测试
     */
    fun main() {
        //生产产品A
        ProductFactory.createProduct("A").show()
        //生产产品B
        ProductFactory.createProduct("B").show()

    }

运行结果

简单工厂模式

优点

代码解耦,创建实例的工作与使用实例的工作分开,使用者不必关心类对象的创建。

缺点


工厂方法模式

背景:有多个工厂,每个工厂只生产一种产品。

package 设计模式1

/**
 *@Description
 *@Author PC
 *@QQ 1578684787
 */

    /**
     * 抽象产品类
     */
    interface Product{
        fun show()
    }
    /**
     * 具体的产品类A
     */
    class ProductA:Product{
        override fun show() {
            println("产品A")
        }
    }
    /**
     * 具体的产品类B
     */
    class ProductB:Product{
        override fun show() {
            println("产品B")
        }
    }

    /**
     * 抽象的工厂类
     */

    abstract class ProductFactory(){
        abstract fun createProduct():Product
    }
/**
 * 具体的工厂类
 */
 object ProductFactoryA:ProductFactory(){
    override fun createProduct(): Product {
        return ProductA()
    }
}

object ProductFactoryB:ProductFactory(){
    override fun createProduct(): Product {
        return ProductB()
    }
}

/**
     * 测试
     */
    fun main() {
        ProductFactoryA.createProduct().show()
        ProductFactoryB.createProduct().show()

    }

运行结果:

优点

缺点

应用

Android中的ThreadFactory就是使用了工厂方法模式来生成线程的,线程就是ThreadFactory的产品。
应用场景:生成复杂对象时,无需知道具体类名,只需知道相应的工厂方法即可。


抽象工厂模式

背景:有多个工厂,每个工厂生产多个产品。

package 设计模式1.factory2

/**
 *@Description
 *@Author PC
 *@QQ 1578684787
 */

/**
 * 抽象工厂模式
 */

interface CPU{
    fun showCPU()
}
interface Memory{
    fun showMemory()
}
interface HD{
    fun showHD()
}

/**
 * 具体的产品类
 */

class IntelCPU:CPU{
    override fun showCPU() {
        println("this is IntelCPU")
    }
}
class AmdCPU:CPU{
    override fun showCPU() {
        println("this is AMD CPU")
    }
}
class SanXinMemory:Memory{
    override fun showMemory() {
        println("this is SanXinMemory")
    }

}
class KingstonMemory:Memory{
    override fun showMemory() {
        println("this is KingstonMemory")
    }

}
class XiJieHD:HD{
    override fun showHD() {
        println("希捷 硬盘")
    }

}
class DongZhiHD:HD{
    override fun showHD() {
        println("东芝 硬盘")
    }

}

/**
 * 抽象的工厂类
 */

abstract class ComputerFactory{
    abstract fun createCPU():CPU
    abstract fun createMemory():Memory
    abstract fun createHD():HD
}

/**
 * 具体的工厂类
 */
object AppleFactory:ComputerFactory(){
    override fun createCPU(): CPU {
        return IntelCPU()
    }

    override fun createMemory(): Memory {
        return SanXinMemory()
    }

    override fun createHD(): HD {
        return DongZhiHD()
    }

}

object LenovoFactory:ComputerFactory(){
    override fun createCPU(): CPU {
        return AmdCPU()
    }

    override fun createMemory(): Memory {
       return KingstonMemory()
    }

    override fun createHD(): HD {
        return XiJieHD()
    }

}

/**
 * 测试
 */
fun main() {
    println("--------苹果生产厂---------")
    AppleFactory.apply {
        this.createCPU().showCPU()
        this.createMemory().showMemory()
        this.createHD().showHD()
    }
    println("--------联想生产厂---------")
    LenovoFactory.apply {
        this.createCPU().showCPU()
        this.createMemory().showMemory()
        this.createHD().showHD()
    }
}

测试结果


image.png

优点

代码解耦,创建实例的工作与使用实例的工作分开,使用者不用关心类如何创建。

缺点

如果新增产品,则需要修改抽象工厂和所有的具体工厂违反了开放封闭原则。

应用场景

生产多个产品组合的对象。

参考文章:
Android的设计模式-工厂设计模式

上一篇 下一篇

猜你喜欢

热点阅读