设计模式代表了最佳的实践
引言
- 创建型模式。
- 主要解决:不同条件下,创建不同实例。
- 关键代码:接口制定规范。
- 用户只想考虑顶层需求,给我想要的! 怎么办呢? 外包(工厂)!
场景
- 通过 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. 小结
- 简单工厂:唯一工厂类,工厂类依据入参创建产品对象。
- 工厂方法:多个工厂类,扩展产品子类,增加对应工厂即可。
- 抽象工厂:多个工厂类,产品子类分组,工厂组合为产品族。