【软考】抽象工厂模式

抽象工厂模式
提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类

结构：
![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/18/hdvulb.webp)

Client：客户端，具体使用抽象工厂的类
与工厂方法模式的区别：产品不一样，现在有两类产品 A B，抽象工厂定义了一个创建产品A、创建产品B，工厂方法模式的升级版。
工厂 2 可以创建产品 A 也可以创建产品 B，创建出来的产品是 A2 和 B2
工厂 1 也可以创建产品 A 也可以创建产品 B，创建出来的产品是 A1 和 B1
多增加相关的产品接口，再去工厂里面接口中增加一个方法

```java
//最上面这段可以理解成从客户端（Client）调用
public class AbstractFactory{
	public static void main(String[] args){
		Factroy factory1 = new Factory1();
		
		//工厂 1 创建一个具体的产品 A
		ProductA productA = factory1.createProductA();
		productA.info();
		
		Factory factory2 = new Factory2();
		
		ProductB productB = factory2.createProductB();
		productB.info();
		
	}
}

//写工厂的接口，还有实现工厂的子类，要多增加一个方法
//创建产品 A、创建产品 B
interface Factory{
	public ProductA createProductA();
	//返回值的类型要根据创建的产品来改
	//也就是创建产品 A 返回值的类型也是 ProductA，创建产品 B 返回值的类型是 ProductB
	public ProductB createProductB();
}

class Factory1 implements Factory{
	// 上面有两个方法要实现，两个方法都要实现，也就是 创建产品 A1 要实现，创建产品 B1 也要实现
	// 工厂1 只创建 A1 和 B1
	@Override
	public ProductA createProductA(){
		return new ProductA1();
	}
	
	@Override
	public ProductB createProductB(){
		return new ProductB1();
	}
}

class Factory2 implements Factory{
	@Override
	public ProductA createProductA(){
		return new ProductA2();
	}
	
	@Override
	public ProductB createProductB(){
		return new ProductB2();	
	}
}

// 一个接口是产品 A，一个接口是产品 B
//以下六段写的是，上面结构图中右侧的部分：产品 A 和产品 B 的接口，还有具体的产品 A1 A2 B1 B2
interface ProductA{
	public void info();
}

class ProductA1 implements ProductA{
	@Override
	public void info(){
		System.out.println("产品的信息：A1");
	}
}

class ProductA2 implements ProductA{
	@Override
	public void info(){
		System.out.println("产品的信息：A2");
	}
}

interface ProductB{
	public void info();
}

class ProductB1 implements ProductB{
	@Override
	public void info(){
		System.out.println("产品的信息：B1");
	}
}

class ProductB2 implements ProductB{
	@Override
	public void info(){
		System.out.println("产品的信息：B2");
	}
}
```

执行结果：
![image](https://cdn-imagehost.xyzttt.xyz/image/2026/05/18/ik675k.webp)

抽象工厂模式适用性：
- 一个系统要独立于它的产品的创建、组合 和 表示时
- 一个系统要由多个产品系列中的一个来配置时
- 当要强调一系列相关的产品对象的设计以便进行联合使用时
- 当提供一个产品类库，指向显示它们的接口而不是实现时