创建型设计模式（4）：抽象工厂模式_abstract void operation-优快云博客

本文介绍了抽象工厂模式的概念、实现及应用场景。通过实例演示了如何利用该模式将对象的实现细节与一般使用分离开来，从而使得系统能在不修改客户端代码的情况下增加新的具体工厂。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

定义

抽象工厂模式提供了一种方式，可以将一组具有同一主题的单独的工厂封装起来。在正常使用中，客户端程序需要创建抽象工厂的具体实现，然后使用抽象工厂作为接口来创建这一主题的具体对象。客户端程序不需要知道（或关心）它从这些内部的工厂方法中获得对象的具体类型，因为客户端程序仅使用这些对象的通用接口。抽象工厂模式将一组对象的实现细节与他们的一般使用分离开来。

“工厂”是创建产品（对象）的地方，其目的是将产品的创建与产品的使用分离。抽象工厂模式的目的，是将若干抽象产品的接口与不同主题产品的具体实现分离开。这样就能在增加新的具体工厂的时候，不用修改引用抽象工厂的客户端代码。

使用抽象工厂模式，能够在具体工厂变化的时候，不用修改使用工厂的客户端代码，甚至是在运行时。然而，使用这种模式或者相似的设计模式，可能给编写代码带来不必要的复杂性和额外的工作。正确使用设计模式能够抵消这样的“额外工作”。

实现

1. AbstractFactory - 定义创建抽象产品的接口方法。

2. ConcreteFactory - 实现方法创建具体的产品。

3. AbstractProduct - 声明不同类型的产品的接口。

4. Product - 定义ConcreteFactory对应的具体产品，实现AbstractProduct接口。

5. Client - 使用AbstractFactory和AbstractProduct类。

abstract class AbstractProductA{
	public abstract void operationA1();
	public abstract void operationA2();
}

class ProductA1 extends AbstractProductA{
	ProductA1(String arg){
		System.out.println("Hello "+arg);
	} // Implement the code here
	public void operationA1() { };
	public void operationA2() { };
}

class ProductA2 extends AbstractProductA{
	ProductA2(String arg){
		System.out.println("Hello "+arg);
	} // Implement the code here
	public void operationA1() { };
	public void operationA2() { };
}

abstract class AbstractProductB{
	//public abstract void operationB1();
	//public abstract void operationB2();
}

class ProductB1 extends AbstractProductB{
	ProductB1(String arg){
		System.out.println("Hello "+arg);
	} // Implement the code here
}

class ProductB2 extends AbstractProductB{
	ProductB2(String arg){
		System.out.println("Hello "+arg);
	} // Implement the code here
}

abstract class AbstractFactory{
	abstract AbstractProductA createProductA();
	abstract AbstractProductB createProductB();
}

class ConcreteFactory1 extends AbstractFactory{
	AbstractProductA createProductA(){
		return new ProductA1("ProductA1");
	}
	AbstractProductB createProductB(){
		return new ProductB1("ProductB1");
	}
}

class ConcreteFactory2 extends AbstractFactory{
	AbstractProductA createProductA(){
		return new ProductA2("ProductA2");
	}
	AbstractProductB createProductB(){
		return new ProductB2("ProductB2");
	}
}

//Factory creator - an indirect way of instantiating the factories
class FactoryMaker{
	private static AbstractFactory pf=null;
	static AbstractFactory getFactory(String choice){
		if(choice.equals("a")){
			pf=new ConcreteFactory1();
		}else if(choice.equals("b")){
                        pf=new ConcreteFactory2();
                }
                return pf;
	}
}

// Client
public class Client{
	public static void main(String args[]){
		AbstractFactory pf=FactoryMaker.getFactory("a");
		AbstractProductA product=pf.createProductA();
		//more function calls on product
	}
}

FactoryMaker类使用的是简单工厂模式，而具体工厂的实现用的是工厂方法模式。

适用场景

1. 一个系统要独立于它的产品的创建、组合和表示时。

2. 一个系统要由多个产品系列中的一个来配置时。

3. 需要强调一系列相关的产品对象的设计以便进行联合使用时。

4. 提供一个产品类库，而只想显示它们的接口而不是实现时。

优点

1. 具体产品从客户代码中被分离出来

2. 容易改变产品的系列

3. 将一个系列的产品族统一到一起创建

缺点

1. 在产品族中扩展新的产品是很困难的，它需要修改抽象工厂的接口和具体工厂。