抽象工厂模式(Java与Kotlin版)

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了抽象工厂模式(Java与Kotlin版)相关的知识,希望对你有一定的参考价值。

 

前文推送

设计模式

简单工厂模式(Java与Kotlin版)

工厂方法模式(Java与Kotlin版)

 

Kotlin基础知识

Kotlin入门第一课:从对比Java开始

Kotlin入门第二课:集合操作

Kotlin入门第三课:数据类型

初次尝试用Kotlin实现Android项目

 

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(): AbstractProductA
3     abstract fun createProductB(): AbstractProductB
4 }

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<String>) {
 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. 适用场景

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

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

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

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

以上是关于抽象工厂模式(Java与Kotlin版)的主要内容,如果未能解决你的问题,请参考以下文章

工厂方法模式(Java与Kotlin版)

大话设计模式-抽象工厂模式(大鸟和小菜Java版)

java 抽象工厂模式

设计模式-工厂方法模式[JAVA版]

java抽象工厂的使用意图是啥?

JAVA设计模式--抽象工厂模式