欢迎使用Java示例中的抽象工厂设计模式。抽象工厂设计模式是创意模式的一种。抽象工厂模式几乎类似于Factory Pattern ]，只是它更像工厂的工厂。

抽象工厂

如果您熟悉java**](/community/tutorials/factory-design-pattern-in-java)，中的[** 工厂设计模式]，您会注意到我们只有一个工厂类。该工厂类根据提供的输入返回不同的子类，工厂类使用if-Else或Switch语句来实现这一点。在抽象工厂模式中，我们去掉了If-Else块，每个子类都有一个工厂类。然后是一个抽象工厂类，它将返回基于输入工厂类的子类。乍一看，这似乎令人困惑，但一旦您看到其实现，就很容易掌握和理解Factory和Abstract Factory模式之间的细微差别。像我们的工厂模式POST一样，我们将使用相同的超类和子类。

抽象工厂设计模式父类和子类

[[computer.java]]

 1package com.journaldev.design.model;
 2
 3public abstract class Computer {
 4
 5    public abstract String getRAM();
 6    public abstract String getHDD();
 7    public abstract String getCPU();
 8
 9    @Override
10    public String toString(){
11        return "RAM= "+this.getRAM()+", HDD="+this.getHDD()+", CPU="+this.getCPU();
12    }
13}

从另一方面来说，就是‘PC.java’。

 1package com.journaldev.design.model;
 2
 3public class PC extends Computer {
 4
 5    private String ram;
 6    private String hdd;
 7    private String cpu;
 8
 9    public PC(String ram, String hdd, String cpu){
10        this.ram=ram;
11        this.hdd=hdd;
12        this.cpu=cpu;
13    }
14    @Override
15    public String getRAM() {
16        return this.ram;
17    }
18
19    @Override
20    public String getHDD() {
21        return this.hdd;
22    }
23
24    @Override
25    public String getCPU() {
26        return this.cpu;
27    }
28
29}

Server.java

 1package com.journaldev.design.model;
 2
 3public class Server extends Computer {
 4
 5    private String ram;
 6    private String hdd;
 7    private String cpu;
 8
 9    public Server(String ram, String hdd, String cpu){
10        this.ram=ram;
11        this.hdd=hdd;
12        this.cpu=cpu;
13    }
14    @Override
15    public String getRAM() {
16        return this.ram;
17    }
18
19    @Override
20    public String getHDD() {
21        return this.hdd;
22    }
23
24    @Override
25    public String getCPU() {
26        return this.cpu;
27    }
28
29}

每个子类的工厂类

首先，我们需要创建抽象工厂接口或抽象class .ComputerAbstractFactory.java

1package com.journaldev.design.abstractfactory;
2
3import com.journaldev.design.model.Computer;
4
5public interface ComputerAbstractFactory {
6
7    public Computer createComputer();
8
9}

注意，createComputer()方法返回的是超类Computer的实例。现在，我们的工厂类将实现该接口并返回其各自的子类。PCFactory.java

 1package com.journaldev.design.abstractfactory;
 2
 3import com.journaldev.design.model.Computer;
 4import com.journaldev.design.model.PC;
 5
 6public class PCFactory implements ComputerAbstractFactory {
 7
 8    private String ram;
 9    private String hdd;
10    private String cpu;
11    
12    public PCFactory(String ram, String hdd, String cpu){
13    	this.ram=ram;
14    	this.hdd=hdd;
15    	this.cpu=cpu;
16    }
17    @Override
18    public Computer createComputer() {
19    	return new PC(ram,hdd,cpu);
20    }
21
22}

类似地，我们将为Server子类创建一个工厂类。ServerFactory.java

 1package com.journaldev.design.abstractfactory;
 2
 3import com.journaldev.design.model.Computer;
 4import com.journaldev.design.model.Server;
 5
 6public class ServerFactory implements ComputerAbstractFactory {
 7
 8    private String ram;
 9    private String hdd;
10    private String cpu;
11    
12    public ServerFactory(String ram, String hdd, String cpu){
13    	this.ram=ram;
14    	this.hdd=hdd;
15    	this.cpu=cpu;
16    }
17    
18    @Override
19    public Computer createComputer() {
20    	return new Server(ram,hdd,cpu);
21    }
22
23}

现在，我们将创建一个Consumer类，它将为客户端类创建子类提供入口点。ComputerFactory.java

 1package com.journaldev.design.abstractfactory;
 2
 3import com.journaldev.design.model.Computer;
 4
 5public class ComputerFactory {
 6
 7    public static Computer getComputer(ComputerAbstractFactory factory){
 8    	return factory.createComputer();
 9    }
10}

注意，它是一个简单的类，并且getComputer方法接受ComputerAbstractFactory参数并返回Computer对象。在这一点上，实现必须变得清晰起来。让我们编写一个简单的测试方法，看看如何使用抽象工厂来获取子类的实例。TestDesignPatterns.java

 1package com.journaldev.design.test;
 2
 3import com.journaldev.design.abstractfactory.PCFactory;
 4import com.journaldev.design.abstractfactory.ServerFactory;
 5import com.journaldev.design.factory.ComputerFactory;
 6import com.journaldev.design.model.Computer;
 7
 8public class TestDesignPatterns {
 9
10    public static void main(String[] args) {
11    	testAbstractFactory();
12    }
13
14    private static void testAbstractFactory() {
15    	Computer pc = com.journaldev.design.abstractfactory.ComputerFactory.getComputer(new PCFactory("2 GB","500 GB","2.4 GHz"));
16    	Computer server = com.journaldev.design.abstractfactory.ComputerFactory.getComputer(new ServerFactory("16 GB","1 TB","2.9 GHz"));
17    	System.out.println("AbstractFactory PC Config::"+pc);
18    	System.out.println("AbstractFactory Server Config::"+server);
19    }
20}

上述程序的输出将为：

1AbstractFactory PC Config::RAM= 2 GB, HDD=500 GB, CPU=2.4 GHz
2AbstractFactory Server Config::RAM= 16 GB, HDD=1 TB, CPU=2.9 GHz

下面是抽象工厂设计模式实现的类图。

抽象工厂设计模式的好处

抽象工厂设计模式提供了编写接口代码的方法，而不是实现。
抽象工厂模式是工厂的工厂，可以很容易地扩展以容纳更多的产品，例如，我们可以添加另一个子类笔记本电脑和一个工厂LaptopFactory。
抽象工厂模式健壮，避免工厂模式的条件逻辑。

抽象JDK中的工厂设计模式示例

javax.xml.parsers.DocumentBuilderFactory# newInstance()
javax.xml.transform.TransformerFactory# newInstance()
javax.xml.xpath.XPathFactory# newInstance()

抽象工厂设计模式视频教程

我最近在YouTube上上传了一个抽象工厂设计模式的视频。在视频中，我讨论了何时以及如何实现抽象工厂模式。我还讨论了工厂模式和抽象工厂设计模式之间的区别。https://youtu.be/BPkYkyVWOaw

您可以从我的giHub Project.]下载示例代码

Java 中的抽象工厂设计模式