Java If, Else If, and Else

A boolean asks a question; if chooses what to execute

The operators lesson produced true or false. An if statement uses that answer to decide whether to execute a statement or block. Write the boolean condition in parentheses, then put the conditional work inside braces. In the first example, practiceMinutes >= 20 is false, so the target message is skipped.

After that skipped block, execution continues with Report complete. A false if condition does not automatically stop the program or skip every later statement. Change the minutes to 20 and trace the two output lines: the conditional message now runs, followed by the same final message.

Use a boolean expression, not a count by itself. Java does not treat a nonzero int as true. A condition such as seatsAvailable > 0 explains the intended meaning better than attempting if (seatsAvailable). Read each condition aloud as a question before deciding which work belongs inside its braces.

public class Main {
    public static void main(String[] args) {
        int practiceMinutes = 17;
        if (practiceMinutes >= 20) {
            System.out.println("Practice target reached.");
        }
        System.out.println("Report complete.");
    }
}

Select Run code to compile and execute this program.

Report complete.

if and else choose between two alternatives

An else supplies the alternative when the if condition is false. For one execution of this if/else statement, only one of its two branches is selected. With zero seats, the no-seats message is selected; with a positive seat count, the available message is selected.

The final Checked capacity line is outside both branches, so it runs after either branch completes normally. Keep that shared work outside when it genuinely belongs to both paths. If a selected branch returns or throws, control does not simply fall through to that line; the guard-clause example will make that difference explicit.

else does not take a condition in parentheses. For another condition, write else if instead. Also distinguish an alternative message from a validation policy: this small example reports no seats for any nonpositive value, but does not establish that a negative stored capacity is acceptable input. The chosen domain still needs to be defined.

public class Main {
    public static void main(String[] args) {
        int seatsAvailable = 0;
        if (seatsAvailable > 0) {
            System.out.println("A seat is available.");
        } else {
            System.out.println("No seats available.");
        }
        System.out.println("Checked capacity.");
    }
}

Select Run code to compile and execute this program.

No seats available.
Checked capacity.

An else-if chain stops at its first true condition

Suppose a delivery rule offers free shipping at 5000 cents, a standard tier at 2500 cents, and a small-order tier below that. A subtotal of 5000 satisfies both >= 5000 and >= 2500. The order of the branch chain decides which matching rule gets selected.

Evaluate from top to bottom. At 5000, the first condition is true, its block runs, and the remaining else-if conditions and final else are not selected. At 3000, the first condition is false and the second true. At 1000, both conditions are false, so the final else runs. This is a first-match decision, not a process that runs every true block.

Put overlapping thresholds in an order that implements the policy. Here the highest threshold comes first. The second branch needs only >= 2500 because arriving there already means the first threshold was not met. These examples assume a valid nonnegative subtotal; the lab validates invalid and empty cases before choosing a shipping tier.

public class Main {
    public static void main(String[] args) {
        int subtotalCents = 5000;
        if (subtotalCents >= 5000) {
            System.out.println("Free shipping tier.");
        } else if (subtotalCents >= 2500) {
            System.out.println("Standard shipping tier.");
        } else {
            System.out.println("Small-order shipping tier.");
        }
    }
}

Select Run code to compile and execute this program.

Free shipping tier.

Independent if statements answer independent questions

Two separate if statements are two separate decisions. A score of 85 meets both the foundation and advanced targets, so printing both achievements is reasonable. Joining them with else if would select only the first matching achievement and hide the other, which would be the wrong model for this report.

The else below belongs to the second if, not to the whole sequence of previous decisions. At a score of 60, the program prints Foundation target met and Advanced target not met. Those messages are compatible: one achievement was reached and another was not. Trace the braces rather than guessing from the visual proximity of a line.

Choose separate checks when multiple outcomes are allowed, such as independent warnings or achievements. Choose one chain when exactly one classification or price tier should win. If independent checks repeatedly assign the same result variable, a later assignment can overwrite an earlier one; that is the defect in the repair exercise.

public class Main {
    public static void main(String[] args) {
        int score = 85;
        if (score >= 50) {
            System.out.println("Foundation target met.");
        }
        if (score >= 80) {
            System.out.println("Advanced target met.");
        } else {
            System.out.println("Advanced target not met.");
        }
    }
}

Select Run code to compile and execute this program.

Foundation target met.
Advanced target met.

Braces define the controlled work; indentation only helps readers

Without braces, a plain if controls only its next statement. Indenting a second statement does not add it to the branch. Use braces consistently so adding a log message or calculation does not silently change which work is conditional. In nested code, braces also make the relationship between each if and else easier to see.

Do not put a semicolon immediately after the closing parenthesis of an if condition. In if (ready); the semicolon is an empty statement controlled by the if. A following braced block is then separate work and can execute even when ready is false. The program can compile while doing the opposite of what its indentation suggests.

An else associates with the nearest eligible unmatched if according to Java's syntax, not whichever earlier if looks closest to its indentation level. Prefer explicit braces instead of relying on that dangling-else rule. Match the opening and closing braces after each edit, then run both true and false paths.

A nested decision is reached only through its outer branch

The tools-preview example first asks whether the user is signed in. Only the true path then asks whether the user is a teacher. With signedIn true and teacher false, the inner else selects Student tools preview. If signedIn is false, neither inner tools branch is reached.

Nesting is useful when the second question only makes sense inside the first path. If several independent requirements simply need to be true together, a clear && expression may be shorter. Choose the structure that explains the decision rather than assuming deeper indentation means more complete validation.

These booleans are fixed teaching values. Printing a tools label does not authenticate a user, grant a role, or protect server resources. A real application needs trusted checks where an action is performed. For this example, change the two booleans through all combinations and explain which question is actually reached.

public class Main {
    public static void main(String[] args) {
        boolean signedIn = true;
        boolean teacher = false;
        if (signedIn) {
            if (teacher) {
                System.out.println("Teacher tools preview.");
            } else {
                System.out.println("Student tools preview.");
            }
        } else {
            System.out.println("Sign in first.");
        }
    }
}

Select Run code to compile and execute this program.

Student tools preview.

A guard clause handles an early exit before the main work

A guard clause checks an unacceptable or special case near the top and exits that path. The name example handles a missing or blank value first. Its || short-circuit prevents isBlank from being called on null. Printing the required-name message explains the rejection; return then ends main.

Without that return, execution would continue and might call strip on null or print a misleading success message for blank input. Printing an error is not itself an exit. Always trace the statement after the guard block and ask whether the rejected path can still reach it.

After the guard returns for invalid inputs, the remaining code can be read as the accepted path. In these programs return exits main; inside another method it would exit that method, not magically stop every application thread. Use a small number of purposeful guards to reduce nesting without scattering unexplained exits throughout a large method.

public class Main {
    public static void main(String[] args) {
        String name = null;
        if (name == null || name.isBlank()) {
            System.out.println("A name is required.");
            return;
        }
        System.out.println("Welcome, " + name.strip() + "!");
        System.out.println("Profile preview ready.");
    }
}

Select Run code to compile and execute this program.

A name is required.

A result must be in scope and assigned on every path that uses it

A variable declared inside a branch block is local to that block. If a result is needed after the whole decision, declare it in the enclosing scope, then assign it in the appropriate branches. The status example declares one String variable before the if/else and assigns it on both continuing paths.

Java checks definite assignment before a local variable is read. Removing the else assignment can make the later print fail compilation, because the compiler cannot establish a value for every path. This matters even when you happen to expect a positive seat count at runtime. Do not silence the problem with a meaningless default merely to hide a missing case.

A path that returns before the later read does not need to assign the result for that read. That is how early guards and later complete classifications fit together. Explain each continuing path and the value it supplies. Shared calculations can then follow the branch rather than being copied into every block.

public class Main {
    public static void main(String[] args) {
        int seatsAvailable = 2;
        String status;
        if (seatsAvailable > 0) {
            status = "Available";
        } else {
            status = "Full";
        }
        System.out.println("Status: " + status);
    }
}

Select Run code to compile and execute this program.

Status: Available

Write boundary expectations before running the code

For the shipping tiers, test 2499, 2500, 2501, 4999, 5000, and 5001 cents. These values exercise both exact thresholds and their immediate neighbours. Testing only a very small and a very large subtotal can miss a mistaken > where the rule requires >=.

Also test different paths, not just different numbers. The lab has missing input, text that cannot be parsed, a negative subtotal, an empty order, and each normal tier. A successful compilation does not prove that the branch order, fallback, or input policy is correct. Specify the expected output for each kind of path first.

Conditions are evaluated when execution reaches them. If you store a boolean and later change its input, that stored boolean does not update itself. Likewise, a selected if block is not a background rule that reruns whenever a variable changes. Make the timing of updates and decisions explicit when reading a trace.

Optional: use ?: for a small choice of one value

The conditional expression condition ? valueWhenTrue : valueWhenFalse selects one value. In the example, quantity == 1 chooses item; other quantities choose items. The selected value is assigned to unit, then used in one shared print statement. Only the selected alternative expression is evaluated.

This is an expression rather than an if statement: it produces a value with a type determined by Java's rules. Here both alternatives are Strings, keeping that type choice simple. It is not a replacement for arbitrary blocks of statements or a reason to hide multiple side effects inside one dense line.

Use an ordinary if/else for larger work, multiple statements, or a policy that benefits from named branches. Avoid nested conditional expressions while learning. The wording example also assumes an appropriate nonnegative quantity; choosing a plural word does not validate the number.

public class Main {
    public static void main(String[] args) {
        int quantity = 1;
        String unit = quantity == 1 ? "item" : "items";
        System.out.println(quantity + " " + unit);
    }
}

Select Run code to compile and execute this program.

1 item

A block runs even when the condition is false

Look for a stray semicolon after if (...) or a statement outside the intended braces. Indentation does not define a Java block. Run both truth values after repairing the structure.

The wrong price tier wins

Check overlapping conditions and their order. An else-if chain selects the first true condition. Separate if statements can select several branches and overwrite a result. Match the structure to the policy.

The exact threshold falls into the lower tier

Translate at least as >= rather than >. Test the boundary itself as well as its immediate neighbours. A few far-away passing values will not reveal the missing equality case.

An error message is followed by a success result

Printing an error does not stop execution. Use an appropriate return or alternative branch so rejected input cannot reach the normal result calculation.

cannot find symbol or variable might not have been initialized

A result may be declared only inside a branch, or a continuing path may never assign it. Declare shared results in the proper enclosing scope and cover every continuing case rather than adding arbitrary defaults.

An else belongs to the wrong if

Inspect the syntax and matching braces. An else pairs with its nearest eligible unmatched if, not the indentation you intended. Explicit blocks and a smaller decision structure make the relationship visible.

References and related learning

The decision scenarios, examples, explanations, and exercises are original SovranCode material. These official references support the language rules.

• Java 21 specification: if statements
• Java 21 specification: blocks and statement structure
• Java 21 specification: definite assignment
• Java 21 specification: conditional expressions

Review input validation · Review conditions and boundaries · Java course roadmap.

Last updated: 21 October 2026