抽象工厂设计模式

抽象工厂设计模式

1. 抽象工厂设计模式：提供一个用于创建相关对象或相互依赖对象的接口，无须指定对象的具体类

2. 抽象工厂模式UML图

   • 抽象工厂（AbstractFactory）：声明一个用于完成抽象产品对象创建操作的接口
   • 具体工厂（ConcreteFactory）：实现创建具体产品对象的操作
   • 抽象产品（AbstractProduct）：声明一个用于一类产品对象的接口
   • 具体产品（ConcreteProduct）：定义由相应的具体工厂来创建的产品对象
   • 客户端（Client）：使用由抽象工厂和抽象产品类声明的唯一接口
     

3. 示例：

   /**
    * @author xiao儿
    * @date 2019/8/29 20:59
    * @Description Parts
    */
   public class Parts {
       public String specification;
   
       public Parts(String specification) {
           this.specification = specification;
       }
   
       public String getSpecification() {
           return specification;
       }
   }
   
   /**
    * @author xiao儿
    * @date 2019/8/29 20:58
    * @Description Car
    */
   public abstract class Car {
       public abstract Parts getWheels();
       public abstract Parts getMirrors();
       public abstract Parts getEngine();
       public abstract Parts getBody();
   }
   
   /**
    * @author xiao儿
    * @date 2019/8/29 21:04
    * @Description BenQ
    */
   public class BenQ extends Car {
       @Override
       public Parts getWheels() {
           return new Parts("BenQ Wheels");
       }
   
       @Override
       public Parts getMirrors() {
           return new Parts("BenQ Mirrors");
       }
   
       @Override
       public Parts getEngine() {
           return new Parts("BenQ Engine");
       }
   
       @Override
       public Parts getBody() {
           return new Parts("BenQ Body");
       }
   }
   
   /**
    * @author xiao儿
    * @date 2019/8/29 21:06
    * @Description BMW
    */
   public class BMW extends Car {
       @Override
       public Parts getWheels() {
           return new Parts("BMW Wheels");
       }
   
       @Override
       public Parts getMirrors() {
           return new Parts("BMW Mirrors");
       }
   
       @Override
       public Parts getEngine() {
           return new Parts("BMW Engine");
       }
   
       @Override
       public Parts getBody() {
           return new Parts("BMW Body");
       }
   }
   
   /**
    * @author xiao儿
    * @date 2019/8/29 21:08
    * @Description GeneralMotors
    */
   public class GeneralMotors extends Car {
       @Override
       public Parts getWheels() {
           return new Parts("GeneralMotors Wheels");
       }
   
       @Override
       public Parts getMirrors() {
           return new Parts("GeneralMotors Mirrors");
       }
   
       @Override
       public Parts getEngine() {
           return new Parts("GeneralMotors Engine");
       }
   
       @Override
       public Parts getBody() {
           return new Parts("GeneralMotors Body");
       }
   }
   
   /**
    * @author xiao儿
    * @date 2019/8/29 21:09
    * @Description CarType
    */
   public class CarType {
       private Car car;
   
       public static void main(String[] args) {
           CarType type = new CarType();
           Car car = type.getCar("BMW");
           System.out.println("Wheels：" + car.getWheels().getSpecification());
           System.out.println("Mirrors：" + car.getMirrors().getSpecification());
           System.out.println("Engine：" + car.getEngine().getSpecification());
           System.out.println("Bady：" + car.getBody().getSpecification());
       }
   
       public Car getCar(String carType) {
           if ("BenQ".equals(carType)) {
               car = new BenQ();
           } else if ("BMW".equals(carType)) {
               car = new BMW();
           } else if ("GeneralMotors".equals(carType)) {
               car = new GeneralMotors();
           }
           return car;
       }
   }
   

4. 抽象工厂模式应用场景

   • 它屏蔽了这些具体类的创建方法。实际应用的类名称不需要再让客户端（将客户端与集体类解耦）知道。由于具体类是屏蔽的，因此我们可以在不同的工厂（实现方法）之间进行切换