创建型模式之抽象工厂模式（Abstract Factory）- 工厂方法模式（Factory Method）

在 简单工厂模式中有一个工厂类，一般都是单例的，通过静态方法创建具体产品，在这个类里有个生产具体产品的方法，他的逻辑是依据指定的参数（比如具体产品相关的名字、类型等）生产对应的产品，这种模式对开闭原则支持不够，即扩展性不好，因为如果要新增一种产品那么还要修改原先工厂的生产方法，这不符合开闭原则，而且有时候我们没有原先工厂类的源码，无法修改，这样的软件系统扩展性不好，如何解决？

抽象工厂模式很好地解决了这个问题，在抽象工厂模式中，不再传递具体参数生成产品，因为这些具体参数是与具体产品相关的，耦合性太强，也因此失去了这个点上的扩展性，
取而代之的是传递一个生产具体对象的具体工厂，这有就不必了解具体产品细节，这些细节都被封装到具体工厂里，通过工厂可以获取到想要的产品，然后对具体工厂进行抽象，这有就不依赖具体工厂，也就是这一层的工厂抽象将具体产品的生产彻底地分离出去，高度送耦合，进而可扩展。

抽象进而分层，分层后而扩展，这岂不是一种经典设计思想！

抽象工厂模式应用非常广泛，在JDK源码及Java相关框架如Spring、Hibernate、Kryo等随处可见。

抽象工厂模式经常被用来完成一系列有关系的对象（产品族对象）的创建过程。当系统中涉及到多个产品族而且只有同一产品族中的产品才能协作时，抽象工厂模式可以非常好的胜任此工作。比如UI系统，包括按钮、文本框等很多UI组件，各操作系统平台都有自己的一套完整实现，然而他们不能互相使用，如Windows的按钮无法和Linux的文本框在一起使用，他们属于不同的产品族。另外，说明一下，当产品族中只有一种产品时候，这种模式又降级为工厂方法模式，有人这么叫，名字不重要，我们需要掌握的是其思想，掌握了思想，如何使用就看自己的创造力了！

场景一：假设一台Computer的工作需要CPU和RAM两种组件，Intel和Amd两个厂商都可以生产这两个组件，并且假设他们的组件互不兼容。

使用抽象工厂模式设计如下：

示例代码：

public interface CPU {
    void cpuWork();
}

public interface RAM {
    void ramWork();
}

public interface HardwareFirm {
    CPU createCPU();
    RAM createRAM();
}

public class Computer {
    private CPU cpu;
    private RAM ram;

    public Computer(CPU cpu, RAM ram) {
        this.cpu = cpu;
        this.ram = ram;
    }

    public void work() {
        cpu.cpuWork();
        ram.ramWork();
        System.out.println("Computer is working ...");
    }
}

public class Intel implements HardwareFirm {
    @Override
    public CPU createCPU() {
        return new IntelCPU();
    }

    @Override
    public RAM createRAM() {
        return new IntelRAM();
    }
}
class IntelCPU implements CPU {

    @Override
    public void cpuWork() {
        System.out.println("IntelCPU is working ...");
    }
}
class IntelRAM implements RAM {
    @Override
    public void ramWork() {
        System.out.println("IntelRAM is working ...");
    }
}

public class Amd implements HardwareFirm {
    @Override
    public CPU createCPU() {
        return new AmdCPU();
    }

    @Override
    public RAM createRAM() {
        return new AmdRAM();
    }
}

class AmdCPU implements CPU {

    @Override
    public void cpuWork() {
        System.out.println("AmdCPU is working ...");
    }
}

class AmdRAM implements RAM {

    @Override
    public void ramWork() {
        System.out.println("AmdRAM is working ...");
    }
}

public class Test {
    public static void main(String[] args) {
//        HardwareFirm hardwareFirm = new Intel();
        HardwareFirm hardwareFirm = new Amd();
        Computer computer = new Computer(hardwareFirm.createCPU(), hardwareFirm.createRAM());
        computer.work();
    }
}

场景二：假设一台Computer的工作需要CPU组件，Intel和Amd两个厂商都可以生产这个组件。

使用降级后的抽象工厂模式（即工厂方法模式）设计如下：

示例代码：

public interface CPU {
    void cpuWork();
}

public interface CPUFirm {
    CPU createCPU();
}

public class Computer {
    private CPU cpu;
    public Computer(CPU cpu) {
        this.cpu = cpu;
    }
    public void work() {
        cpu.cpuWork();
        System.out.println("Computer is working ...");
    }
}

public class Intel implements CPUFirm {
    @Override
    public CPU createCPU() {
        return new IntelCPU();
    }
}
class IntelCPU implements CPU {

    @Override
    public void cpuWork() {
        System.out.println("IntelCPU is working ...");
    }
}

public class Amd implements CPUFirm {
    @Override
    public CPU createCPU() {
        return new AmdCPU();
    }
}
class AmdCPU implements CPU {

    @Override
    public void cpuWork() {
        System.out.println("AmdCPU is working ...");
    }
}

public class Test {
    public static void main(String[] args) {
//        CPUFirm cpuFirm = new Intel();
        CPUFirm cpuFirm = new Amd();
        Computer computer = new Computer(cpuFirm.createCPU());
        computer.work();
    }
}