Java 方法重载与工厂

假设我们需要在一个标志的基础上对多个类的多个方法进行一些逻辑更改，同时保持向后兼容性

有两种方法

1.重载每个类中的每个方法。然后在调用方代码中使用if-else梯形图来调用正确的方法

2.制作一个通用接口和一个工厂。根据传递给工厂的标志返回其中一个的对象。打电话的人不需要找零钱。创建对象时只需稍作更改。仅为两种类型创建工厂是否合乎逻辑

根据你的经验，你会选择哪一种？如何在这两种方式之间做出选择？你能建议什么更好的方法吗？

逻辑变化表明行为表明策略模式。这避免了对现有方法签名的更改

但是您仍然可以使用工厂来集中创建处理逻辑的具体策略对象

import java.util.Random;

public class App {

    public static void main(String[] args) {
        App app = new App();
        app.calculateSomething(new Random().nextBoolean());
    }

    private void calculateSomething(boolean isUsingLegacyLogic) {
        CalculationStrategyFactory factory = new CalculationStrategyFactory();
        CalculationStrategy strategy = factory.getCalculationStrategy(isUsingLegacyLogic);
        Calculator calculator = new Calculator(strategy);
        calculator.calculate();
    }

    class Calculator {
        CalculationStrategy calculationStrategy;

        Calculator(CalculationStrategy calculationStrategy) {
            this.calculationStrategy = calculationStrategy;
        }

        // ...

        public double calculate() {
            // original code
            // ...
            // System.out.println("Calculation steps were done in sequential order.");
            // return 0;


            return calculationStrategy.calculate(this);
        }

    }

    private interface CalculationStrategy {
        double calculate(Calculator c);
    }

    private class SequentialCalculationHandler implements CalculationStrategy {
        public double calculate(Calculator c) {
            // ...
            System.out.println("Calculation steps were done in sequential order.");
            return 0;
        }
    }

    private class ParallelCalculationHandler implements CalculationStrategy {
        public double calculate(Calculator c) {
            // ...
            System.out.println("Calculation steps were done in parralel.");
            return 0;
        }
    }

    private class CalculationStrategyFactory {
        public CalculationStrategy getCalculationStrategy(boolean isUsingLegacyLogic) {
            if (isUsingLegacyLogic || Runtime.getRuntime().availableProcessors() == 1) {
                return new SequentialCalculationHandler();
            }

            return new ParallelCalculationHandler();
        }
    }

}

逻辑变化表明行为表明策略模式。这避免了对现有方法签名的更改

但是您仍然可以使用工厂来集中创建处理逻辑的具体策略对象

import java.util.Random;

public class App {

    public static void main(String[] args) {
        App app = new App();
        app.calculateSomething(new Random().nextBoolean());
    }

    private void calculateSomething(boolean isUsingLegacyLogic) {
        CalculationStrategyFactory factory = new CalculationStrategyFactory();
        CalculationStrategy strategy = factory.getCalculationStrategy(isUsingLegacyLogic);
        Calculator calculator = new Calculator(strategy);
        calculator.calculate();
    }

    class Calculator {
        CalculationStrategy calculationStrategy;

        Calculator(CalculationStrategy calculationStrategy) {
            this.calculationStrategy = calculationStrategy;
        }

        // ...

        public double calculate() {
            // original code
            // ...
            // System.out.println("Calculation steps were done in sequential order.");
            // return 0;


            return calculationStrategy.calculate(this);
        }

    }

    private interface CalculationStrategy {
        double calculate(Calculator c);
    }

    private class SequentialCalculationHandler implements CalculationStrategy {
        public double calculate(Calculator c) {
            // ...
            System.out.println("Calculation steps were done in sequential order.");
            return 0;
        }
    }

    private class ParallelCalculationHandler implements CalculationStrategy {
        public double calculate(Calculator c) {
            // ...
            System.out.println("Calculation steps were done in parralel.");
            return 0;
        }
    }

    private class CalculationStrategyFactory {
        public CalculationStrategy getCalculationStrategy(boolean isUsingLegacyLogic) {
            if (isUsingLegacyLogic || Runtime.getRuntime().availableProcessors() == 1) {
                return new SequentialCalculationHandler();
            }

            return new ParallelCalculationHandler();
        }
    }

}

---

我建议你用这两种方法编写一个现实的例子，自己看。我建议你用这两种方法编写一个现实的例子，自己看。啊！我打字不够快，你比我快。我喜欢战略模式。是的，这个问题不是一个创造性的问题，而是一个行为性的问题，因此您将“注入”新的实现。啊！我打字不够快，你比我快。我喜欢战略模式。是的，这个问题不是一个创造性的问题，而是一个行为性的问题，因此您将“注入”新的实现。