Syntax, Error Messages and Debugging

This section explains the rules a Java program must follow, how to read the message the compiler prints when a rule is broken, and how a programmer fixes the problem.

The Rules for Writing Code

Syntax is the set of rules a programmer follows when writing code. In Java, a statement such as a line that prints ends with a semicolon. Every opening brace, `{`, needs a matching closing brace, `}`, because braces mark where a block of code begins and ends. Text sits inside a pair of double quotes, as in `"Canal Street"`. Java also treats a capital letter and a small letter as different characters, so `System` must start with a capital S. A reader of English can still follow a sentence with a missing period, but the compiler will not compile a program with a missing semicolon. Syntax is only about how code is written, so a program can follow every rule and still print the wrong answer.

Reading an Error Message

As an earlier lesson explained, the javac compiler turns source code into bytecode in a .class file. It checks that the program follows the syntax rules. When a rule is broken, javac makes no .class file and prints an error message instead, which is a report that names the file, the line and the problem the compiler noticed. The first line of a javac error message has three parts, separated by colons: the file, the line number and what went wrong. Under that line, javac prints the line of code it was reading and puts a caret, `^`, under the spot where it noticed the problem. Figure 1 shows a real message, `Stops.java:4: error: ';' expected`, with each part labeled. The file is Stops.java, the line is 4, and javac expected a semicolon at the end of `System.out.println(stops)`. An error message names the file, the line and what the compiler expected, but it does not always name the fix.

When the Line Is Not the Mistake

The line in an error message is where the compiler noticed the problem, which is not always where the mistake is. Each program below fails on purpose, and its first line is a comment. The compiler skips everything from `//` to the end of that line, but the comment still counts as line 1. The next program is missing the closing brace for the class.

1// This does not compile.
2public class Stops {
3    public static void main(String[] args) {
4        System.out.println("Next stop: Canal Street");
5    }

Stops.java:5: error: reached end of file while parsing
    }
     ^
1 error

The message points at line 5, which is the last line of the file. The mistake is a brace that was never written, and javac noticed only when it ran out of code to read.

Some messages name what the compiler saw instead of the fix. The program below writes `system` with a small s.

1// This does not compile.
2public class Stops {
3    public static void main(String[] args) {
4        system.out.println("Next stop: Canal Street");
5    }
6}

Stops.java:4: error: package system does not exist
        system.out.println("Next stop: Canal Street");
              ^
1 error

Because a small s and a capital S are different characters, javac reads `system` as a different name from `System`, and it reports that no package called system exists. The message never says to use a capital S, so the programmer works out the fix from what the message describes.

Finding and Fixing a Problem

Debugging is finding the cause of a problem, fixing it and running the code again to check the fix. An OpenStax computer science textbook advises fixing only the first error message and then compiling again, because one syntax error can cause false alarms later in the code. For example, a programmer reads the message in Figure 1, opens Stops.java at line 4, adds the semicolon and compiles again. If a new message appears after that fix, the debugging is not finished yet. Changing lines at random until the message goes away is not debugging, because it does not find the cause or check the fix.

Code with no syntax errors can still be wrong. A program that compiles and prints 4 when it should print 5 has a mistake the compiler cannot see, because every rule was followed. A test with an expected output catches this kind of mistake, as the lesson on testing a change showed. The programmer runs the program, compares what it prints with what it should print, and looks for the cause when the two differ. Debugging covers both kinds of problems, the ones the compiler reports and the ones that only a test shows.

Summary

Syntax is the set of rules a programmer follows when writing Java code. When a rule is broken, javac makes no .class file and prints an error message that names the file, the line and what it expected. Debugging means finding the cause, fixing one thing and then compiling or testing again to check the fix.

Sources: Oracle, Common Problems (and Their Solutions) (n.d.); Oracle, About the Java Technology (n.d.); Oracle, The javac Command (n.d.); Oracle, The Java Language Specification, SE 21 (n.d.); Franchitti, Introduction to Computer Science (2024); course JDK, Stops.java (2026).