目录
- 简单工厂模式
- 工厂方法模式
- 抽象工厂模式
简单工厂模式
简单工厂模式是所有工厂模式的基础，不属于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的设计模式-工厂设计模式
网友评论