抽象工厂模式的Java实现

抽象工厂模式

• 抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂，因此又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
• 在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类，每个生成的工厂都能按照工厂模式提供对象。
• 抽象工厂用于生产产品族，不可以增加单个产品，但可以增加产品族。

介绍

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

主要解决：主要解决接口选择的问题。

何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

如何解决：在一个产品族里面，定义多个产品。

关键代码：在一个工厂里聚合多个同类产品。

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

使用场景：

• QQ 换皮肤，一整套一起换
• 生成不同操作系统的程序

注意事项：产品族难扩展，产品等级易扩展。

实现：

步骤1：创建汽车各组件（引擎、座位、轮胎）的抽象接口和相应的具体实现类

package com.ly.abstractFactory;

public interface Engine {
    void start();
    void run();
}

class LuxuryEngine implements Engine {
    @Override
    public void start() {
        System.out.println("LuxuryEngine --> start quickly");
    }

    @Override
    public void run() {
        System.out.println("转的快！");
    }
}


class LowEngine implements Engine {
    @Override
    public void start() {
        System.out.println("LowEngine --> start slowly");
    }

    @Override
    public void run() {
        System.out.println("转的慢！");
    }
}

package com.ly.abstractFactory;

public interface Seat {
    void massage();
}

class LuxurySeat implements Seat {
    @Override
    public void massage() {
        System.out.println("have the function of massage");
    }
}

class LowSeat implements Seat {
    @Override
    public void massage() {
        System.out.println("no function of massage");
    }
}

package com.ly.abstractFactory;

public interface Tyre {
    void revolve();
}

class LuxuryTyre implements Tyre {
    @Override
    public void revolve() {
        System.out.println("耐磨损，防打滑");
    }
}

class LowTyre implements Tyre {
    @Override
    public void revolve() {
        System.out.println("易磨损，易打滑");
    }
}

步骤2：创建一个抽象的汽车工厂

package com.ly.abstractFactory;

public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}

步骤3：创建汽车工厂的具体工厂类型

package com.ly.abstractFactory;

public class LuxuryCarFactory implements CarFactory{
    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}

package com.ly.abstractFactory;

public class LowCarFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }
}

 步骤4：客户端测试

package com.ly.abstractFactory;

/**
 * 1、测试抽象工厂
 * liyang 2020-07-12
 * 2、抽象工厂用于生产产品族
 * 3、不可以增加单个产品，但可以增加产品族
 *      比如这里的高端产品线（族）包括引擎、座椅和轮胎
 * 4、工厂模式的主要应用场景（很多情况下会和其他模式配合，比如单例模式）
 *      jdk中Calender的getInstance方法
 *      JDBC中Connection对象的获取
 *      Hibernate中SessionFactory创建Session
 *      Spring中IOC容器创建管理bean对象
 *      XML解析时的DocumentBuilderFactory创建解析器对象
 *      反射中Class对象的newInstance()
 */

public class Client {
    public static void main(String[] args) {
        //开始创建高端产品
        System.out.println("开始创建高端产品线产品");
        //创建抽象工厂的具体实现类工厂对象
        CarFactory luxuryCarFactory = new LuxuryCarFactory();
        //通过具体实现类工厂对象中的相应方法创建该工厂的相应产品engine
        Engine luxuryEngine = luxuryCarFactory.createEngine();
        //被创建产品具有的方法
        luxuryEngine.start();
        luxuryEngine.run();
        //通过具体实现类工厂对象中的相应方法创建该工厂的相应产品seat
        Seat luxurySeat = luxuryCarFactory.createSeat();
        //被创建产品具有的方法
        luxurySeat.massage();
        //通过具体实现类工厂对象中的相应方法创建该工厂的相应产品tyre
        Tyre luxuryTyre = luxuryCarFactory.createTyre();
        //被创建产品具有的方法
        luxuryTyre.revolve();
        //创建高端产品线结束
        System.out.println("结束高端产品线");

        //清晰起见，间隔一行
        System.out.println();

        //开始创建低端产品
        System.out.println("开始创建低端产品线产品");
        //创建抽象工厂的具体实现类工厂对象
        CarFactory lowCarFactory = new LowCarFactory();
        //通过具体实现类工厂对象中的相应方法创建该工厂的相应产品engine
        Engine lowEngine = lowCarFactory.createEngine();
        //被创建产品具有的方法
        lowEngine.start();
        lowEngine.run();
        //通过具体实现类工厂对象中的相应方法创建该工厂的相应产品seat
        Seat lowSeat = lowCarFactory.createSeat();
        //被创建产品具有的方法
        lowSeat.massage();
        //通过具体实现类工厂对象中的相应方法创建该工厂的相应产品tyre
        Tyre lowTyre = lowCarFactory.createTyre();
        //被创建产品具有的方法
        lowTyre.revolve();
        //创建低端产品线结束
        System.out.println("结束低端产品线");
    }
}

结果：

开始创建高端产品线产品
LuxuryEngine --> start quickly
转的快！
have the function of massage
耐磨损，防打滑
结束高端产品线

开始创建低端产品线产品
LowEngine --> start slowly
转的慢！
no function of massage
易磨损，易打滑
结束低端产品线

Process finished with exit code 0

工厂模式要点：

• 简单工厂模式：又叫静态工厂模式，虽然某种程度不符合设计原则，但实际使用最多
• 工厂方法模式：不修改已有类的情况下，通过增加新的工厂类实现扩展
• 抽象工厂模式：不可以增加产品，可以增加产品族

参考资料：

https://www.runoob/design-pattern/abstract-factory-pattern.html