ReviseAlgo Logo

Introduction to Java

Your First Java Program

Write, understand, and dissect every token of a standard "Hello, World!" Java application.

Interview: Tests absolute fundamentals. Expect questions asking why main is static, whether it can be private, and why it returns void.

Last Updated: June 13, 2026 10 min read

The first program written when learning a language is the classic "Hello, World!" application. In Java, this simple program introduces several syntactic and structural conventions that apply to all Java source files.

Core Idea

Every executable line of code in Java must live inside a class, and execution begins at a specific main method signature.

Why It Matters

Dissecting the HelloWorld structure clarifies object initialization, memory visibility, and entry parameters.

Interview Lens

Candidates are asked why main is static, if the parameters can change, and what happens if a modifier is omitted.

Deconstruction of the Code

Here is the standard Java entry code template:

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

In-Depth Program Anatomy

The diagram above illustrates the structural layers of a simple Java application. The class declaration (HelloWorld) acts as the outer container matching the file name. Inside it, the main method is marked as static, making it directly addressable by the JVM without class instantiation, while System.out represents the output stream routing the printed string to the console.

Token Dissection

  • public (class modifier): Makes the class accessible to the JVM system. If a class is public, its name must exactly match the filename.
  • class (keyword): Used to declare a user-defined blueprint type.
  • HelloWorld (identifier): The name of class, starting with an uppercase letter following PascalCase.
  • public static void main(String[] args) (method header):
    • public: The JVM requires access from outside the package package structures.
    • static: Essential so that the JVM loader can invoke this method directly on the class without needing to allocate an instance in Heap memory.
    • void: The method does not return a value. Process exit codes are handled via the OS process level.
    • main: The exact method identifier the JVM searches for as the starting execution point.
    • String[] args: Holds command-line arguments passed to the application.
  • System.out.println:
    • System: A final class pre-imported from java.lang.
    • out: A static variable member of System holding a print stream handler.
    • println: A method that writes a string to output followed by a carriage return.

Common Pitfalls

  • Mismatching Filename and Class Name: Creating a class named HelloWorld inside a file named hello.java (case-sensitive mismatch).
  • Incorrect main Signature: Omitting static, using String args (missing brackets), or spelling main incorrectly (e.g. Main). This will compile but fail to run.

Best Practices

  • Check Arguments Length: Always validate the length of args array before accessing indices directly, preventing ArrayIndexOutOfBoundsException.
  • Follow Standard Formatting: Always group blocks with braces {} and use consistent spacing.

Interview-Relevant Information

Q1: Why must the main method be static?
Answer: If it were not static, the JVM would have to instantiate the class before calling it. However, class constructors can throw exceptions or require constructor arguments, creating a dependency loop during application bootstrap. Making it static allows execution to begin immediately.

Q2: Can we overload the main method?
Answer: Yes, you can define other methods with different parameters (e.g., public static void main(int a)). However, the JVM will only call the one matching the standard signature public static void main(String[] args) as the entry point.

Q3: Can we declare main with varargs?
Answer: Yes, public static void main(String... args) is a valid entry point signature.

Quick Checklist

Can you explain every single word in the classic Hello World class, describe what happens if main is not static, and write a program to print command-line arguments? If yes, you are ready for entry-level syntax evaluations.

Use Cases

Building basic command-line parser scripts that accept user-provided configurations.

Testing small class-level helper functions via localized temporary main methods.

Understanding boot configurations inside Spring Boot initialization layers.

Common Mistakes

Omitting String[] parameters array inside main signature, causing execution engine rejection.

Forgetting to compile the source code via javac before attempting to run it.