How to Write Your First Java Program: Step-by-Step

Writing my first Java program was the gateway to understanding how this powerful language works. Once I grasped the basic structure, the process of creating applications became far less intimidating. The beauty of Java is that it provides a consistent framework for organizing code, and once I mastered that foundation, I could build anything from small utilities to complex enterprise-level systems.

In this guide, I’ll walk through how to write your first Java program: step-by-step, sharing the exact approach I use when introducing new developers to Java. I’ll explain how to set up the environment, write the code, compile it, run it, and even troubleshoot common issues along the way. This way, by the time you reach the end, you’ll have a fully functional Java program running on your machine.

Installing Java Development Kit (JDK)

Before writing any code, I need the Java Development Kit (JDK). The JDK contains all the tools required to compile and run Java programs. Without it, the computer has no way of translating Java code into something the machine understands.

To get started, I visit Oracle’s official website or OpenJDK’s site and download the version of JDK that matches my operating system. During installation, I make sure to note where the JDK is being installed because I’ll need that path later for setting environment variables.

On Windows, I also configure the JAVA_HOME environment variable and add the JDK’s bin directory to my system’s PATH. This step ensures that I can run Java commands from the terminal or command prompt without specifying full file paths.

Setting Up a Development Environment

While it’s possible to write Java code in any text editor, I prefer using an Integrated Development Environment (IDE) because it makes coding faster and more intuitive. IDEs like IntelliJ IDEA, Eclipse, or NetBeans provide features like code highlighting, auto-completion, and built-in debugging tools.

For beginners, I recommend starting with IntelliJ IDEA Community Edition or Eclipse. These tools simplify the process of creating projects and running code, which is helpful when focusing on the basics of how to write your first Java program: step-by-step.

Once my IDE is installed, I configure it to point to the JDK I installed earlier. Most IDEs prompt me to do this during the initial setup, but it can also be done later through the settings menu.

Creating a New Java Project

In the IDE, I create a new Java project. The IDE typically asks for the project name, location, and JDK version. I give the project a meaningful name like HelloWorldProject so I can identify it easily in the future.

The IDE automatically creates a project folder with a structure that includes a src directory for source code. This is where all my .java files will go.

Writing the Java Code

Every Java application starts with at least one class and a main method. The main method is the entry point for the program when I run the application, Java looks for this method to start execution.

Here’s my first program:

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

The program does exactly what it looks like it prints Hello, World! to the console. Each part has a role:

• public class HelloWorld declares a class named HelloWorld.
• public static void main(String[] args) defines the method that starts execution.
• System.out.println("Hello, World!"); prints a message to the screen.

Even in such a small program, I’m already seeing how Java structures its code: every statement ends with a semicolon, code blocks are enclosed in curly braces, and classes are the foundation.

Saving and Compiling the Program

When working outside an IDE, I can write this program in a plain text editor like Notepad, save it as HelloWorld.java, and compile it manually.

To compile from the command line, I navigate to the folder containing my .java file and type:

nginx javac HelloWorld.java

If there are no errors, the compiler creates a HelloWorld.class file, which is the bytecode version of my program.

Running the Program

To run the compiled program, I type:

nginx java HelloWorld

The output should display:

 Hello, World!

It’s important not to include the .class extension when running the program Java only needs the class name.

How the Compilation Process Works

When I run javac HelloWorld.java, the Java compiler translates my source code into bytecode. Bytecode is a platform-independent format that can run on any system with the Java Virtual Machine (JVM). This is one of Java’s biggest strengths write once, run anywhere.

The java HelloWorld command then starts the JVM, which interprets and executes the bytecode, producing the output I see on the screen.

Adding More Functionality

Once the basic program works, I can start expanding it. For example, I can add variables, take user input, or perform calculations.

Example with user input:

java import java.util.Scanner;

public class HelloWorld {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter your name: ");
        String name = scanner.nextLine();
        System.out.println("Hello, " + name + "!");
    }
}

Now, instead of always greeting the world, the program greets me personally. I can already see how even small changes can make my programs more interactive.

Organizing Code into Methods

To keep code clean and readable, I start breaking tasks into separate methods. This helps when following how to write your first Java program: step-by-step because it introduces structured thinking early.

Example:

java public class HelloWorld {
    public static void main(String[] args) {
        greetUser("Alice");
    }

    public static void greetUser(String name) {
        System.out.println("Hello, " + name + "!");
    }
}

Here, greetUser is a separate method that takes a name and prints a greeting. This makes the program easier to expand later.

Common Errors and How to Fix Them

When writing my first Java programs, I often ran into simple mistakes:

• Missing semicolons: Every statement in Java must end with a semicolon.
• Case sensitivity: Java treats uppercase and lowercase letters differently. Typing system.out.println instead of System.out.println causes an error.
• File naming: If a public class is named HelloWorld, the file must be saved as HelloWorld.java.
• Incorrect main method signature: The exact form public static void main(String[] args) must be used.

Recognizing these early saved me hours of debugging.

Adding Comments for Clarity

I use comments to explain what my code does. This is a habit worth building from the very first program.

Example:

java // This program prints a greeting to the user
public class HelloWorld {
    public static void main(String[] args) {
        // Print the greeting
        System.out.println("Hello, World!");
    }
}

Java supports both single-line (//) and multi-line (/* ... */) comments.

Formatting and Code Style

Readable code is easier to maintain. I follow conventions such as:

• Indenting code inside methods and loops.
• Using descriptive names for variables and methods.
• Placing opening braces on the same line as the declaration.

A well-formatted first program sets the tone for future projects.

Moving Beyond the Basics

After creating my first program, the next step is to experiment with more complex ideas loops, conditional statements, and object-oriented concepts. The skills developed while following how to write your first Java program: step-by-step are the same ones I use in more advanced applications.

For example, adding a simple loop:

java public class Counter {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Count: " + i);
        }
    }
}

This introduces control flow and shows how Java executes repetitive tasks.

Troubleshooting Runtime Problems

Sometimes a program compiles fine but behaves unexpectedly when run. In these cases, I use print statements to display variable values and track what’s happening. For larger projects, IDEs provide built-in debuggers that let me pause the program and inspect variables at different points.

Saving Multiple Programs in a Project

Once I know how to write one Java program, I can add more files to the same project. Each file can contain a separate main method, and I can run them individually. This is useful for organizing different exercises or experiments without mixing them into one file.

Experimenting with Different Output Styles

Java’s System.out.print and System.out.printf methods let me format output neatly. For example:

java double price = 19.99;
System.out.printf("The price is $%.2f%n", price);

This control over formatting helps make programs look professional.

Building Confidence

The key to getting comfortable with Java is repetition. The more I practice writing small programs, the more confident I become in using the language. Starting with a clear structure, as outlined in how to write your first Java program: step-by-step, builds a solid base for learning advanced features later.

Conclusion

Creating my first Java program wasn’t just about writing a few lines of code it was about learning the workflow from installation to execution. By setting up the JDK, using an IDE, writing the code, compiling, running, and troubleshooting, I built the exact skills I now use in every Java project. The process I’ve shared is the same approach I’d recommend to anyone starting out. With these fundamentals in place, it’s easier to move into more complex programming concepts and begin building real-world applications.