设计模式之抽象工厂模式

抽象工厂

抽象工厂模式是提供一个抽象的接口，同于创建相关或依赖对象的产品，而不需要明确指定具体的类。抽象工厂模式是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

抽象工厂和工厂模式的区别是抽象工厂可以生成多个产品，比如造车工厂CarFactory还可以生产轮胎、发动机等一系列产品；而工厂模式只能够生产一个产品。

首先创建公共的车接口

public interface Car {
    public void run();
}

然后创建两个实现类

public class SUV implements Car{
    @Override
    public void run() {
        System.out.println("SUV 越野车");
    }
}

public class Tractor implements Car{
    @Override
    public void run() {
        System.out.println("Tractor 拖拉机");
    }
}

创建轮胎接口

public interface Tire {
    public void roll();
}

为轮胎接口创建实现类

public class ATire implements Tire{
    @Override
    public void roll() {
        System.out.println("ATire 全地形轮胎");
    }
}

public class HTire implements Tire{
    @Override
    public void roll() {
        System.out.println("HTire 公路轮胎");
    }
}

创建抽象工厂类

public abstract class AbstractFactory {
    public abstract Car getCar(String catType);
    public abstract Tire getTire(String tireType);
}

创建扩展了抽象工厂的工厂类

public class CarFactory extends AbstractFactory {
    @Override
    public Car getCar(String carType){
        if (carType == null){
            return null;
        }
        if (carType.equals("SUV")){
            return new SUV();
        } else if (carType.equals("Tractor")) {
            return new Tractor();
        }
        return null;
    }

    @Override
    public Tire getTire(String tireType) {
        return null;
    }
}

public class TireFactory extends AbstractFactory{
    @Override
    public Car getCar(String catType) {
        return null;
    }

    @Override
    public Tire getTire(String tireType) {
        if (tireType == null){
            return null;
        }
        if (tireType.equals("HTire")){
            return new HTire();
        } else if (tireType.equals("ATire")) {
            return new ATire();
        }
        return null;
    }
}

创建一个工厂生成器，通过传递信息来获取不同的工厂

public class FactoryProducer {
    public static AbstractFactory getFactory(String factoryType){
        if(factoryType.equalsIgnoreCase("Car")){
            return new CarFactory();
        } else if(factoryType.equalsIgnoreCase("Tire")){
            return new TireFactory();
        }
        return null;
    }
}

通过工厂生成器获取对应工厂，然后再通过工厂获取对象

public static void main(String[] args) {
    //获取工厂
    AbstractFactory carFactory = FactoryProducer.getFactory("Car");
    AbstractFactory tireFactory = FactoryProducer.getFactory("Tire");

    Car car1 = carFactory.getCar("SUV");
    car1.run();
    Car car2 = carFactory.getCar("Tractor");
    car2.run();
    Tire tire1 = tireFactory.getTire("HTire");
    tire1.roll();
    Tire tire2 = tireFactory.getTire("ATire");
    tire2.roll();
}

输出结果：

SUV 越野车
Tractor 拖拉机
HTire 公路轮胎
ATire 全地形轮胎

总结：

• 抽象工厂模式优点：
  • 抽象工厂可以创建一系列产品，并且保证只能使用同一个产品系列的产品
• 抽象工厂模式缺点：
  • 如果要新增产品，那么要修改多个工厂类，扩展困难