03 抽象工厂模式（Abstract Factory Desig

工厂的工厂，不再需要if-else或者switch 。

抽象工厂设计模式(Abstract Factory Design Pattern)是创建型模式之一。抽象工厂设计模式类似于工厂设计模式（Factory Design Pattern），但是它更像工厂的工厂。

Abstract Factory

如果你比较熟悉工厂设计模式（Factory Design Pattern），你会注意到有一个单独的工厂类，这个类负责根据提供参数的不同实例化并返回不同的实现类，这个是用if-else或者switch语句实现的。

在抽象工厂模式中，我们摆脱了if-else块并为每个子类设置了工厂类。 然后抽象工厂类将根据输入的工厂类返回子类。 现在你可能还是比较困惑，但一旦你看到实现就很容易理解和理解工厂和抽象工厂模式之间的微小差异。

Abstract Factory Design Pattern Super Class and Subclasses

定义超类和子类

Computer.java

public abstract class Computer {

    public abstract String getRAM();
    public abstract String getHDD();
    public abstract String getCPU();

    @Override
    public String toString(){
        return "RAM= "+this.getRAM()+", HDD="+this.getHDD()+", CPU="+this.getCPU();
    }
}

PC.java

public class PC extends Computer {

    private String ram;
    private String hdd;
    private String cpu;

    public PC(String ram, String hdd, String cpu){
        this.ram=ram;
        this.hdd=hdd;
        this.cpu=cpu;
    }
    @Override
    public String getRAM() {
        return this.ram;
    }

    @Override
    public String getHDD() {
        return this.hdd;
    }

    @Override
    public String getCPU() {
        return this.cpu;
    }
}

Server.java

public class Server extends Computer {

    private String ram;
    private String hdd;
    private String cpu;

    public Server(String ram, String hdd, String cpu){
        this.ram=ram;
        this.hdd=hdd;
        this.cpu=cpu;
    }
    @Override
    public String getRAM() {
        return this.ram;
    }

    @Override
    public String getHDD() {
        return this.hdd;
    }

    @Override
    public String getCPU() {
        return this.cpu;
    }
}

Factory Class for Each subclass

为每个子类建立工厂类

首先我们定义一个抽象工厂接口或者抽象工厂类ComputerAbstractFactory.java

public interface ComputerAbstractFactory {

    public Computer createComputer();

}

注意createComputer()方法正在返回Computer的实例。 现在我们的工厂类将实现这个接口并返回它们各自的子类。

public class PCFactory implements ComputerAbstractFactory {

    private String ram;
    private String hdd;
    private String cpu;

    public PCFactory(String ram, String hdd, String cpu){
        this.ram=ram;
        this.hdd=hdd;
        this.cpu=cpu;
    }
    @Override
    public Computer createComputer() {
        return new PC(ram,hdd,cpu);
    }

}

public class ServerFactory implements ComputerAbstractFactory {

    private String ram;
    private String hdd;
    private String cpu;

    public ServerFactory(String ram, String hdd, String cpu){
        this.ram=ram;
        this.hdd=hdd;
        this.cpu=cpu;
    }

    @Override
    public Computer createComputer() {
        return new Server(ram,hdd,cpu);
    }

}

现在我们将创建一个消费者类，它将为client类创建computer实现类提供入口点。

public class ComputerFactory {

    public static Computer getComputer(ComputerAbstractFactory factory){
        return factory.createComputer();
    }
}

注意它是一个简单的类，getComputer方法接受ComputerAbstractFactory参数并返回computer的实例。

让我们写一个简单的测试方法，看看如何使用抽象工厂来获取子类的实例。

public class TestDesignPatterns {

    public static void main(String[] args) {
        testAbstractFactory();
    }

    private static void testAbstractFactory() {
        Computer pc = ComputerFactory.getComputer(new PCFactory("2 GB","500 GB","2.4 GHz"));
        Computer server = ComputerFactory.getComputer(new ServerFactory("16 GB","1 TB","2.9 GHz"));
        System.out.println("AbstractFactory PC Config::"+pc);
        System.out.println("AbstractFactory Server Config::"+server);
    }
}

Abstract Factory Design Pattern Banefits

抽象工厂设计模式的好处：

• 提供一种基于接口的编程而不是具体实现。
• 抽象工厂设计模式是“工厂的工厂” 而且可以很容易的拓展以容纳更多的产品, 例如我们可以添加另一个子类Laptop和一个工厂类LaptopFactory.
• 抽象工厂模式更加健壮，避免了工厂模式的条件逻辑。

总结

工厂模式和抽象工厂模式的区别是，当你需要添加一个实现的时候，例如新增Laptop子类

在工厂模式下的做法：新增Laptop类，并在工厂类中添加if-else条件判断。（修改工厂类）

在抽象工厂模式中的做法：新增Laptop类和其工厂类LaptopFactory即可（无需修改原有的任何工厂类）