静态类的模板方法模式

Question

我有一个执行一些工作的util类。显然，它对于扩展是封闭的，并且所有方法都是静态的。为了简单起见，这个类看起来像这样：

public final class Util {
    private Util() { }

    public static void doWork() {
        // some work
        int variable = help();
        // some work uses variable
    }

    private static int help() {
        // some helper functionality
    }
}

这个类有执行大量计算的doWork方法。顺便说一下，方法调用帮助器方法help来获得一些结果，其余的代码使用help方法返回的结果。

现在，在客户机代码中，我希望重用方法doWork的功能，但我希望调用help2方法而不是调用help。最简单的解决方案是创建方法doWork2，将help替换为help2。

这是一种非常糟糕的方法，因为doWork中的每个更改也必须在doWork2中复制。这非常类似于Template Method模式，但是由于我们这里没有扩展，所以我们不能应用它。

我想出的最佳解决方案是向此方法添加参数，但保留所有现有的doWork用户

public static void doWork() {
    doWorkWithParameter(true);
}

public static void doWorkWithParameter(boolean helpOrHelp2) {
    // some work
    int variable = helpOrHelp2 ? help() : help2();
    // some work uses variable
}

可以应用哪些更好的设计解决方案来解决此问题？有没有一种方法可以像Template Pattern一样实现灵活性，但在应用到util类时。

提前谢谢。

Answer 1

我的建议的灵感来自于Command Pattern，其中Util类是一个调用者，每个doWork-help对都是使用Worker接口封装的。

Worker Inteface可能类似于

public interface Worker {
    public void doWork();
    public int help();
}

Util类

public final class Util {
    private Util() { }

    public static void toWork(Worker worker){
        worker.doWork();
    }

}

具体工作者( help和doWork的实现)

public class ConcreteWorker implements Worker{

    @Override
    public void doWork() {
        // TODO Auto-generated method stub
            int variable = help();

    }

    @Override
    public int help() {
        // TODO Auto-generated method stub
        return 0;
    }

}

另一名工人

public class ConcreteWorker2 implements Worker{

    @Override
    public void doWork() {
        // TODO Auto-generated method stub
            int variable = help();

    }

    @Override
    public int help() {
        // TODO Auto-generated method stub
        return 1;
    }

}

和执行

Util.toWork(new ConcreteWorker());
Util.toWork(new ConcreteWorker2());

Answer 2

你可以创建两个实现Help接口的静态对象Help1 & Help2，其中有一个help()方法，并像这样改变你的doWorkWithParameter方法：

public static void doWorkWithParameter(Help h) {
    int variable = h.help();
}

它与您当前的解决方案密切相关。但我认为它更像是“面向对象的”。

Answer 3

不久前，我做了这样的事情：

public static enum Helper{
    OLD(){
        public int help(){
            return 0;
        }
    },

    NEW(){
        public int help(){
            return 1;
        }
    };

    public abstract int help();

    public void doWork() {
        int variable = help();
    }
}

public static Helper HELPER = Helper.NEW;

然后我们可以调用：

Constants.HELPER.doWork()

通过切换辅助常量值，我可以更改行为。或者你可以这样做：

Helper.OLD.doWork();
Helper.NEW.doWork();