抽象工厂模式

抽象工厂模式 一、抽象工厂模式的解释

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其它的工厂的工厂，该超级工厂又称为其它工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们的类。

使用场景：
1.客户端（应用层）不依赖与产品类示例如何被创建、实现等细节。
2.强调一系列相关的产品对象（数据同一产品族）一起使用创建对象需要大量的重复代码。
3.提供一个产品类的库，所有的产品以同样的接口出现，使得客户端不依赖于具体实现。

二、抽象工厂模式的优点和缺点

优点：

1.具体产品在应用层的代码隔离，无需关系创建的细节
2.将一个系列的产品统一到一起创建

缺点：

1.规定了所有可能被创建的产品集合，产品族中扩展新的产品困难；
2.增加了系统的抽象性和理解难度

三、模式的结构与实现

• 抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法 new Product()，可以创建多个不同等级的产品。
• 具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
• 抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
• 具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

具体实现：
首先先看一下这个抽象工厂的UML图

下面是该抽象工厂的具体实现：

抽象工厂（Abstract Factory）：

//抽象工厂
public interface ProductFactory {
    GasolineCarProduct createGasolineCar();

    ElectricCarProduct createElectricCar();
}

抽象产品（Product）：

//抽象产品
public interface GasolineCarProduct {
    void start();
    void run();
    void park();
    void fuelup();
}

public interface ElectricCarProduct {
    void start();
    void run();
    void park();
    void charge();
}

具体工厂（Concrete Factory）：

//具体工厂
public class AudiFactory implements ProductFactory{
    @Override
    public GasolineCarProduct createGasolineCar() {
        return new AudiGasolineCar();
    }
    @Override
    public ElectricCarProduct createElectricCar() {
        return new AudiElectricCar();
    }
}

//具体工厂
public class BMWFactory implements ProductFactory{
    @Override
    public GasolineCarProduct createGasolineCar() {
        return new BMWGasolineCar();
    }
    @Override
    public ElectricCarProduct createElectricCar() {
        return new BMWElectricCar();
    }
}

//具体工厂
public class BenzFactory implements ProductFactory{
    @Override
    public GasolineCarProduct createGasolineCar() {
        return new BenzGasolineCar();
    }
    @Override
    public ElectricCarProduct createElectricCar() {
        return new BenzElectricCar();
    }
}

具体产品（ConcreteProduct）：

//具体产品
public class AudiGasolineCar implements GasolineCarProduct {
    @Override
    public void start() {
        System.out.println("奥迪汽车启动");
    }

    @Override
    public void run() {
        System.out.println("奥迪汽车开车");
    }

    @Override
    public void park() {
        System.out.println("奥迪汽车停车");
    }

    @Override
    public void fuelup() {
        System.out.println("奥迪汽车加油");
    }
}

//具体产品
public class BenzElectricCar implements ElectricCarProduct {
    @Override
    public void start() {
        System.out.println("奔驰电动车启动");
    }

    @Override
    public void run() {
        System.out.println("奔驰电动车开车");
    }

    @Override
    public void park() {
        System.out.println("奔驰电动车停车");
    }

    @Override
    public void charge() {
        System.out.println("奔驰电动车充电");
    }
}

//具体产品
public class BenzGasolineCar implements GasolineCarProduct {
    @Override
    public void start() {
        System.out.println("奔驰汽车启动");
    }

    @Override
    public void run() {
        System.out.println("奔驰汽车开车");
    }

    @Override
    public void park() {
        System.out.println("奔驰汽车停车");
    }

    @Override
    public void fuelup() {
        System.out.println("奔驰汽车加油");
    }
}

//具体产品
public class BMWElectricCar implements ElectricCarProduct {
    @Override
    public void start() {
        System.out.println("宝马电动车启动");
    }

    @Override
    public void run() {
        System.out.println("宝马电动车开车");
    }

    @Override
    public void park() {
        System.out.println("宝马电动车停车");
    }

    @Override
    public void charge() {
        System.out.println("宝马电动车充电");
    }
}

//具体产品
public class BMWGasolineCar implements GasolineCarProduct {
    @Override
    public void start() {
        System.out.println("宝马汽车启动");
    }

    @Override
    public void run() {
        System.out.println("宝马汽车开车");
    }

    @Override
    public void park() {
        System.out.println("宝马汽车停车");
    }

    @Override
    public void fuelup() {
        System.out.println("宝马汽车加油");
    }
}

//具体产品
public class AudiElectricCar implements ElectricCarProduct {
    @Override
    public void start() {
        System.out.println("奥迪电动车启动");
    }

    @Override
    public void run() {
        System.out.println("奥迪电动车开车");
    }

    @Override
    public void park() {
        System.out.println("奥迪电动车停车");
    }

    @Override
    public void charge() {
        System.out.println("奥迪电动车充电");
    }
}

测试：

public class TestFactory {
    public static void main(String[] args) {
        BenzFactory benzFactory = new BenzFactory();
        ElectricCarProduct benzElectricCar = benzFactory.createElectricCar();
        benzElectricCar.start();
        benzElectricCar.run();
        benzElectricCar.park();
        benzElectricCar.charge();

        System.out.println("---------------------------------------");

        AudiFactory audiFactory = new AudiFactory();
        GasolineCarProduct audiGasolineCar = audiFactory.createGasolineCar();
        audiGasolineCar.start();
        audiGasolineCar.run();
        audiGasolineCar.park();
        audiGasolineCar.fuelup();
    }
}

结果：

奔驰电动车开车
奔驰电动车停车
奔驰电动车充电
---------------------------------------
奥迪汽车启动
奥迪汽车开车
奥迪汽车停车
奥迪汽车加油

总结：

1. 抽象工厂模式是为用户端提供一个创建一系列相关或相互依赖对象的接口,用户端无需知道他们需要的产品怎么做的，它只需要调用接口方法就行。
2. 抽象工厂模式，不仅可以实现多个接口，而且每个工厂也可以生产多种产品类，和工厂方法模式一样，抽象工厂模式同样实现了开发封闭原则。