是否可以在循环中的每个方法之后检查条件？ 如果是这样，怎么样？

Question

Like I said in the title I have a loop in an RPG I'm making about High School. This is the main loop that sets up your day to act out individual sequences in chronological order. My question is how could I make it so that I check whether the boolean "beat" or the boolean "lost" (referring to the status of the game) has been tripped to true after every method in the loop but still keeping the methods together in a loop. Is nested if statements inside my while loop the only way?

while (!g.getBeat() || g.getLost()) 
{
    g.wakeUp();
    g.goToSchool();
    g.beforeLunch();
    g.lunchActivity();
    g.afterLunch();
    g.afterSchool();
    g.home();
    g.sleep();
}

Answer 1

You would have to do it manually. To help you write a little less code, make a method that checks both conditions:

private boolean stopTheLoop() {
    return g.getBeat() || g.getLost();
}

Now convert your loop to infinite with checks after each method:

while (true) {
    g.wakeUp();
    if (stopTheLoop()) break;
    g.goToSchool();
    if (stopTheLoop()) break;
    g.beforeLunch();
    if (stopTheLoop()) break;
    ...
}

Answer 2

You could use a switch statement by introducing a state :

int state = 0;
while (!g.getBeat() || g.getLost()) 
{
    switch (state) {
    case 0:
      g.wakeUp();
      break;
    case 1: 
      g.goToSchool();
      break;
    case 2: 
      g.beforeLunch();
      break;
    case 3: 
      g.lunchActivity();
      break;
    case 4: 
      g.afterLunch();
      break;
    case 5: 
      g.afterSchool();
      break;
    case 6: 
      g.home();
      break;
    case 7: 
      g.sleep();
      break;
    default:
      // some error handling, depending on your logic, 
      // or perhaps state = -1 to restart
    }
    state++;
}

Answer 3

There isn't any "built-in" way to do this, but with some coding, anything's possible.

First, regardless if how you handle this, I'd wrap the end condition into a single method, just to make things more convenient:

public class Game {
    // method, members, etc...

    public boolean isOver() {
        return !getBeat() || getLost();
    }
}

Now, The first option that comes to mind is to do this manually:

while (!g.isOver()) {
    g.wakeUp();
    if (g.isOver()) {
        break;
    }
    g.goToSchool();
    if (g.isOver()) {
        break;
    }
    // etc...
}

But this involves a lot of code, and isn't too elegant.

A more OO approach, perhaps, would be to warp every such call in a handler class:

public abstract GameStageHandler (Game g) {
    protected Game g;

    public GameStageHandler (Game g) {
        this.g = g;
    }


    /**
     * Play a stage in the game
     * @return Whether the game should go on or not after this stage
     */
    public boolean play() {
        performStage();
        return !g.isOver();
    }

    public abstract void performStage();
}

And implement it for every stage of the game. Eg for the wakeUp() stage you'd have:

public abstract WakeUpHandler (Game g) {
    public WakeUpHandler (Game g) {
        super(g);
    }

    @Override
    public void performStage() {
        g.wakeUp();
    }
}

Then, in the main method, you could have an array of such handlers, and iterate over them:

List<GameStageHandler> handlers = ...;
while (!g.isOver()) {
    for (GameStageHandler handler : handlers) {
        if (!g.play()) {
            break;
        }
     }
}

Answer 4

This is probably beyond the scope of your assignment, as you noted the class hasn't even covered Runnable yet. This is an interesting question, though, and the challenge is to come up with a concise and elegant way to represent it, while avoiding as much repetition as possible. Here's a solution that uses Java 8 and functional programming techniques.

The first insight is to see that each game action or step can be represented as a lambda expression or method reference. I'll assume that you have a Game class. Each such step takes a Game instance as an argument (or receiver) and thus can be typed as a "consumer" of Game instances. We can thus put them into a data structure:

List<Consumer<Game>> actions = Arrays.asList(
    Game::wakeUp,
    Game::goToSchool,
    Game::beforeLunch,
    Game::lunchActivity,
    Game::afterLunch,
    Game::afterSchool,
    Game::home,
    Game::sleep);

Now that we have them in a data structure, we can loop over them:

for (Consumer<Game> action : actions) {
    action.accept(game);
}

Of course, we want to check if the game is over after each action. Let's assume you have a method isOver on the Game class that checks the right termination conditions. You can then do:

for (Consumer<Game> a : actions) {
    a.accept(game);
    if (game.isOver()) {
        break;
    }
}

That only runs through one day of the game. Presumably you want to run the game indefinitely until it reaches its termination condition. For that you need an outer loop, and the termination check has to break out of the outer loop:

outer:
while (true) {
    for (Consumer<Game> a : actions) {
        a.accept(game);
        if (game.isOver()) {
            break outer;
        }
    }
}

This by itself might be sufficient: you have a list of game actions, and a loop that runs indefinitely, checking the termination condition after each action.

But wait, there's more! There's still a fair amount of boilerplate here, which can be eliminated using some of Java 8's stream features. Consider that every element of a stream can be tested against a predicate using the noneMatch method. This method terminates when one of the predicates returns true.

Since each action has type Consumer<Game> , we need a little helper function that turns each action into a predicate:

static Predicate<Consumer<Game>> stepAndCheck(Game game) {
    return c -> { c.accept(game); return game.isOver(); };
}

Now we can run all the actions of a day as follows:

actions.stream().noneMatch(stepAndCheck(game))

To run the game indefinitely, we simply wrap this in a while loop. Since noneMatch returns true if, as it says, none of the predicates matches, we make this the loop condition and leave the loop body empty:

while (actions.stream().noneMatch(stepAndCheck(game))) {
    // nothing
}

This might seem like it's unnecessarily obscure. Indeed, it might be, for toy examples such as this. However, for more complex problems, techniques like this are quite valuable.

Answer 5

If you want to keep each step in its own method like you do in your example there is little you can do about it...

You can reduce the amount of code if you make all those methods to return "true" if the condition to stop the loop is met... however this might not be possible if you plan to use those methods in order context.

if (!g.getBeat() || g.getLost()) do {
    if (g.wakeUp()) break;
    if (g.goToSchool()) break;
    ...
    if (g.sleep()) break;
} while (true);

A possible trick is to make those methods to throw an exception if the stop condition is met. Then you would catch that exception in outside the loop. That way you would save the if (...) break statements. However this is not considered a good practice.

if (!g.getBeat() || g.getLost()) {
  try {
    do {
      g.wakeUp();
      g.goToSchool();
      ...
      g.sleep();
    } while (true);
  } catch (ActivityLoopFinished ex) {
    // nothing to do here
  }
}