转载

工厂模式根据不同的参数调用不同的实现类操作

要实现根据不同的参数调用不同的实现类操作，我们可以使用工厂模式来解决。

工厂模式

工厂模式是一种创建型设计模式，用于创建对象，而无需指定将使用哪个类来创建对象。它定义一个接口或抽象类，其实现类或子类来决定要实例化的类。这使得我们可以将对象的实例化延迟到子类中进行。在工厂模式中，客户端不用关心产品是如何创建的，只关心需要什么产品。工厂模式的主要优点是它具有很高的灵活性和可维护性，因为任何对产品的修改都不会影响客户端代码。

实现步骤

步骤1：创建抽象类或接口创建一个接口或者抽象类，这个类将被所有的实现类继承或者实现。

public interface Operation {
    double calculate(double num1, double num2);
}

步骤2：创建具体实现类创建具体类来实现接口或者抽象类并实现需要的方法。

public class Addition implements Operation {
    @Override
    public double calculate(double num1, double num2) {
        return num1 + num2;
    }
}

public class Subtraction implements Operation {
    @Override
    public double calculate(double num1, double num2) {
        return num1 - num2;
    }
}

步骤3：创建工厂类创建一个工厂类来生产实现类的对象，根据不同的参数，返回不同的实现类。

public class OperationFactory {
    public static Operation create(String operator) {
        switch (operator) {
            case "+":
                return new Addition();
            case "-":
                return new Subtraction();
            default:
                throw new IllegalArgumentException("Invalid operator: " + operator);
        }
    }
}

步骤4：测试工厂类

double num1 = 10, num2 = 5;
Operation addition = OperationFactory.create("+");
Operation subtraction = OperationFactory.create("-");
System.out.println(addition.calculate(num1, num2)); // 输出 15.0
System.out.println(subtraction.calculate(num1, num2)); // 输出 5.0

在上面的代码中，我们创建了一个工厂类OperationFactory用于根据不同的参数创建不同的实现类。具体实现类Addition和Subtraction实现了接口Operation的calculate方法，用于进行加法和减法计算。我们通过工厂类OperationFactory的create方法来创建实现类，然后调用计算方法calculate来对num1和num2进行加法和减法操作。

示例1

我们可以通过工厂模式来为一个系统创建多种不同的日志记录方式，如将日志记录到文件或者数据库等。我们可以定义一个抽象日志记录类和多个具体日志记录类来实现这个功能。

public interface Logger {
    void log(String message);
}

public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Log message to file: " + message);
    }
}

public class DatabaseLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Log message to database: " + message);
    }
}

public class LoggerFactory {
    public static Logger create(String loggerType) {
        switch (loggerType.toLowerCase()) {
            case "file":
                return new FileLogger();
            case "database":
                return new DatabaseLogger();
            default:
                throw new IllegalArgumentException("Invalid logger type: " + loggerType);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Logger logger = LoggerFactory.create("file");
        logger.log("Log this message to file");

        logger = LoggerFactory.create("database");
        logger.log("Log this message to database");
    }
}

在这个例子中，Logger是抽象的日志记录类，它的具体实现类FileLogger和DatabaseLogger分别将日志记录到文件和数据库中。LoggerFactory是日志记录的工厂类，它根据传入的参数来创建不同的Logger实例对象。

示例2

一个更为常见的应用是处理HTTP请求。我们可以定义一个抽象类HttpRequestHandler和多个具体实现类来处理不同的请求，再通过工厂类来创建具体的请求处理对象。

public abstract class HttpRequestHandler {
    public abstract void handleRequest(HttpServletRequest request);
}

public class MainPageHandler extends HttpRequestHandler {
    @Override
    public void handleRequest(HttpServletRequest request) {
        System.out.println("Handling request for main page");
    }
}

public class AboutPageHandler extends HttpRequestHandler {
    @Override
    public void handleRequest(HttpServletRequest request) {
        System.out.println("Handling request for about page");
    }
}

public class ContactPageHandler extends HttpRequestHandler {
    @Override
    public void handleRequest(HttpServletRequest request) {
        System.out.println("Handling request for contact page");
    }
}

public class HttpRequestHandlerFactory {
    public static HttpRequestHandler create(String requestPage) {
        switch (requestPage) {
            case "main":
                return new MainPageHandler();
            case "about":
                return new AboutPageHandler();
            case "contact":
                return new ContactPageHandler();
            default:
                throw new IllegalArgumentException("Invalid request page: " + requestPage);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        String requestPage = "main";
        HttpRequestHandler handler = HttpRequestHandlerFactory.create(requestPage);
        handler.handleRequest(null);

        requestPage = "about";
        handler = HttpRequestHandlerFactory.create(requestPage);
        handler.handleRequest(null);

        requestPage = "contact";
        handler = HttpRequestHandlerFactory.create(requestPage);
        handler.handleRequest(null);
    }
}

在这个例子中，HttpRequestHandler是抽象的请求处理类，具体的请求处理实现类MainPageHandler、AboutPageHandler和ContactPageHandler分别处理不同的请求。HttpRequestHandlerFactory是请求处理的工厂类，它根据传入的参数来创建不同的HttpRequestHandler实例对象。这两个例子说明了在不同的场景下，工厂模式可以被广泛应用，能够使代码更容易扩展和维护。

正文到此结束