抽象工厂模式

工厂方法模式中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机、计算机软件学院只培养计算机软件专业的学生等。
同种类称为同等级，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类） 的产品，如电脑配件包括cpu、内存、主板、硬盘等。
抽象工厂模式将考虑多等级产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族

一个产品族是同一个工厂生产的一系列产品，如：A厂生产的主板、内存、cpu就是一个产品族，一个产品等级是指一种产品，如A厂的cpu和B厂的cpu就是一个产品等级
每一个产品族中含有产品的数目，与产品等级结构的数目是相等的。
抽象工厂模式UML类图
上面所给出的三个不同的等级结构具有平行的结构。因此，如果采用工厂方法模式，就势必要使用三个独立的工厂等级结构来对付这三个产品等级结构。由于这三个产品等级结构的相似性，会导致三个平行的工厂等级结构。随着产品等级结构的数目的增加，工厂方法模式所给出的工厂等级结构的数目也会随之增加。
工厂方法模式

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。在工厂方法模式中有多个抽象工厂，每个抽象工厂有多个具体工厂，有多个抽象产品，每个抽象产品有多个具体产品，每个具体工厂负责一个具体产品的创建。当需要新加一类产品的时候，就需要在创建一个相关的抽象工厂、具体工厂实现类、产品抽象类、具体产品实现类。
那么，是否可以使用同一个工厂等级结构来对付这些相同或者极为相似的产品等级结构呢？当然可以的，而且这就是抽象工厂模式的好处。同一个工厂等级结构负责三个不同产品等级结构中的产品对象的创建。
抽象工厂模式

interface Cpu{
    void method();
}

interface Memory{
    void method();
}

interface MainBoard{
    void method();
}

interface Factory{
    Cpu createCpu();
    Memory createMemory();
    MainBoard createMainBoard();
}

class ACpu implements Cpu{
    @Override
    public void method() {
        System.out.println("ACpu");
    }
}

class BCpu implements Cpu{
    @Override
    public void method() {
        System.out.println("VCpu");
    }
}

class AMemory implements Memory{
    @Override
    public void method() {
        System.out.println("AMemory");
    }
}

class BMemory implements Memory{
    @Override
    public void method() {
        System.out.println("BMemory");
    }
}

class AMainBoard implements MainBoard{
    @Override
    public void method() {
        System.out.println("AMainBoard");
    }
}

class BMainBoard implements MainBoard{
    @Override
    public void method() {
        System.out.println("BMainBoard");
    }
}

class AFactory implements Factory{

    @Override
    public Cpu createCpu() {
        System.out.println("AFactory生产了ACpu");
        return new ACpu();
    }

    @Override
    public Memory createMemory() {
        System.out.println("AFactory生产了AMemory");
        return new AMemory();
    }

    @Override
    public MainBoard createMainBoard() {
        System.out.println("AFactory生产了AMainBoard");
        return new AMainBoard();
    }
}

class BFactory implements Factory{

    @Override
    public Cpu createCpu() {
        System.out.println("BFactory生产了BCpu");
        return new BCpu();
    }

    @Override
    public Memory createMemory() {
        System.out.println("AFactory生产了BMemory");
        return new BMemory();
    }

    @Override
    public MainBoard createMainBoard() {
        System.out.println("BFactory生产了BMainBoard");
        return new BMainBoard();
    }
}

public class AbstractFactory {
    public static void main(String[] args) {
        Factory factoryA = new AFactory();
        Factory factoryB = new BFactory();
        Cpu cpuA = factoryA.createCpu();
        factoryA.createMemory();
        factoryA.createMainBoard();
        System.out.println("-----------------");
        factoryB.createCpu();
        Memory memoryB = factoryB.createMemory();
        factoryB.createMainBoard();
        System.out.println("-----------------");
        cpuA.method();
        memoryB.method();
    }
}

运行结果：    
AFactory生产了ACpu
AFactory生产了AMemory
AFactory生产了AMainBoard
-----------------
BFactory生产了BCpu
AFactory生产了BMemory
BFactory生产了BMainBoard
-----------------
ACpu
BMemory

工厂方法模式与抽象工厂模式区别

工厂方法模式：

• 一个抽象产品类，可以派生出多个具体产品类。
• 一个抽象工厂类，可以派生出多个具体工厂类。
• 每个具体工厂类只能创建一个具体产品类的实例。 抽象工厂模式：
• 多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。
• 一个抽象工厂类，可以派生出多个具体工厂类。
• 每个具体工厂类可以创建多个具体产品类的实例。
  区别： 工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。
  工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。