Java Program Structure

What is Java program structure?

Java program structure is the standard arrangement of declarations and statements in a Java source file. It shows where a class is declared, where methods are written, where executable statements belong, and how braces define the boundaries of each code block.

Basic Java program structure

A simple executable Java program normally follows this structure:

class ClassName {
    public static void main(String[] args) {
        // statements
    }
}

Parts of a Java program

Class declaration in Java

Java code is organized into classes. A class declaration uses the class keyword, followed by the class name and a body enclosed in braces.

class HelloWorld {
    // class body
}

By Java naming convention, class names normally use PascalCase and begin with an uppercase letter, such as HelloWorld or StudentRecord.

The main() method in Java

The following declaration is the conventional entry point used by the Java launcher:

public static void main(String[] args) {
    System.out.println("Hello Java");
}

Meaning of each part

• public: makes the method accessible to the Java launcher.
• static: allows the method to be invoked without first creating an object.
• void: indicates that the method does not return a value.
• main: is the method name recognized as the application entry point.
• String[] args: receives command-line arguments as an array of strings.

Statements and semicolons

A statement is an instruction that tells Java to perform an action. Many statements end with a semicolon, which marks the end of the instruction.

System.out.println("Welcome to Java");

A semicolon does not follow every construct. For example, a class declaration, method declaration, or if block ends with a closing brace rather than a semicolon.

Braces and code blocks

Curly braces { } group statements into blocks. Classes, methods, loops, and conditional statements use blocks to define where their contents begin and end.

class Example {
    public static void main(String[] args) {
        System.out.println("Inside main block");
    }
}

Package and import declarations

Larger applications organize related classes into packages. Import declarations allow a source file to use types from other packages without writing their fully qualified names repeatedly.

package myapp;

import java.util.Scanner;

public class Example {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("Enter your name:");
        String name = input.nextLine();
        System.out.println("Hello " + name);
        input.close();
    }
}

Java filename rule

When a top-level class is declared public, its source filename must match the class name exactly, including uppercase and lowercase letters, followed by .java.

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

The correct filename is HelloWorld.java because the public class is named HelloWorld.

Execution flow of a Java program

1. Write the program in a .java source file.
2. Compile the source code with javac.
3. The compiler creates bytecode in a .class file.
4. The java launcher starts a JVM and loads the class.
5. The launcher invokes the class's main() method.

Complete Java program structure example

The following example combines a public class, the main method, a comment, and a statement.

public class ProgramStructureExample {
    public static void main(String[] args) {
        // This statement prints a message
        System.out.println("Java program structure is easy to understand.");
    }
}

Output

Java program structure is easy to understand.

How the example works

• public class ProgramStructureExample declares the public class.
• The source file must be named ProgramStructureExample.java.
• main() is the entry point used to start the program.
• The comment describes the purpose of the following statement.
• System.out.println() prints the message followed by a new line.

Common mistakes in Java program structure