Stateful Movement with a Crash Flag

Some movement classes need an "I'm done — no more moves" mode. A crash flag is a boolean instance variable that records whether the object has hit something. Once true, every subsequent move is rejected.

This combines three patterns from earlier topics: position state, bounds checking, and a state flag. The crash flag is a one-way switch — it gets set to true on the first invalid move and never resets.

On the AP exam, this pattern appears in rover/robot FRQs and in any "object that can fail permanently" problem.

Class skeleton

public class Rover {
    private int row, col;
    private int rows, cols;
    private boolean crashed;

    public Rover(int rows, int cols) {
        this.rows = rows;
        this.cols = cols;
        this.row = 0;
        this.col = 0;
        this.crashed = false;
    }

    public void move(char direction) {
        if (crashed) return;   // first guard — already crashed

        int newRow = row, newCol = col;
        if (direction == 'U') newRow--;
        else if (direction == 'D') newRow++;
        else if (direction == 'L') newCol--;
        else if (direction == 'R') newCol++;

        if (newRow < 0 || newRow >= rows ||
            newCol < 0 || newCol >= cols) {
            crashed = true;    // crash on out-of-bounds
            return;
        }
        row = newRow;
        col = newCol;
    }

    public boolean isCrashed() { return crashed; }
}

The two guards

1. Already crashed? Return immediately without changing anything.
2. Move out of bounds? Set the crash flag and return without moving.

The order matters: check the existing flag first, then compute and validate the new position.

Sticky flag

The crash flag is sticky — it only ever goes from false to true. There's no uncrash() method. This is intentional: the object is permanently disabled after the first crash.

Running a sequence

public void runCommands(String commands) {
    for (int i = 0; i < commands.length() && !crashed; i++) {
        move(commands.charAt(i));
    }
}

The loop's !crashed check is technically redundant (the move method already short-circuits) but cleaner and slightly faster.