接上文抽象工厂 模式模式讲解，本文主要从具体示例来复现该设计模式：

由上文可知，抽象工厂模式的UML图如下：

image.png

【1】情景假设：

假设现在有一个奥迪造车工厂，生产的车系有Q3,Q5,Q7三种不同型号但同属于Q系列的轿车，虽然同属于Q系列轿车，但三者车型的零部件差别还是很大，比如Q3和Q7对比，Q3使用的发动机是国产的，Q7使用的是原装进口，Q3使用的轮胎是普通轮胎，Q7使用的是全尺寸越野轮胎，Q3使用的是比较普通的制动系统，而Q7使用的是制动性能杠杠的制动系统。Q3和Q7对应的是一系列车，而发动机，轮胎，制动系统则对应的是一系列的零部件，两者是两种不同的产品类型，上文说过，抽象工厂的定义是为创建一组相关或者相互依赖的对象提供一个接口，而不需要指定它们的具体实现类。结合该情景，我们可以使用抽象工厂模式。

具体示例UML图：

image.png

1)首先,汽车工厂需要生产发动机，轮胎，制动系统这3种零部件。

抽象汽车工厂类：

package com.company.designModel.sample;/**
 * @ClassName CarFactory
 * @Description 抽象汽车工厂类
 * @Author lm
 * @Date 2018/9/14 0014 11:16
 * @Version 1.0
 **/public abstract class CarFactory {    /**
     * 生产轮胎
     * return 生产轮胎
     */
    public abstract ITire createTire();    /**
     * 生产发动机
     * return 发动机
     */
    public abstract IEngine createEngine();    /**
     * 生产制动系统
     * return 制动系统
     */
    public abstract IBrake createBrake();

}

2)其次,为每种零部件定义一个接口，并分别创建两个不同的实现类表示不同的零部件。

轮胎接口：

package com.company.designModel.sample;/**
 * 轮胎相关类
 */public interface ITire {    void tire();
}

轮胎接口实现类1：

package com.company.designModel.sample;/**
 * @ClassName NormalTire
 * @Description 普通轮胎类
 * @Author lm
 * @Date 2018/9/14 0014 11:23
 * @Version 1.0
 **/public class NormalTire implements ITire{    @Override
    public void tire() {
        System.out.println("normal tire");
    }
}

轮胎接口实现类2：

package com.company.designModel.sample;/**
 * @ClassName SUVTire
 * @Description SUV轮胎类
 * @Author lm
 * @Date 2018/9/14 0014 11:23
 * @Version 1.0
 **/public class SUVTire implements ITire{    @Override
    public void tire() {
        System.out.println("SUV tire");
    }
}

发动机接口：

package com.company.designModel.sample;/**
 * 发动机相关类
 */public interface IEngine {    void engine();
}

发动机接口实现类1：

package com.company.designModel.sample;/**
 * @ClassName DomesticEngine
 * @Description 国产发动机
 * @Author lm
 * @Date 2018/9/14 0014 11:23
 * @Version 1.0
 **/public class DomesticEngine implements IEngine{    @Override
    public void engine() {
        System.out.println("domestic engine");
    }
}

发动机接口实现类2：

package com.company.designModel.sample;/**
 * @ClassName ImportEngine
 * @Description 进口发动机
 * @Author lm
 * @Date 2018/9/14 0014 11:23
 * @Version 1.0
 **/public class ImportEngine implements IEngine{    @Override
    public void engine() {
        System.out.println("Import engine");
    }
}

制动系统接口：

package com.company.designModel.sample;/**
 * 制动系统相关类
 */public interface IBrake {    void brake();
}

制动系统接口实现类1：

package com.company.designModel.sample;/**
 * @ClassName NormalBrake
 * @Description 普通发动机
 * @Author lm
 * @Date 2018/9/14 0014 11:27
 * @Version 1.0
 **/public class NormalBrake implements IBrake{    @Override
    public void brake() {
        System.out.println("Normal Brake");
    }
}

制动系统接口实现类2：

package com.company.designModel.sample;/**
 * @ClassName SeniorBrake
 * @Description 高级发动机
 * @Author lm
 * @Date 2018/9/14 0014 11:27
 * @Version 1.0
 **/public class SeniorBrake implements IBrake{    @Override
    public void brake() {
        System.out.println("Senior Brake");
    }
}

3)然后,对于具体生产工厂Q3，Q7，生产的零部件均不相同。

具体生产工厂Q3Factory：

package com.company.designModel.sample;/**
 * @ClassName Q3Factory
 * @Description 具体生产工厂类Q3
 * @Author lm
 * @Date 2018/9/14 0014 11:32
 * @Version 1.0
 **/public class Q3Factory extends CarFactory {    @Override
    public ITire createTire() {        return new NormalTire();
    }    @Override
    public IEngine createEngine() {        return new DomesticEngine();
    }    @Override
    public IBrake createBrake() {        return new NormalBrake();
    }
}

具体生产工厂Q7Factory：

package com.company.designModel.sample;/**
 * @ClassName Q7Factory
 * @Description 具体生产工厂类Q7
 * @Author lm
 * @Date 2018/9/14 0014 11:33
 * @Version 1.0
 **/public class Q7Factory extends CarFactory {    @Override
    public ITire createTire() {        return new SUVTire();
    }    @Override
    public IEngine createEngine() {        return new ImportEngine();
    }    @Override
    public IBrake createBrake() {        return new SeniorBrake();
    }
}

4)最后,在客户端的具体实现。

客户端：

package com.company.designModel.sample;/**
 * @ClassName Client
 * @Description 客户端具体实现
 * @Author lm
 * @Date 2018/9/14 0014 11:34
 * @Version 1.0
 **/public class Client {    public static void main(String[] args) {        //构造一个生产Q3的工厂
        CarFactory Q3Factory = new Q3Factory();
        Q3Factory.createTire().tire();
        Q3Factory.createEngine().engine();
        Q3Factory.createBrake().brake();

        System.out.println("===================");        //构造一个生产Q7的工厂
        CarFactory Q7Factory = new Q7Factory();
        Q7Factory.createTire().tire();
        Q7Factory.createEngine().engine();
        Q7Factory.createBrake().brake();

    }
}

输出结果：

normal tire
domestic engine
Normal Brake
===================
SUV tire
Import engine
Senior Brake

【2】示例小结：

示例中我们模拟了只有具体工厂类，而如果此时需要增加一个Q5Factory类，，那么需要增加对应Q5Factory类的轮胎，发动机，制动系统类，可以看出，随着具体工厂的增加，类的数目会成倍增加，因此在实际工作中需要控制具体工厂的数目，保持设计模式的简洁性。

作者：Ferrari1001
链接：https://www.jianshu.com/p/44f4d3d467b8