You've installed Java. You've written your first "Hello World" class. Now comes the part that actually matters: turning that file into a running program. This is the full walkthrough — from a blank text file to a terminal output — so you know exactly what happens at every step.

Why Does This Matter?

Most tutorials skip the "how do I actually run this?" part. They show you the code and assume you'll figure out the rest. But understanding the end-to-end flow — writing, compiling, and executing — gives you a mental model that pays off for years. You'll know where errors come from, how to fix them, and how Java really works under the hood.

What You'll Need

• A text editor (VS Code, Notepad++, or even Notepad)
• Java Development Kit (JDK) installed (version 8 or later)
• A terminal or command prompt

If you haven't installed the JDK yet, check out the first article in this series: How to Download and Install Java JDK.

Step 1: Write the Code

Open your text editor and create a new file called HelloWorld.java. The filename must match the class name exactly — that's not a suggestion, it's a rule.

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

A few things to note:

• public class HelloWorld — This defines a class named HelloWorld. In Java, everything lives inside a class.
• public static void main(String[] args) — This is the entry point. When you run a Java application, the JVM looks for this specific method.
• System.out.println(...) — This prints a line to the terminal.

Save the file. Make sure it's HelloWorld.java with a capital H and W.

Step 2: Open a Terminal

Navigate to the folder where you saved HelloWorld.java. On most systems:

• Windows: Open Command Prompt, type cd C:\path\to\your\folder
• Mac/Linux: Open Terminal, type cd /path/to/your/folder

Verify the file is there by listing the directory contents:

ls    # Mac/Linux
dir   # Windows

You should see HelloWorld.java in the list.

Step 3: Compile the Code

Java is a compiled language. That means you can't run .java files directly — you need to turn them into bytecode first. The javac compiler does this.

javac HelloWorld.java

If everything is correct, you won't see any output. That's actually good news — it means the compilation succeeded. Check the directory again, and you'll see a new file: HelloWorld.class.

That .class file contains the bytecode the JVM can execute. You don't need to read it, but it's good to know it exists.

Common Errors at This Stage

• "javac: command not found" — Your JDK isn't installed or the PATH isn't set up correctly.
• "class HelloWorld is public, should be declared in a file named HelloWorld.java" — Your filename doesn't match the class name.
• "cannot find symbol" — You have a typo in your code. Check spelling and capitalization.

Step 4: Run the Program

Now that you have the compiled bytecode, run it with the java command:

java HelloWorld

Notice you don't type the .class extension. The JVM looks for a class with that name in the current directory (or wherever the classpath points).

You should see:

Hello from Java!

That's it. You just ran your first Java application end to end.

What Happened Behind the Scenes?

Here's the full chain:

1. You wrote source code in a .java file.
2. javac compiled it into bytecode in a .class file.
3. java launched the JVM, which loaded your class and executed the main method.
4. System.out.println sent text to your terminal.

This three-step process — write, compile, run — is fundamental to Java. Every Java application follows this pattern, whether it's a simple script or a massive enterprise system.

Making It More Interesting

Let's modify the program to do something slightly more dynamic:

public class Greeter {
    public static void main(String[] args) {
        String name = args.length > 0 ? args[0] : "Developer";
        System.out.println("Welcome, " + name + "!");
    }
}

Save this as Greeter.java, compile it, and run it:

javac Greeter.java
java Greeter

Output:

Welcome, Developer!

Now try passing a name:

java Greeter Jamilur

Output:

Welcome, Jamilur!

You've just used command-line arguments — a common pattern in real-world Java applications.

The Anatomy of a Java Program

Let's break down the structure one more time:

• Class declaration: public class ClassName — defines the blueprint.
• Main method: public static void main(String[] args) — the entry point.
• Statements: Lines ending with ; that do something.
• Strings: Text enclosed in "double quotes".
• System.out.println: The standard way to print output.

Every Java application you write will follow this skeleton. The details change, but the structure stays the same.

Key Takeaways

• Java source code lives in .java files and must match the public class name.
• Use javac ClassName.java to compile code into bytecode (.class files).
• Use java ClassName to run the compiled bytecode.
• The main method is where execution starts — without it, nothing runs.
• Command-line arguments let you pass data into your program at runtime.

What's Next?

Now that you can write, compile, and run Java programs, the natural next step is learning how the Java launcher works under the hood — classpaths, modules, and JVM flags. That's where things get interesting, and it's covered in the next article: How Java Launcher Works.

Based on dev.java/learn — Running Your First Java Application