最近在一次面试中，有这样一个问题问到了我。
问题: 有一个类用于分析代码执行时间。类的结构如下:
Class StopWatch {
long startTime;
long stopTime;
void start() {// set startTime}
void stop() { // set stopTime}
long getTime() {// return difference}
}
客户端需要创建一个StopWatch实例并相应地调用方法。用户代码可能会搞乱方法的使用，导致意外结果。例如，start()、stop()和getTime()的调用应按顺序进行。
这个类必须被“重新配置”，以便防止用户搞乱顺序。
我提议在调用 start() 之前调用 stop() 时使用自定义异常或进行一些 if/else 检查，但面试官并不满意。
是否有设计模式可以处理这种情况？
编辑：类成员和方法实现可以进行修改。
首先，实现自己的Java分析器是浪费时间的事情，因为已经有好的分析器可用（也许这就是问题背后的意图）。
如果您想在编译时强制执行正确的方法顺序，则必须在每个链中的方法中返回一些内容：
start() 必须返回一个带有 stop 方法的 WatchStopper。WatchStopper.stop() 必须返回一个具有 getResult() 方法的 WatchResult。当然，必须防止外部构建这些辅助类以及其他访问它们方法的方式。
StopWatch => RunningStopWatch => StoppedStopWatch这样的命名可能更好（或者只是在后两个之间交替使用？）。这种命名描述了对象状态而不是可用的方法。在我看来，可用的方法从上下文中会比较明显，而这个名称则更明确地表示了对象的含义。 - Kat通过对界面进行轻微更改，您可以使方法序列成为唯一可以在编译时调用的方法！
public class Stopwatch {
public static RunningStopwatch createRunning() {
return new RunningStopwatch();
}
}
public class RunningStopwatch {
private final long startTime;
RunningStopwatch() {
startTime = System.nanoTime();
}
public FinishedStopwatch stop() {
return new FinishedStopwatch(startTime);
}
}
public class FinishedStopwatch {
private final long elapsedTime;
FinishedStopwatch(long startTime) {
elapsedTime = System.nanoTime() - startTime;
}
public long getElapsedNanos() {
return elapsedTime;
}
}
使用方法很简单 - 每个方法都会返回一个不同的类，其中仅包含当前适用的方法。基本上，秒表的状态封装在类型系统中。
评论中指出，即使使用上述设计，您仍然可以调用stop()两次。尽管我认为这是增加了附加值，但从理论上讲可能会自毁前程。那么，我能想到的唯一办法就是这样：
class Stopwatch {
public static Stopwatch createRunning() {
return new Stopwatch();
}
private final long startTime;
private Stopwatch() {
startTime = System.nanoTime();
}
public long getElapsedNanos() {
return System.nanoTime() - startTime;
}
}
这与任务不同，它省略了stop()方法，但这也有可能是一种良好的设计。一切都取决于精确的要求...
RunningStopwatch 实例上，什么阻止你调用两次 stop 方法？ - EranFinishedStopwatch 实例，这使得您可以将一个 RunningStopwatch 重复使用多次进行测量。虽然即使使用错误也很可能是正确的，但确实有可能以可怕的方式弄乱它。如果我们想要防范甚至这种情况，我们应该省略 stop() 方法，只在获得正在运行的秒表实例后提供 getElapsedNanos()。 - Petr JanečekMultimapBuilder中也被使用。我仍然很想知道你为什么认为它不适合生产。 - Petr Janeček我们通常使用Apache Commons StopWatch来检查其提供的模式。
当停表状态错误时，会抛出IllegalStateException（非法状态异常）。
stop
public void stop()停止计时器。
此方法结束一个新的计时会话，允许检索时间。
Throws:
IllegalStateException- 如果StopWatch没有在运行中。
直截了当。
start()之前调用stop()时使用自定义异常...，但面试官并不满意。” - Petr Janečekclass StopWatch {
public static long runWithProfiling(Runnable action) {
startTime = now;
action.run();
return now - startTime;
}
}
回想起来，他们似乎在寻找执行周围模式。它们通常用于执行诸如强制关闭流之类的操作。由于这一行代码，这也更相关：
有没有一种设计模式来处理这些情况？
这个想法是你给那个做“执行周围”工作的东西一些类去做某些事情。你可能会使用Runnable，但这不是必要的。（Runnable最有意义，你很快就会明白为什么。）在你的StopWatch类中添加一个像这样的方法。
public long measureAction(Runnable r) {
start();
r.run();
stop();
return getTime();
}
StopWatch stopWatch = new StopWatch();
Runnable r = new Runnable() {
@Override
public void run() {
// Put some tasks here you want to measure.
}
};
long time = stopWatch.measureAction(r);
Runnable 之所以好用，是因为：
Runnable 中。StopWatchWrapper 来代替修改 StopWatch。您还可以使 measureAction(Runnable) 不返回时间，并公开 getTime()。StopWatch stopWatch = new StopWatch();
long time = stopWatch.measureAction(() - > {/* Measure stuff here */});
A third (hopefully final) thought: it seems what the interviewer was looking for and what is being upvoted the most is throwing exceptions based on state (e.g., if
stop()is called beforestart()orstart()afterstop()). This is a fine practice and in fact, depending on the methods inStopWatchhaving a visibility other than private/protected, it's probably better to have than not have. My one issue with this is that throwing exceptions alone will not enforce a method call sequence.For example, consider this:
class StopWatch { boolean started = false; boolean stopped = false; // ... public void start() { if (started) { throw new IllegalStateException("Already started!"); } started = true; // ... } public void stop() { if (!started) { throw new IllegalStateException("Not yet started!"); } if (stopped) { throw new IllegalStateException("Already stopped!"); } stopped = true; // ... } public long getTime() { if (!started) { throw new IllegalStateException("Not yet started!"); } if (!stopped) { throw new IllegalStateException("Not yet stopped!"); } stopped = true; // ... } }Just because it's throwing
IllegalStateExceptiondoesn't mean that the proper sequence is enforced, it just means improper sequences are denied (and I think we can all agree exceptions are annoying, luckily this is not a checked exception).The only way I know to truly enforce that the methods are called correctly is to do it yourself with the execute around pattern or the other suggestions that do things like return
RunningStopWatchandStoppedStopWatchthat I presume have only one method, but this seems overly complex (and OP mentioned that the interface couldn't be changed, admittedly the non-wrapper suggestion I made does this though). So to the best of my knowledge there's no way to enforce the proper order without modifying the interface or adding more classes.I guess it really depends on what people define "enforce a method call sequence" to mean. If only the exceptions are thrown then the below compiles
StopWatch stopWatch = new StopWatch(); stopWatch.getTime(); stopWatch.stop(); stopWatch.start();True it won't run, but it just seems so much simpler to hand in a
Runnableand make those methods private, let the other one relax and handle the pesky details yourself. Then there's no guess work. With this class it's obvious the order, but if there were more methods or the names weren't so obvious it can begin to be a headache.
更多后见之明的编辑: OP在评论中提到，
"这三种方法应该保持完整，只是对程序员的接口。类成员和方法实现可以改变。"
所以下面的方法是错误的，因为它从接口中删除了一些内容。（从技术上讲，你可以将其实现为空方法，但这似乎是一个愚蠢的事情，也太令人困惑了。）如果没有限制，我有点喜欢这个答案，它似乎是另一种“傻瓜式”的方法，所以我会保留它。
对我来说，像这样的东西似乎很好。
class StopWatch {
private final long startTime;
public StopWatch() {
startTime = ...
}
public long stop() {
currentTime = ...
return currentTime - startTime;
}
}
stop()方法）。stop()的命名。起初我想到了lap()，但这通常意味着重新启动或某种记录（或者至少是自上次圈/开始以来的记录）。也许read()会更好？这模仿了看秒表时间的动作。我选择stop()以保持与原始类的相似性。...以相同的方式获取当前时间，就应该没问题。我建议采用类似以下内容：
interface WatchFactory {
Watch startTimer();
}
interface Watch {
long stopTimer();
}
它将会被用于以下方式
Watch watch = watchFactory.startTimer();
// Do something you want to measure
long timeSpentInMillis = watch.stopTimer();
您不能按错误的顺序调用任何内容。如果您两次调用stopTimer，每次都会得到有意义的结果（也许更好的做法是将其重命名为measure，并在每次调用时返回实际时间）。
Thread 的 start 在第二次调用时会抛出 IllegalThreadStateException 异常。startTime，例如在秒表启动之前将其设置为 -1。 - aioobe在Java 8中也可以使用Lambda表达式来实现。在这种情况下，您将您的函数传递给StopWatch类，然后告诉StopWatch执行该代码。
Class StopWatch {
long startTime;
long stopTime;
private void start() {// set startTime}
private void stop() { // set stopTime}
void execute(Runnable r){
start();
r.run();
stop();
}
long getTime() {// return difference}
}
我知道这个问题已经有答案了，但是找不到一个使用接口来控制流程的构建器的答案，所以这里是我的解决方案: (请给接口命名比我更好 :p)
public interface StartingStopWatch {
StoppingStopWatch start();
}
public interface StoppingStopWatch {
ResultStopWatch stop();
}
public interface ResultStopWatch {
long getTime();
}
public class StopWatch implements StartingStopWatch, StoppingStopWatch, ResultStopWatch {
long startTime;
long stopTime;
private StopWatch() {
//No instanciation this way
}
public static StoppingStopWatch createAndStart() {
return new StopWatch().start();
}
public static StartingStopWatch create() {
return new StopWatch();
}
@Override
public StoppingStopWatch start() {
startTime = System.currentTimeMillis();
return this;
}
@Override
public ResultStopWatch stop() {
stopTime = System.currentTimeMillis();
return this;
}
@Override
public long getTime() {
return stopTime - startTime;
}
}
使用方法:
StoppingStopWatch sw = StopWatch.createAndStart();
//Do stuff
long time = sw.stop().getTime();
start()方法返回一个带有stop()方法的RunningStopWatch的StoppedStopWatch。（然后可以通过将其设置为包级私有来防止直接使用底层的StopWatch。） - aioobe