简单工厂模式（Simple Factory Pattern）
工厂方法模式（Factory Method Pattern）
抽象工厂模式（Abstract Factory Pattern）
它们是三种与对象创建相关的设计模式，都属于创建型模式，用于将对象的创建过程与使用过程分离，以提高代码的可维护性和灵活性。下面对这三个模式进行讲解：
1. 简单工厂模式
（Simple Factory Pattern）
概念
简单工厂模式由一个工厂类负责创建对象，根据参数决定要创建的具体类的实例。虽然它不是23种经典设计模式之一，但在实践中非常常用。
特点
- 工厂类：一个工厂类包含一个静态方法，根据传入的参数来决定创建哪种具体产品对象。
- 客户端：客户端只需要知道要创建的对象类型的参数，而不需要关心具体的创建过程。
示例
// 产品接口
interface Product {
void use();
}
// 具体产品A
class ProductA implements Product {
public void use() {
System.out.println("Using Product A");
}
}
// 具体产品B
class ProductB implements Product {
public void use() {
System.out.println("Using Product B");
}
}
// 简单工厂类
class SimpleFactory {
public static Product createProduct(String type) {
if (type.equals("A")) {
return new ProductA();
} else if (type.equals("B")) {
return new ProductB();
} else {
throw new IllegalArgumentException("Unknown product type");
}
}
}
// 客户端
public class Client {
public static void main(String[] args) {
Product product = SimpleFactory.createProduct("A");
product.use(); // 输出: Using Product A
}
}
优点
- 客户端代码简单，只需要知道产品的类型参数。
- 工厂类封装了对象创建的逻辑，客户端与具体产品的创建过程解耦。
缺点
- 当增加新的产品时，需要修改工厂类，违背了开闭原则。
- 工厂类可能会变得过于复杂，难以维护。
2. 工厂方法模式
（Factory Method Pattern）
概念
工厂方法模式通过定义一个创建对象的接口，由子类决定实例化哪一个类。工厂方法将对象的创建延迟到子类。
特点
- 工厂接口或抽象类：定义一个创建产品对象的接口或抽象方法。
- 具体工厂类：子类实现具体的产品创建逻辑。
- 客户端：通过调用工厂方法获取产品对象，客户端不直接依赖具体产品类。
示例
// 产品接口
interface Product {
void use();
}
// 具体产品A
class ProductA implements Product {
public void use() {
System.out.println("Using Product A");
}
}
// 具体产品B
class ProductB implements Product {
public void use() {
System.out.println("Using Product B");
}
}
// 工厂接口
interface Factory {
Product createProduct();
}
// 具体工厂A
class FactoryA implements Factory {
public Product createProduct() {
return new ProductA();
}
}
// 具体工厂B
class FactoryB implements Factory {
public Product createProduct() {
return new ProductB();
}
}
// 客户端
public class Client {
public static void main(String[] args) {
Factory factory = new FactoryA();
Product product = factory.createProduct();
product.use(); // 输出: Using Product A
}
}
优点
- 遵循开闭原则，增加新产品时只需要增加新的具体工厂类，不需要修改现有代码。
- 客户端通过工厂接口进行创建，依赖抽象而不依赖具体类，增强了代码的灵活性。
缺点
- 可能会导致类的数量增多，增加系统的复杂性。
3. 抽象工厂模式
（Abstract Factory Pattern）
概念
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。它是一种在多个产品等级结构中扩展的工厂方法模式。
特点
- 抽象工厂接口：定义多个创建不同产品类型的方法。
- 具体工厂类：每个具体工厂类负责创建一组相关的产品。
- 抽象产品接口：定义产品的公共接口，每个产品等级结构都要实现这个接口。
示例
// 抽象产品A
interface ProductA {
void use();
}
// 抽象产品B
interface ProductB {
void operate();
}
// 具体产品A1
class ProductA1 implements ProductA {
public void use() {
System.out.println("Using Product A1");
}
}
// 具体产品A2
class ProductA2 implements ProductA {
public void use() {
System.out.println("Using Product A2");
}
}
// 具体产品B1
class ProductB1 implements ProductB {
public void operate() {
System.out.println("Operating Product B1");
}
}
// 具体产品B2
class ProductB2 implements ProductB {
public void operate() {
System.out.println("Operating Product B2");
}
}
// 抽象工厂接口
interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
public ProductA createProductA() {
return new ProductA1();
}
public ProductB createProductB() {
return new ProductB1();
}
}
// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
public ProductA createProductA() {
return new ProductA2();
}
public ProductB createProductB() {
return new ProductB2();
}
}
// 客户端
public class Client {
public static void main(String[] args) {
AbstractFactory factory = new ConcreteFactory1();
ProductA productA = factory.createProductA();
ProductB productB = factory.createProductB();
productA.use(); // 输出: Using Product A1
productB.operate(); // 输出: Operating Product B1
}
}
优点
- 易于交换产品系列：客户端可以无缝切换到另一个产品系列，因为客户端是面向抽象的。
- 保证产品的一致性：抽象工厂会确保同一系列的产品一起使用，避免出现产品不兼容的情况。
缺点
- 增加新产品系列时，所有相关的工厂类都需要修改，违反了开闭原则。
总结
- 简单工厂模式：通过一个工厂类来决定创建哪种产品，适用于产品类型较少的简单场景。
- 工厂方法模式：通过创建工厂接口和具体工厂类，适用于有多个产品类型的场景，并且易于扩展新的产品类型。
- 抽象工厂模式：通过一个工厂接口创建一系列相关的产品，适用于需要生成一系列相关产品的场景，保证产品族的完整性和一致性。