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