设计模式之简单工厂模式、工厂方法模式和抽象工厂模式

简单工厂模式、工厂方法模式和抽象工厂模式

在软件设计中，工厂模式是一种常见的设计模式，它提供了一种创建对象的接口，而无需指定其具体类。在Java中，有三种主要的工厂模式：简单工厂模式、工厂方法模式和抽象工厂模式。本文将深入探讨这三种工厂模式的区别、特点以及使用场景，并提供详细的代码示例。

1. 简单工厂模式

简单工厂模式是最基础的工厂模式，它由一个单一的工厂类负责创建对象。这个工厂类根据客户端的需求，决定实例化哪个具体的产品类。虽然简单，但也存在一些局限性。

特点：

• 单一工厂类负责所有产品的创建，可能导致该类臃肿。
• 客户端只需知道产品的类型，无需关心具体的实现。

代码示例：

// 简单工厂模式
class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        return null;
    }
}

// 产品接口
interface Product {
    void display();
}

// 具体产品类A
class ConcreteProductA implements Product {
    @Override
    public void display() {
        System.out.println("Product A");
    }
}

// 具体产品类B
class ConcreteProductB implements Product {
    @Override
    public void display() {
        System.out.println("Product B");
    }
}

// 客户端
public class SimpleFactoryClient {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.display();

        Product productB = SimpleFactory.createProduct("B");
        productB.display();
    }
}

2. 工厂方法模式

工厂方法模式是简单工厂模式的进一步抽象，它通过定义一个工厂接口，由具体的工厂子类负责创建产品。每个工厂子类对应一个具体的产品，从而实现了更好的可扩展性。

特点：

• 引入了抽象工厂接口，每个具体工厂都实现了这个接口。
• 每个具体工厂负责创建一个具体产品，符合开放-封闭原则。
• 客户端通过工厂接口调用，降低了与具体产品的耦合。

代码示例：

// 工厂方法模式
// 产品接口
interface Product {
    void display();
}

// 具体产品类A
class ConcreteProductA implements Product {
    @Override
    public void display() {
        System.out.println("Product A");
    }
}

// 具体产品类B
class ConcreteProductB implements Product {
    @Override
    public void display() {
        System.out.println("Product B");
    }
}

// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂类A
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂类B
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端
public class FactoryMethodClient {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.display();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.display();
    }
}

3. 抽象工厂模式

抽象工厂模式是一种更高级别的工厂模式，它允许一个工厂创建一系列相关或依赖的产品。抽象工厂模式通常包括多个抽象产品和多个具体工厂，每个具体工厂负责创建一族相关产品。

特点：

• 引入了抽象工厂接口，包含多个用于创建产品的方法。
• 每个具体工厂都实现了抽象工厂接口，负责创建一族相关的产品。
• 支持产品族的创建，例如在一个工厂中创建按钮和文本框，而在另一个工厂中创建滚动条和复选框。

代码示例：

// 抽象工厂模式
// 抽象产品接口
interface Button {
    void display();
}

// 具体产品类A
class ConcreteButtonA implements Button {
    @Override
    public void display() {
        System.out.println("Button A");
    }
}

// 具体产品类B
class ConcreteButtonB implements Button {
    @Override
    public void display() {
        System.out.println("Button B");
    }
}

// 抽象工厂接口
interface GUIFactory {
    Button createButton();
}

// 具体工厂类A
class ConcreteGUIFactoryA implements GUIFactory {
    @Override
    public Button createButton() {
        return new ConcreteButtonA();
    }
}

// 具体工厂类B
class ConcreteGUIFactoryB implements GUIFactory {
    @Override
    public Button createButton() {
        return new ConcreteButtonB();
    }
}

// 客户端
public class AbstractFactoryClient {
    public static void main(String[] args) {
        GUIFactory factoryA = new ConcreteGUIFactoryA();
        Button buttonA = factoryA.createButton();
        buttonA.display();

        GUIFactory factoryB = new ConcreteGUIFactoryB();
        Button buttonB = factoryB.createButton();
        buttonB.display();
    }
}

比较与选择

• 简单工厂模式适用于单一产品的场景，实现简单但不够灵活。
• 工厂方法模式更具扩展性，每个具体工厂负责一个产品，符合开放-封闭原则。
• 抽象工厂模式适用于产品族的创建，每个具体工厂创建一组相关产品，使得系统更具弹性和可维护性。

选择合适的工厂模式取决于项目需求和设计目标。在实际应用中，根据具体情况选择适当的工厂模式，可以提高代码的可维护性和灵活性。