抽象工厂设计模式

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