skip to content

What is the role of the semicolon in Java, and what counts as a statement that needs one?

level: juniorimportance: must knowfreq 40%

answer

  1. Semicolon = period: terminates a statement
  2. Yes: declarations, assignments, calls, return/break/throw
  3. No: after } of blocks, after if/for/while headers
  4. Stray ';' after for/if = empty body bug
  5. do-while and enum field list are the brace+; exceptions

basics

~20 s

The semicolon ends a statement, like a period ends a sentence. Each instruction - a variable declaration, an assignment, a method call, return - finishes with a ';'. Blocks wrapped in { } and class/method headers do not take one.

solid answer

~40 s

Java is a statement-terminated language: a semicolon explicitly marks the end of a statement, so the compiler knows where one instruction stops and the next begins. It is required after expression statements (assignments, method calls, increments), local-variable declarations, return/break/continue/throw, and the empty statement is just a lone ';'. It is NOT used after a block's closing brace '}' (an if/for/while body, a method body, a class body), nor after the parentheses of an if/for/while/method header. Because Java terminates rather than separates, line breaks are irrelevant - you may put several statements on one line or split one statement across many lines. This explicitness is why Java has none of the automatic-semicolon-insertion surprises that JavaScript has.

code

java · 8 lines
java
// The trailing ';' becomes the entire loop body (empty statement):
for (int i = 0; i < 3; i++);   // loop does NOTHING three times
    doWork();                  // runs ONCE, after the loop

// Correct form - body in braces, no stray ';':
for (int i = 0; i < 3; i++) {
    doWork();                  // runs three times
}

go deeper

for a junior

Knows ';' ends a statement and that declarations/assignments/calls/return need one while { } blocks and if/for headers do not.

for a middle

Explains termination vs separation, lists statement kinds, and identifies the stray-semicolon empty-statement bug after a loop or if header.

for a senior

Articulates the do-while and enum-field-list exceptions where ';' follows a brace, notes the empty statement as a language construct, and contrasts with JavaScript ASI.

for a principal

Discusses why explicit termination (vs ASI) improves grammar predictability and tooling/codegen, and how empty-statement pitfalls are caught structurally by linters rather than by the compiler.

## What a statement is A **statement** is a complete instruction that tells the program to *do* something - declare a variable, assign a value, call a method, return from a method, loop, branch. It is the executable unit of a method body. An **expression** computes a value (`a + b`, `list.size()`); an expression becomes a **statement** when you end it with a semicolon and execute it for its effect (`list.add(x);`). ## The semicolon's job: termination Java is a **statement-terminated** language, meaning every statement is explicitly ended with a **`;`**. Think of it as the period at the end of a sentence: it tells the compiler exactly where one instruction finishes so the next can begin. Because the terminator is explicit, **line breaks and spacing do not matter** - the compiler relies on the `;`, not on where lines end. So all of these are legal and equivalent: ```java int a = 1; int b = 2; // two statements on one line int c = a + b; // one statement across three lines ``` ## What needs a semicolon - **Local variable declarations:** `int count = 0;` - **Assignments:** `count = count + 1;` - **Method/constructor-call statements:** `System.out.println(count);` - **Increment/decrement used as statements:** `count++;` - **`return`, `break`, `continue`, `throw`:** `return count;`, `break;` - **The empty statement:** a bare `;` that does nothing (occasionally used as an empty loop body, but easy to write by accident). - **Field declarations** and **package**/**import** declarations also end in `;`. ## What does NOT take a semicolon - **A block** - code wrapped in braces `{ ... }`. The closing `}` of a method body, a loop body, an `if` body, or a class body is **not** followed by `;`. - **Control-flow headers** - the `if (...)`, `for (...)`, `while (...)`, `switch (...)` header line; the semicolon belongs (if at all) to the statements *inside* the body. - **Method and class declarations** - `void run() { ... }` ends with `}`, no semicolon. (Two historical exceptions where a `;` follows a brace: after the field list of an `enum`, and after a `do { ... } while (...);` because `while(...)` is the terminating expression.) ## A common bug: the stray semicolon Because a lone `;` is the *empty statement*, putting one right after a control header silently changes behaviour: ```java for (int i = 0; i < 3; i++); // <- this ; is the WHOLE loop body doWork(); // runs once, AFTER the loop, not 3 times ``` The loop runs three times doing nothing, then `doWork()` runs once. It compiles cleanly, which is what makes it dangerous - linters flag it as an "empty statement". ## Contrast with JavaScript JavaScript has **automatic semicolon insertion (ASI)**: it tries to add missing semicolons, which causes occasional surprises. Java has no ASI - if you omit a required `;`, you get a compile error, full stop. The explicitness trades a little typing for predictability.

  • Why does 'for (int i=0;i<3;i++);' compile but not loop as expected?
    The trailing ';' is an empty statement that becomes the entire loop body, so the loop spins doing nothing. Any indented code after it runs once, after the loop finishes. It is a classic accidental-empty-body bug.
  • Why does a do-while end with a semicolon after the brace?
    In 'do { ... } while (cond);' the while(cond) is the loop's terminating condition expression, and that whole statement is ended by the ';'. It is one of the few places a ';' legitimately follows a '}'.

A semicolon is the full stop at the end of a sentence. Just as 'I went home I slept' is ambiguous without punctuation, the compiler needs the ; to know where one instruction ends. A block { } is a paragraph - you don't put a full stop after a paragraph's closing.

saying these in an interview costs you the question

  • Saying semicolons separate statements rather than terminate them (subtle but Java terminates)
  • Adding ';' after the closing brace of an if/for/while/method block
  • Not recognizing a stray ';' after a loop header as an empty-body bug
  • Assuming each line must be one statement (line breaks are irrelevant)

context

resolving links…