一、前言

上篇文章 《Java 设计模式之工厂模式(二)》,介绍了简单工厂模式和工厂方法模式,本篇将继续介绍工厂模式中的最后一个模式--抽象工厂模式。

二、简单介绍

抽象工厂模式是所有形态的工厂模式中最为抽象的。抽象工厂模式可以向客户端提供一个接口,使得客户端在不必指定产品的具体类型(不是指实现类)的情况下,能够创建多个产品族的产品对象。

产品族可以通入下图理解:

在上图中,有多个发动机、轮胎和座椅,它们都可以看作是单独的产品,我们将发动机、轮胎和座椅组成一个产品族,用于区分其他的发动机、轮胎和座椅。

每个产品族又可以划分成高端、中端和低端系列产品。

三、实现方式

我们现在通过代码实现不同产品族中每个产品的创建。我们以高端和低端产品族为例。

发动机接口和实现类:

  1. public interface Engine {
  2. void run();
  3. }
  4. class HighEndEngine implements Engine {
  5. @Override
  6. public void run() {
  7. System.out.println("高端发动机,启动快");
  8. }
  9. }
  10. class LowEndEngine implements Engine {
  11. @Override
  12. public void run() {
  13. System.out.println("低端发动机,启动慢");
  14. }
  15. }

轮胎接口和实现类:

  1. public interface Tyre {
  2. void use();
  3. }
  4. class HighEndTyre implements Tyre {
  5. @Override
  6. public void use() {
  7. System.out.println("高端轮胎,耐磨防滑");
  8. }
  9. }
  10. class LowEndTyre implements Tyre {
  11. @Override
  12. public void use() {
  13. System.out.println("低端轮胎,磨损大,易打滑");
  14. }
  15. }

座椅接口和实现类:

  1. public interface Seat {
  2. void feel();
  3. }
  4. class HighEndSeat implements Seat {
  5. @Override
  6. public void feel() {
  7. System.out.println("高端座椅,坐着舒适");
  8. }
  9. }
  10. class LowEndSeat implements Seat {
  11. @Override
  12. public void feel() {
  13. System.out.println("低端座椅,坐旧难受");
  14. }
  15. }

工厂模式的前提:创建的实例通常都具有共同的父类,此处使用接口作为“父类”。

如果使用工厂方法模式,代码如下:

  1. public interface EngineFactory {
  2. Engine createEngine();
  3. }
  4. public interface TyreFactory {
  5. Tyre createTyre();
  6. }
  7. public interface SeatFactory{
  8. Seat createSeat();
  9. }
  10. ...

发动机、轮胎、座椅 3 个产品需要创建 3 个抽象工厂与 6 个实现类(高端和低端)。

客户端调用:

  1. public class Client {
  2. public static void main(String[] args) {
  3. EngineFactory ef = new HighEndEngineFactory();
  4. Engine engine = ef.createEngine();
  5. TyreFactory tf = new HighEndTyreFactory();
  6. Tyre tyre = tf.createTyre();
  7. SeatFactory sf = new HighEndEngineSeatFactory();
  8. Seat seat = sf.createSeat();
  9. }
  10. }

如果需要拼装一辆高端的轿车,客户端需要创建 3 个高端的工厂获取发动机、轮胎和座椅才能完成需求。这样客户端就与多个类进行耦合,违反了迪米特法则。

假设,高端产品族新增一个安全锁的产品,我们又要新建相应的抽象工厂和子类工厂,项目结构的复杂度大大增加。因此,简单工厂模式和工厂方法模式只适用于创建某一类对象,对于产品族维度划分的产品创建的操作就显得繁琐了。

如果使用抽象工厂模式,我们站在产品族内部结构的角度思考,抽象工厂中方法对应产品结构,而具体工厂对应产品族中的各个产品,那么需求实现起来就轻松许多了。

工厂接口:

  1. public interface CarFactory {
  2. Engine createEngine();
  3. Tyre createTyre();
  4. Seat createSeat();
  5. }

工厂实现类:

  1. public class HighEndCarFactory implements CarFactory {
  2. @Override
  3. public Engine createEngine() {
  4. return new HighEndEngine();
  5. }
  6. @Override
  7. public Tyre createTyre() {
  8. return new HighEndTyre();
  9. }
  10. @Override
  11. public Seat createSeat() {
  12. return new HighEndSeat();
  13. }
  14. }
  15. public class LowEndCarFactory implements CarFactory {
  16. @Override
  17. public Engine createEngine() {
  18. return new LowEndEngine();
  19. }
  20. @Override
  21. public Tyre createTyre() {
  22. return new LowEndTyre();
  23. }
  24. @Override
  25. public Seat createSeat() {
  26. return new LowEndSeat();
  27. }
  28. }

客户端调用:

  1. public class Client {
  2. public static void main(String[] args) {
  3. CarFactory cf = new HighEndCarFactory();
  4. Engine engine = cf.createEngine();
  5. Tyre tyre = cf.createTyre();
  6. Seat seat = cf.createSeat();
  7. }
  8. }

这种实现方式对应上文的内容:客户端在不必指定产品的具体类型(发动机、轮胎、座椅)的情况下,能够创建多个产品族的产品对象。当产品族中新增几个产品,只需创建产品类以及在对应的工厂类中添加对应的方法即可。

在使用设计模式时,很难遵循五大原则和一大法则。我们使用设计模式是为了让代码具有可复用性、可扩展性和灵活性,不能一味地守着这几个规定,从而限制自己对编程的想象和发挥。因此,需要使用怎样的设计模式还得根据项目的实际需求来衡量选择。