抽象工厂模式(Java与Kotlin版)
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了抽象工厂模式(Java与Kotlin版)相关的知识,希望对你有一定的参考价值。
前文推送
设计模式
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(): 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版)的主要内容,如果未能解决你的问题,请参考以下文章