设计模式代表了最佳的实践

引言

• 创建型模式。
• 主要解决：不同条件下，创建不同实例。
• 关键代码：接口制定规范。
• 用户只想考虑顶层需求，给我想要的！ 怎么办呢？ 外包（工厂）！

场景

• 通过 new 就能创建的对象，无需使用工厂模式。
• 用户不关心实例的创建、组合和表达的细节。
• 生成复杂对象的地方，都可以使用工厂方法模式。

1. 简单工厂模式

1.1 图示

简单工厂模式

1.2 代码示例

interface Color {
    fun paint()
}

class Red : Color {
    override fun paint() {
        println("Color Red::paint() method")
    }
}

class Green : Color {
    override fun paint() {
        println("Color Green::paint() method")
    }
}

class ColorFactory {
    fun getColor(colorType: String): Color? {
        return when (colorType) {
            "RED" -> {
                Red()
            }
            "GREEN" -> {
                Green()
            }
            else -> null
        }
    }
}

class FactoryColorDemo {
    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            val colorFactory = ColorFactory()

            //获取 Red 的对象，并调用它的 paint 方法
            val red = colorFactory.getColor("RED")
            red?.paint()

            //获取 Green 的对象，并调用它的 paint 方法
            val green = colorFactory.getColor("GREEN")
            green?.paint()
        }
    }
}

1.3 图示（简单工厂模式 增加产品）

简单工厂模式 增加产品

1.4 优缺点

• 增加新的产品子类，需要在工厂中增加新的if-else。
• 扩展性差，违背了开闭原则，也影响了可读性。
• 适合使用在业务较简单，工厂类不会经常更改的情况。

2. 工厂模式

2.1 图示

工厂模式

2.2 代码示例

interface Color {
    fun paint()
}

class Red : Color {
    override fun paint() {
        println("Color Red::paint() method")
    }
}

class Green : Color {
    override fun paint() {
        println("Color Green::paint() method")
    }
}

interface ColorFactory {
    fun createColor(): Color
}

class RedColorFactory : ColorFactory {
    override fun createColor(): Color {
        return Red()
    }
}

class GreenColorFactory : ColorFactory {
    override fun createColor(): Color {
        return Green()
    }
}

class FactoryColorDemo {
    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            //获取 Red 的对象，并调用它的 paint 方法
            val redColorFactory = RedColorFactory()
            val red = redColorFactory.createColor()
            red.paint()

            //获取 Green 的对象，并调用它的 paint 方法
            val greenColorFactory = GreenColorFactory()
            val green = greenColorFactory.createColor()
            green.paint()
        }
    }
}

2.3 图示（工厂模式 增加产品）

工厂模式 增加产品

2.4 优缺点

• 一个子类对应一个工厂类，类膨胀。
• 类数量多，代码复杂度高。

3. 抽象工厂模式

3.1 图示

抽象工厂模式

3.2 代码示例

interface Color {
    fun paint()
}

class Red : Color {
    override fun paint() {
        println("Color Red::paint() method")
    }
}

class Green : Color {
    override fun paint() {
        println("Color Green::paint() method")
    }
}

interface Shape {
    fun draw()
}

class Rectangle : Shape {
    override fun draw() {
        println("Shape Rectangle::draw() method")
    }
}

class Circle : Shape {
    override fun draw() {
        println("Shape Circle::draw() method")
    }
}

interface LogoFactory {
    fun createColor(): Color
    fun createShape(): Shape
}

class HappyLogoFactory : LogoFactory {
    override fun createColor(): Color {
        return Red()
    }

    override fun createShape(): Shape {
        return Circle()
    }
}

class AngryLogoFactory : LogoFactory {
    override fun createColor(): Color {
        return Green()
    }

    override fun createShape(): Shape {
        return Rectangle()
    }
}

class FactoryColorDemo {
    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            //获取 喜庆Logo（灯笼红） 的对象
            val happyLogoFactory = HappyLogoFactory()
            val happyColor = happyLogoFactory.createColor()
            val happyShape = happyLogoFactory.createShape()
            happyColor.paint()
            happyShape.draw()

            //获取 愤怒Logo（弹幕绿） 的对象
            val angryLogoFactory = AngryLogoFactory()
            val angryColor = angryLogoFactory.createColor()
            val angryShape = angryLogoFactory.createShape()
            angryColor.paint()
            angryShape.draw()
        }
    }
}

3.3 图示（抽象工厂模式 增加产品）

抽象工厂模式 增加产品

3.4 图示（抽象工厂模式 增加工厂）

抽象工厂模式 增加工厂

3.5 图示（抽象工厂模式 概括总结）

抽象工厂模式 概括总结

3.6 优缺点

• 产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
• 产品族难扩展，产品等级易扩展。

4. 小结

• 简单工厂：唯一工厂类，工厂类依据入参创建产品对象。
• 工厂方法：多个工厂类，扩展产品子类，增加对应工厂即可。
• 抽象工厂：多个工厂类，产品子类分组，工厂组合为产品族。

 

小编的博客系列

设计模式 全家桶