定义

抽象工厂模式（Abstract Factory Pattern）是工厂方法模式的进一步抽象，其英文原话"Provide an interface for creating families of related or dependent objects without specifying their concrete classes"。翻译为以下：
为创建一组相关或者是相互依赖的对象提供一个接口，而不需要指定它们的具体实现类。

使用场景

一个对象族有相同的约束时可以使用抽象工厂模式。以车厂生产汽车零部件为例，A、B两家车厂分别生产不同的轮胎、发动机、制动系统。虽然生产的零件不同，型号不同。但是根本上都有共同的约束，就是轮胎、发动机、制动系统。

代码实现

轮胎相关类：

public interface ITire {
    /**
     * 轮胎 
     */
    void tire();
}

public class NormalTire implements ITire{
    @Override
    public void tire() {
        System.out.println("普通轮胎");
    }
}

public class SUVTire implements ITire{
    @Override
    public void tire() {
        System.out.println("越野轮胎");
    }
}

发动机相关类：

public interface IEngine {
    /**
     *发动机 
     */
    void engine();
}

public class DomesticEngine implements IEngine{
    @Override
    public void engine() {
        System.out.println("国产发动机");
    }
}

public class ImportEngine implements IEngine{
    @Override
    public void engine() {
        System.out.println("进口发动机");
    }
}

制动系统相关类：

public interface IBrake {
    /**
     *制动系统 
     */
    void brake();
}

public class NormalBrake implements IBrake{
    @Override
    public void brake() {
        System.out.println("普通制动");
    }
}

public class SeniorBrake implements IBrake{
    @Override
    public void brake() {
        System.out.println("高级制动");
    }
}

抽象车厂类：

public abstract class CarFactory {
    /**
     * 生产轮胎
     * 
     * @return 轮胎
     * */
    public abstract ITire createTire();

    /**
     * 生产发动机
     * 
     * @return 发动机
     * */
    public abstract IEngine createEngine();

    /**
     * 生产制动系统
     * 
     * @return 制动系统
     * */
    public abstract IBrake createBrake();

}

A车厂：

public class AFactory extends CarFactory{

    @Override
    public ITire createTire() {
        return new NormalTire();
    }

    @Override
    public IEngine createEngine() {
        return new DomesticEngine();
    }

    @Override
    public IBrake createBrake() {
        return new NormalBrake();
    }
}

B车厂：

public class BFactory extends CarFactory{

    @Override
    public ITire createTire() {
        return new SUVTire();
    }

    @Override
    public IEngine createEngine() {
        return new ImportEngine();
    }

    @Override
    public IBrake createBrake() {
        return new SeniorBrake();
    }
}

客户端：

public class Client {
    public static void main(String[] args) {
        //A车厂
        CarFactory factoryA = new AFactory();
        factoryA.createTire().tire();
        factoryA.createEngine().engine();
        factoryA.createBrake().brake();
        System.out.println("---------------");
        //B车厂
        CarFactory factoryB = new BFactory();
        factoryB.createTire().tire();
        factoryB.createEngine().engine();
        factoryB.createBrake().brake();
    }
}

根据代码实现来理解抽象模式的定义：