灵活多变的对象创建——工厂方法模式（Java实现）

1. 引言

大家好，又见面了！在上一篇文章中，我们深入探讨了工厂方法模式的Python实现灵活多变的对象创建——工厂方法模式（Python实现），今天，我们将继续这个话题，但这次我们要用Java来实现。

如果说Python版的工厂方法模式是“变形金刚”，那么Java版的工厂方法模式就是“钢铁侠”，通过定义一个创建对象的接口，让子类决定实例化哪一个类，我们可以让Java代码也变得灵活多变。准备好了吗？Let’s get started!

2. 什么是工厂方法模式

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式使一个类的实例化延迟到其子类，简而言之，就是父类提供一个接口，子类来决定实例化哪个具体的类。

3. 工厂方法模式的实现（Java）

示例一：形状工厂

假如你是个艺术家，需要画各种形状，圆形、方形啥的，你可以用工厂方法模式让子类决定创建哪些形状对象：

代码实现

// 定义Shape接口
public interface Shape {
    void draw();
}

// 实现Circle类
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

// 实现Square类
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Square");
    }
}

// 定义ShapeFactory接口
public interface ShapeFactory {
    Shape createShape();
}

// 实现CircleFactory类
public class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

// 实现SquareFactory类
public class SquareFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Square();
    }
}

// 使用示例
public class FactoryMethodDemo {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape shape1 = circleFactory.createShape();
        shape1.draw();  // 输出: Drawing a Circle

        ShapeFactory squareFactory = new SquareFactory();
        Shape shape2 = squareFactory.createShape();
        shape2.draw();  // 输出: Drawing a Square
    }
}

详细代码解析

• Shape是一个接口，定义了draw方法；
• Circle和Square类实现了Shape接口，具体画啥样子它们说了算；
• ShapeFactory是一个接口，定义了createShape方法；
• CircleFactory和SquareFactory类实现了ShapeFactory接口，分别负责创建Circle和Square对象；
• 我们只需通过调用具体的工厂类（如CircleFactory或SquareFactory）来创建形状对象，然后调用相应的draw方法。

示例二：日志记录器工厂

现在你是个开发者，搞个日志系统，你想要不同级别的日志记录器来帮你分门别类记录信息，工厂方法模式也能派上用场：

代码实现

// 定义Logger接口
public interface Logger {
    void log(String message);
}

// 实现InfoLogger类
public class InfoLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("INFO: " + message);
    }
}

// 实现ErrorLogger类
public class ErrorLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("ERROR: " + message);
    }
}

// 定义LoggerFactory接口
public interface LoggerFactory {
    Logger createLogger();
}

// 实现InfoLoggerFactory类
public class InfoLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        return new InfoLogger();
    }
}

// 实现ErrorLoggerFactory类
public class ErrorLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        return new ErrorLogger();
    }
}

// 使用示例
public class FactoryMethodDemo {
    public static void main(String[] args) {
        LoggerFactory infoLoggerFactory = new InfoLoggerFactory();
        Logger infoLogger = infoLoggerFactory.createLogger();
        infoLogger.log("This is an informational message.");  // 输出: INFO: This is an informational message.

        LoggerFactory errorLoggerFactory = new ErrorLoggerFactory();
        Logger errorLogger = errorLoggerFactory.createLogger();
        errorLogger.log("This is an error message.");  // 输出: ERROR: This is an error message.
    }
}

详细代码解析

• Logger是一个接口，定义了log方法；
• InfoLogger和ErrorLogger类实现了Logger接口，分别负责记录不同级别的日志；
• LoggerFactory是一个接口，定义了createLogger方法；
• InfoLoggerFactory和ErrorLoggerFactory类实现了LoggerFactory接口，分别负责创建InfoLogger和ErrorLogger对象；
• 你只需通过调用具体的工厂类（如InfoLoggerFactory或ErrorLoggerFactory）来创建日志记录器对象，然后调用相应的log方法。

示例三：数据库连接工厂

假如你现在是个DBA，需要管理多个数据库连接，工厂方法模式同样能帮你搞定这个问题：

代码实现

// 定义DatabaseConnection接口
public interface DatabaseConnection {
    void connect();
}

// 实现MySQLConnection类
public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connecting to MySQL database...");
    }
}

// 实现PostgreSQLConnection类
public class PostgreSQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connecting to PostgreSQL database...");
    }
}

// 定义DatabaseConnectionFactory接口
public interface DatabaseConnectionFactory {
    DatabaseConnection createConnection();
}

// 实现MySQLConnectionFactory类
public class MySQLConnectionFactory implements DatabaseConnectionFactory {
    @Override
    public DatabaseConnection createConnection() {
        return new MySQLConnection();
    }
}

// 实现PostgreSQLConnectionFactory类
public class PostgreSQLConnectionFactory implements DatabaseConnectionFactory {
    @Override
    public DatabaseConnection createConnection() {
        return new PostgreSQLConnection();
    }
}

// 使用示例
public class FactoryMethodDemo {
    public static void main(String[] args) {
        DatabaseConnectionFactory mySQLFactory = new MySQLConnectionFactory();
        DatabaseConnection mysqlConnection = mySQLFactory.createConnection();
        mysqlConnection.connect();  // 输出: Connecting to MySQL database...

        DatabaseConnectionFactory postgreSQLFactory = new PostgreSQLConnectionFactory();
        DatabaseConnection postgresqlConnection = postgreSQLFactory.createConnection();
        postgresqlConnection.connect();  // 输出: Connecting to PostgreSQL database...
    }
}

详细代码解析

• DatabaseConnection是一个接口，定义了connect方法；
• MySQLConnection和PostgreSQLConnection类实现了DatabaseConnection接口，分别负责不同数据库的连接；
• DatabaseConnectionFactory是一个接口，定义了createConnection方法；
• MySQLConnectionFactory和PostgreSQLConnectionFactory类实现了DatabaseConnectionFactory接口，分别负责创建MySQLConnection和PostgreSQLConnection对象；
• 你只需通过调用具体的工厂类（如MySQLConnectionFactory或PostgreSQLConnectionFactory）来创建数据库连接对象，然后调用相应的connect方法。

4. 工厂方法模式的优缺点

优点

• 解耦：将对象的创建过程与使用过程分离，降低了代码的耦合度；
• 灵活性：通过子类来决定具体实例化哪个类，增加了代码的灵活性；
• 扩展性：增加新的产品类时，只需添加相应的工厂类即可，不需要修改现有代码。

缺点

• 类的数量增加：每增加一个产品类，都需要增加一个相应的工厂类，导致类的数量增多；
• 代码复杂度提高：增加了系统的复杂性，理解起来可能会有些困难。

5. 图示

类图

示意图

6. 总结

工厂方法模式是一个非常有用的设计模式，通过定义一个创建对象的接口，让子类来决定实例化哪一个类，增加了代码的灵活性和可扩展性。虽然它会增加类的数量和代码的复杂度，但在大多数情况下，工厂方法模式依然是一个非常实用的解决方案。希望今天的分享能让大家对工厂方法模式有更深入的理解，如果你在项目中也用到了工厂方法模式，欢迎留言分享你的经验和见解！