Java设计模式之工厂方法模式详解

什么是工厂方法模式？

工厂方法模式是一种创建型设计模式，它提供了一种将对象的创建委托给子类的方式。在工厂方法模式中，我们定义一个创建对象的接口，但是让子类决定实例化哪个类。这样可以将对象的创建与使用代码解耦，使得代码更加灵活和可扩展。

工厂方法模式的结构

工厂方法模式包含以下几个角色：

1. 抽象产品（Product）：定义了产品的接口，是具体产品类的共同父类。
2. 具体产品（ConcreteProduct）：实现了抽象产品接口的具体产品类。
3. 抽象工厂（Factory）：定义了创建产品的接口，包含一个创建产品的方法。
4. 具体工厂（ConcreteFactory）：实现了抽象工厂接口，负责创建具体产品的实例。

下面是一个示意图，展示了工厂方法模式的结构：

+-----------------+
|   抽象产品      |
+-----------------+
        /_\\
         |
+-----------------+
|  具体产品A     |
+-----------------+
         |
+-----------------+
|  具体产品B     |
+-----------------+

+-----------------+
|   抽象工厂      |
+-----------------+
        /_\\
         |
+-----------------+
|  具体工厂A     |
+-----------------+
         |
+-----------------+
|  具体工厂B     |
+-----------------+

工厂方法模式的示例

下面通过两个示例来说明工厂方法模式的使用。

示例一：创建不同类型的日志记录器

假设我们需要创建不同类型的日志记录器，包括文件日志记录器和数据库日志记录器。首先，我们定义一个抽象产品接口Logger，包含一个记录日志的方法log。然后，我们创建两个具体产品类FileLogger和DatabaseLogger，分别实现了抽象产品接口。接下来，我们定义一个抽象工厂接口LoggerFactory，包含一个创建日志记录器的方法createLogger。最后，我们创建两个具体工厂类FileLoggerFactory和DatabaseLoggerFactory，分别实现了抽象工厂接口，负责创建具体产品的实例。

// 抽象产品接口
public interface Logger {
    void log(String message);
}

// 具体产品类：文件日志记录器
public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println(\"FileLogger: \" + message);
    }
}

// 具体产品类：数据库日志记录器
public class DatabaseLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println(\"DatabaseLogger: \" + message);
    }
}

// 抽象工厂接口
public interface LoggerFactory {
    Logger createLogger();
}

// 具体工厂类：文件日志记录器工厂
public class FileLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        return new FileLogger();
    }
}

// 具体工厂类：数据库日志记录器工厂
public class DatabaseLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        return new DatabaseLogger();
    }
}

使用工厂方法模式的示例代码如下：

public class Main {
    public static void main(String[] args) {
        // 创建文件日志记录器工厂
        LoggerFactory fileLoggerFactory = new FileLoggerFactory();
        // 创建文件日志记录器
        Logger fileLogger = fileLoggerFactory.createLogger();
        // 记录日志
        fileLogger.log(\"This is a file log message.\");

        // 创建数据库日志记录器工厂
        LoggerFactory databaseLoggerFactory = new DatabaseLoggerFactory();
        // 创建数据库日志记录器
        Logger databaseLogger = databaseLoggerFactory.createLogger();
        // 记录日志
        databaseLogger.log(\"This is a database log message.\");
    }
}

运行以上代码，输出结果如下：

FileLogger: This is a file log message.
DatabaseLogger: This is a database log message.

示例二：创建不同类型的图形对象

假设我们需要创建不同类型的图形对象，包括圆形和矩形。首先，我们定义一个抽象产品接口Shape，包含一个绘制图形的方法draw。然后，我们创建两个具体产品类Circle和Rectangle，分别实现了抽象产品接口。接下来，我们定义一个抽象工厂接口ShapeFactory，包含一个创建图形对象的方法createShape。最后，我们创建两个具体工厂类CircleFactory和RectangleFactory，分别实现了抽象工厂接口，负责创建具体产品的实例。

// 抽象产品接口
public interface Shape {
    void draw();
}

// 具体产品类：圆形
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println(\"Drawing a circle.\");
    }
}

// 具体产品类：矩形
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println(\"Drawing a rectangle.\");
    }
}

// 抽象工厂接口
public interface ShapeFactory {
    Shape createShape();
}

// 具体工厂类：圆形工厂
public class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

// 具体工厂类：矩形工厂
public class RectangleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

使用工厂方法模式的示例代码如下：

public class Main {
    public static void main(String[] args) {
        // 创建圆形工厂
        ShapeFactory circleFactory = new CircleFactory();
        // 创建圆形对象
        Shape circle = circleFactory.createShape();
        // 绘制图形
        circle.draw();

        // 创建矩形工厂
        ShapeFactory rectangleFactory = new RectangleFactory();
        // 创建矩形对象
        Shape rectangle = rectangleFactory.createShape();
        // 绘制图形
        rectangle.draw();
    }
}

运行以上代码，输出结果如下：

Drawing a circle.
Drawing a rectangle.

总结

工厂方法模式是一种常用的创建型设计模式，它通过定义一个创建对象的接口，让子类决定实例化哪个类，从而将对象的创建与使用代码解耦。工厂方法模式可以提供灵活的扩展性，使得系统更易于维护和扩展。在实际应用中，我们可以根据具体的需求选择合适的工厂方法模式来创建对象。