Java Syntax Fundamentals: Program Structure and Writing Rules

Java code must be saved in a file with the .java extension, and the file name must match the public class name exactly, including upper and lower case.

• Public class is HelloWorld then the file must be HelloWorld.java
• Public class is MyApp then the file must be MyApp.java
• A file called helloworld.java holding a class called helloworld will not match

This trips up almost every beginner exactly once. The simple habit that prevents it: give the class the same name as the file and match the capital letters. This is because Java is case-sensitive, which means Java and java are two completely different words to the compiler.

What Does Case Sensitive Mean?

It means the computer treats upper case and lower case letters as different characters. name, Name and NAME are three separate identifiers. There is no forgiveness here at all.

Look at the very first line of the program:

public class HelloWorld {

That one line does three different jobs at once.

A class is like a blueprint. The program above is a blueprint for something that knows how to print a message. You will study classes much more deeply later, but for now remember one simple fact: Java is not a language where you scatter loose lines of code around. The code lives inside classes. It is the difference between leaving papers on a desk and filing them in a cabinet.

Also notice the opening curly brace { at the end of that line. Every { must have a matching }, and in this program the class closing brace is the very last line. If you forget it, the compiler message can be oddly unhelpful, something like reached end of file while parsing, but nine times out of ten the answer is simply that one } is missing.

This is the line most beginners cannot quite decode:

public static void main(String[] args) {

You do not need to fully understand every word yet. What you do need to know right now is that main is the entry point of a Java program. When you run a program, Java looks for this exact method and starts executing from inside it. No main, no execution.

Here is what each piece means in plain English.

• public means anyone can call this method.
• static means it can run without creating an object first. The object oriented details come later, so trust this word for now.
• void means this method gives nothing back to anyone. It just does its job.
• main is the special name. Spell it exactly this way, in lower case.
• (String[] args) is the list of things the method can receive. Ignore these for now and just copy them exactly as written.

Inside the method, look at this line:

System.out.println("Hello, Java World!");

It is doing real work, printing text to the screen, and notice the small mark at the end. That is the semicolon. In Java almost every instruction must end with one. Think of it as the full stop at the end of an English sentence, because without it the compiler does not know where one instruction ends and the next one begins.

A very common first week mistake looks like this:

// This will NOT compile:
int age = 25System.out.println(age);
//                ^ the semicolon after 25 is missing

The compiler message for that is famously blunt: "; expected". When you see it, your job is simple. Scan the current line and the line above it for a missing semicolon.

Where semicolons are not needed: after the class declaration, after a method declaration, and after any line ending with { or }. Only actual instructions get semicolons. This "only sometimes" confusion is completely normal and fades quickly once you write code every day.

Curly braces in Java answer one question: which statements belong to which block? In the example the method body contains exactly one statement. Add a second line and it simply goes inside the same pair of braces.

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Java World!");
        System.out.println("This is line two.");
    }
}

Here is a rule that saves you from hours of mystery debugging: count your braces. Opening braces: 2. Closing braces: 2. Balanced. The moment the count is off by one, you have a syntax problem, and the error may point at a line that is actually fine, because the real mistake is a misplaced brace three lines earlier. When you hit a strange error, step one is to count braces.

Technically Java does not care about your indentation. You could write the whole program on one line and it would still run:

public class HelloWorld {
    public static void main(String[] a) {
        System.out.println("Hi");
    }
}

Does it compile? Yes. Will it run? Yes. Would a human being thank you for that code? No.

By convention we indent the code inside each block by four spaces or one tab. Indentation is the difference between a code file and an unreadable run-on sentence. Good editors such as IntelliJ, Eclipse or VS Code handle it for you automatically when you press Enter after a { and press Tab to move out, so never type your indentation by hand and never mix tabs with spaces in the same file.

Java owns roughly fifty keywords: class, public, static, void, int, if, while, return, new, String and many more. These words already have jobs, so you are not allowed to use them as your own variable or class names.

// Broken: "class" is a reserved keyword
int class = 10;
// compile error
// Fine: "classroom" is not a keyword
int classroom = 10;
// compiles perfectly

You do not need to memorise all the keywords yet. Every editor highlights them in a distinct colour, usually blue or purple, and that colour is your brain learning to recognise them. Learn to read your editor.

Sometimes you want to leave a note inside your code, for a teammate or for future you. That is what comments are for.

// This is a single-line comment. Java ignores it completely.
/*
This is a multi-line comment.
It can stretch across several lines,
which makes it perfect for explaining tricky logic.
*/

The compiler ignores comments completely, so you could put a whole novel inside one and nothing would change about how the program runs. Here is advice based on experience though: comment why, not what. A comment that repeats the code, such as // print the number, only adds noise. A comment that explains the reason behind a decision, such as // retry after 2 seconds because the API rate-limits us, is genuinely useful to the next person.

Let us put every rule together. This is the hello world program with each part labelled.

// the class. The file must be named HelloWorld.java
public class HelloWorld {
    // the entry point. Java starts executing here
    public static void main(String[] args) {
        // an instruction, and it ends with a semicolon
        System.out.println("Hello, Java World!");
    } // closing brace for the method
} // closing brace for the class

Read that block once slowly. A file with a matching name, one public class, one main method, statements with semicolons, matched braces and sensible indentation. That is the entire skeleton, and everything you will ever write in Java is this same skeleton with more furniture added inside.

One picture in your head saves you from ninety percent of beginner syntax errors. Keep this order in mind.

1. The file, named exactly after the public class.
2. The class, the outer container for everything.
3. The methods, the blocks of behaviour inside the class, including main.
4. The statements, the actual instructions, each ending with a semicolon.

If you ever feel lost inside a Java error message, check the order from the outside in. Is the file named correctly? Is the class declared? Is main spelled correctly? Is the statement finished with a semicolon? Is every brace matched? Working top-down like this, almost every beginner error is found in under a minute.

One extra note on that last row, because it catches people who copy code out of a document. If the code came from a PDF or a Word file, the straight quotes may have been converted into smart curly quotes. Java only understands straight quotes, so when a string error appears out of nowhere, retype the quotes yourself instead of pasting them.

Quick Self Check

Before moving on, try answering these out loud, or to your dog, there is no judgement.

• Why must the file name match the public class name?
• Which method does Java always start executing from?
• Which punctuation mark ends a statement?
• What are curly braces used for in Java code?
• Name one thing you must never use as a variable name.

If you answered all five without checking the page, you have genuinely learned this rather than simply memorised it, and that is the difference that shows up three months from now.

Frequently Asked Questions

Do I have to memorise the main method line?

Type it by hand for your first ten to twenty programs and then let your editor autocomplete write it for you. Knowing it matters more than typing it, because that way you still know what is there when the autocompleter is off or you are at a whiteboard.

Can a Java file contain more than one class?

Yes, a file can contain several classes, but only one of them can be public, and that public class must match the file name. Beginners should keep it simple with one file and one class.

Why does Java need so many braces compared to Python?

Python uses indentation to define blocks while Java uses braces. Both approaches work, they are just different rule books. Braces are sometimes clumsier to type, but they make block boundaries visible even when the indentation becomes messy.

What happens if I get the order of keywords wrong, such as writing void public static?

Java is strict about the sequence. Modifiers come first, such as public static, then the return type void, then the name main. A different order means a syntax error, so learn the correct order once and it stops being confusing.

Is capitalisation really that important in Java?

Yes. Main is not main, and String is not string. This single rule causes more beginner errors than everything else combined, so when you are stuck on a cannot find symbol error, check capitalisation before anything else.

Do I really need indentation if the compiler does not require it?

The compiler does not require it, but you do. Broken indentation is the reason a small brace mistake turns into an hour of hunting, because you can no longer see which block a line belongs to. Let your editor handle it so the structure is always visible at a glance.

What To Learn Next

You now hold the skeleton of every Java program you will ever write. The natural next steps in your tutorial series are Java variables and data types, the first furniture you will place inside that skeleton, then Java output with System.out, and finally how your .java file is compiled and executed by the javac and java commands.

Write the hello world program three times before moving on: once carefully, once from memory, and once with the comments added. The third attempt is where it truly sticks. Happy coding.