前文推送

设计模式

 

Kotlin基础知识

 

1. 定义

抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式。

 

2. 结构

AbstractFactory：抽象工厂，定义创建实例的抽象方法；

ConcreteFactory：具体工厂，实现具体逻辑；

AbstractProduct：抽象产品，定义产品的抽象方法；

Product：具体产品，实现具体逻辑；

 

3. 代码

3.1 Java

AbstractProductA与AbstractProductB：

1 abstract class AbstractProductA {2     abstract void printA();3 }4 5 abstract class AbstractProductB {6     abstract void printB();7 }

定义了两个抽象产品角色，分别有抽象方法printA和printB。

ConcreteProductA1、ConcreteProductA2、ConcreteProductB1及ConcreteProductB2：

1 class ConcreteProductA1 extends AbstractProductA { 2     void printA() { 3         System.out.println("printA of ConcreteProductA1"); 4     } 5 } 6  7 class ConcreteProductA2 extends AbstractProductA { 8     void printA() { 9         System.out.println("printA of ConcreteProductA2");10     }11 }12 13 class ConcreteProductB1 extends AbstractProductB {14     void printB() {15         System.out.println("printB of ConcreteProductB1");16     }17 }18 19 class ConcreteProductB2 extends AbstractProductB {20     void printB() {21         System.out.println("printB of ConcreteProductB2");22     }23 }

定义了四个具体产品角色，分别实现了父类对应的printA和printB方法。

A1和B1属于同一个产品族的不同产品等级的两种产品，A2和B2类似。其中：

产品等级——同一类产品的产品等级相同，如海尔冰箱、西门子冰箱等；

产品族——同一家工厂生产的不同产品等级的产品，如海尔冰箱、海尔洗衣机等。

AbstractFactory：

1 abstract class AbstractFactory {2     abstract AbstractProductA createProductA();3     abstract AbstractProductB createProductB();4 }

定义了抽象工厂角色，及抽象方法createProductA和createProductB。

ConcreteFactory1与ConcreteFactory2：

1 class ConcreteFactory1 extends AbstractFactory { 2     AbstractProductA createProductA() { 3         System.out.println("create ProductA1"); 4  5         return new ConcreteProductA1(); 6     } 7  8     AbstractProductB createProductB() { 9         System.out.println("create ProductB1");10 11         return new ConcreteProductB1();12     }13 }14 15 class ConcreteFactory2 extends AbstractFactory {16     AbstractProductA createProductA() {17         System.out.println("create ProductA2");18 19         return new ConcreteProductA2();20     }21 22     AbstractProductB createProductB() {23         System.out.println("create ProductB2");24 25         return new ConcreteProductB2();26     }27 }

定义了两个具体工厂角色，分别实现了createProductA和createProductB方法。

AbstractFactoryPattern：

1 public class AbstractFactoryPattern { 2     public static void main(String[] args) { 3         System.out.println("Abstract Factory Pattern"); 4  5         AbstractFactory factory = new ConcreteFactory1(); 6         AbstractProductA productA = factory.createProductA(); 7         AbstractProductB productB = factory.createProductB(); 8         productA.printA(); 9         productB.printB();10 11         factory = new ConcreteFactory2();12         productA = factory.createProductA();13         productB = factory.createProductB();14         productA.printA();15         productB.printB();16     }17 }

不同产品族的具体产品实例，用不同的具体工厂来创建。

输出：

 

3.2 Kotlin

AbstractProductA与AbstractProductB：

1 abstract class AbstractProductA {2     abstract fun printA()3 }4 5 abstract class AbstractProductB {6     abstract fun printB()7 }

ConcreteProductA1、ConcreteProductA2、ConcreteProductB1及ConcreteProductB2：

1 class ConcreteProductA1 : AbstractProductA() { 2     override fun printA() { 3         println("printA of ConcreteProductA1") 4     } 5 } 6  7 class ConcreteProductA2 : AbstractProductA() { 8     override fun printA() { 9         println("printA of ConcreteProductA2")10     }11 }12 13 class ConcreteProductB1 : AbstractProductB() {14     override fun printB() {15         println("printB of ConcreteProductB1")16     }17 }18 19 class ConcreteProductB2 : AbstractProductB() {20     override fun printB() {21         println("printB of ConcreteProductB2")22     }23 }

AbstractFactory：

1 abstract class AbstractFactory {2     abstract fun createProductA(): AbstractProductA3     abstract fun createProductB(): AbstractProductB4 }

ConcreteFactory1与ConcreteFactory2：

1 class ConcreteFactory1 : AbstractFactory() { 2     override fun createProductA(): AbstractProductA { 3         println("create ProductA1") 4  5         return ConcreteProductA1() 6     } 7  8     override fun createProductB(): AbstractProductB { 9         println("create ProductB1")10 11         return ConcreteProductB1()12     }13 }14 15 class ConcreteFactory2 : AbstractFactory() {16     override fun createProductA(): AbstractProductA {17         println("create ProductA2")18 19         return ConcreteProductA2()20     }21 22     override fun createProductB(): AbstractProductB {23         println("create ProductB2")24 25         return ConcreteProductB2()26     }27 }

AbstractFactoryPattern：

1 fun main(args: Array
     
      ) { 2     println("Abstract Factory Pattern") 3  4     var factory: AbstractFactory = ConcreteFactory1() 5     var productA = factory.createProductA() 6     var productB = factory.createProductB() 7     productA.printA() 8     productB.printB() 9 10     factory = ConcreteFactory2()11     productA = factory.createProductA()12     productB = factory.createProductB()13     productA.printA()14     productB.printB()15 }
     

输出同上。

 

4. 优缺点

4.1 优点

抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用；

当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式；

增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。

 

4.2 缺点

在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便；

开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）。

 

5. 适用场景

一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的；

系统中有多于一个的产品族，而每次只使用其中某一产品族；

属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来；

系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。