前文推送
设计模式
Kotlin基础知识
1. 定义
抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。
2. 结构
AbstractFactory：抽象工厂，定义创建实例的抽象方法；
ConcreteFactory：具体工厂，实现具体逻辑；
AbstractProduct：抽象产品，定义产品的抽象方法；
Product：具体产品，实现具体逻辑；
3. 代码
3.1 Java
AbstractProductA与AbstractProductB：
abstract class AbstractProductA {
abstract void printA();
}
abstract class AbstractProductB {
abstract void printB();
}
定义了两个抽象产品角色，分别有抽象方法printA和printB。
ConcreteProductA1、ConcreteProductA2、ConcreteProductB1及ConcreteProductB2：
class ConcreteProductA1 extends AbstractProductA {
void printA() {
System.out.println("printA of ConcreteProductA1");
}
}
class ConcreteProductA2 extends AbstractProductA {
void printA() {
System.out.println("printA of ConcreteProductA2");
}
}
class ConcreteProductB1 extends AbstractProductB {
void printB() {
System.out.println("printB of ConcreteProductB1");
}
}
class ConcreteProductB2 extends AbstractProductB {
void printB() {
System.out.println("printB of ConcreteProductB2");
}
}
定义了四个具体产品角色，分别实现了父类对应的printA和printB方法。
A1和B1属于同一个产品族的不同产品等级的两种产品，A2和B2类似。其中：
产品等级——同一类产品的产品等级相同，如海尔冰箱、西门子冰箱等；
产品族——同一家工厂生产的不同产品等级的产品，如海尔冰箱、海尔洗衣机等。
AbstractFactory：
abstract class AbstractFactory {
abstract AbstractProductA createProductA();
abstract AbstractProductB createProductB();
}
定义了抽象工厂角色，及抽象方法createProductA和createProductB。
ConcreteFactory1与ConcreteFactory2：
class ConcreteFactory1 extends AbstractFactory {
AbstractProductA createProductA() {
System.out.println("create ProductA1");
return new ConcreteProductA1();
}
AbstractProductB createProductB() {
System.out.println("create ProductB1");
return new ConcreteProductB1();
}
}
class ConcreteFactory2 extends AbstractFactory {
AbstractProductA createProductA() {
System.out.println("create ProductA2");
return new ConcreteProductA2();
}
AbstractProductB createProductB() {
System.out.println("create ProductB2");
return new ConcreteProductB2();
}
}
定义了两个具体工厂角色，分别实现了createProductA和createProductB方法。
AbstractFactoryPattern：
public class AbstractFactoryPattern {
public static void main(String[] args) {
System.out.println("Abstract Factory Pattern");
AbstractFactory factory = new ConcreteFactory1();
AbstractProductA productA = factory.createProductA();
AbstractProductB productB = factory.createProductB();
productA.printA();
productB.printB();
factory = new ConcreteFactory2();
productA = factory.createProductA();
productB = factory.createProductB();
productA.printA();
productB.printB();
}
}
不同产品族的具体产品实例，用不同的具体工厂来创建。
输出：
3.2 Kotlin
AbstractProductA与AbstractProductB：
abstract class AbstractProductA {
abstract fun printA()
}
abstract class AbstractProductB {
abstract fun printB()
}
ConcreteProductA1、ConcreteProductA2、ConcreteProductB1及ConcreteProductB2：
class ConcreteProductA1 : AbstractProductA() {
override fun printA() {
println("printA of ConcreteProductA1")
}
}
class ConcreteProductA2 : AbstractProductA() {
override fun printA() {
println("printA of ConcreteProductA2")
}
}
class ConcreteProductB1 : AbstractProductB() {
override fun printB() {
println("printB of ConcreteProductB1")
}
}
class ConcreteProductB2 : AbstractProductB() {
override fun printB() {
println("printB of ConcreteProductB2")
}
}
AbstractFactory：
abstract class AbstractFactory {
abstract fun createProductA(): AbstractProductA
abstract fun createProductB(): AbstractProductB
}
ConcreteFactory1与ConcreteFactory2：
class ConcreteFactory1 : AbstractFactory() {
override fun createProductA(): AbstractProductA {
println("create ProductA1")
return ConcreteProductA1()
}
override fun createProductB(): AbstractProductB {
println("create ProductB1")
return ConcreteProductB1()
}
}
class ConcreteFactory2 : AbstractFactory() {
override fun createProductA(): AbstractProductA {
println("create ProductA2")
return ConcreteProductA2()
}
override fun createProductB(): AbstractProductB {
println("create ProductB2")
return ConcreteProductB2()
}
}
AbstractFactoryPattern：
fun main(args: Array<String>) {
println("Abstract Factory Pattern")
var factory: AbstractFactory = ConcreteFactory1()
var productA = factory.createProductA()
var productB = factory.createProductB()
productA.printA()
productB.printB()
factory = ConcreteFactory2()
productA = factory.createProductA()
productB = factory.createProductB()
productA.printA()
productB.printB()
}
输出同上。
4. 优缺点
4.1 优点
抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用；
当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式；
增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。
4.2 缺点
在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便；
开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）。
5. 适用场景
一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的；
系统中有多于一个的产品族，而每次只使用其中某一产品族；
属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来；
系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。