Your First Java Program: From Installation to Execution ~ Dev.

Welcome to the world of Java, one of the most enduring and widely-used programming languages on the planet. For decades, Java has been the backbone of countless applications, from large-scale enterprise systems and big data analytics to Android mobile apps and web servers. Its philosophy of "Write Once, Run Anywhere" (WORA) has made it a versatile and reliable choice for developers across the globe. This article is designed for the absolute beginner—someone who has heard of programming but doesn't know where to start. We will not just show you how to write your first program; we will explain why each step is necessary, demystifying the entire process from the ground up.

We will embark on a detailed journey, starting with the core concepts of the Java ecosystem, moving through the meticulous process of setting up your development environment on your machine, and culminating in the classic rite of passage for every programmer: writing and running a "Hello, World!" program. By the end, you will not only have executed your first piece of Java code but will also possess a foundational understanding of the tools and concepts that power it.

Chapter 1: Understanding the Java Trinity - JVM, JRE, and JDK

Before we download a single file, it's crucial to understand the landscape. In the Java world, you'll frequently encounter three acronyms: JVM, JRE, and JDK. They are related and build upon each other, forming the foundation of the Java platform. Grasping their individual roles is the first step toward true comprehension.

The Java Virtual Machine (JVM): The Engine of Portability

The JVM is arguably the most brilliant component of the Java ecosystem. Imagine you've written a set of instructions (your program). If you write it for a Windows computer, it won't naturally work on a Mac or a Linux machine, because they speak different "languages" at the hardware level. This is where the JVM comes in.

The JVM is an abstract computing machine, a "virtual" machine that resides within your physical machine. When you write Java code, it isn't compiled into machine code for a specific operating system (like C++ often is). Instead, it's compiled into a special intermediate format called bytecode. This bytecode is a universal language that any JVM can understand, regardless of the underlying operating system.

So, there's a specific JVM implementation for Windows, another for macOS, and another for Linux. When you run your Java program, the local JVM on that machine takes your universal bytecode, interprets it, and translates it into the native machine code that the specific OS and hardware can execute. This is the mechanism behind "Write Once, Run Anywhere." You, the developer, write your code once. The platform-specific JVMs do the heavy lifting of making it run everywhere.

Role: Executes Java bytecode.
Key Function: Provides platform independence.
Analogy: A universal translator. You speak one language (bytecode), and the translator speaks to the local audience (Windows, macOS, etc.) in their native tongue.

The Java Runtime Environment (JRE): The Execution Environment

If the JVM is the engine, the JRE is the complete car, ready to drive. The JRE includes the JVM, but it also provides a set of essential libraries and other files that your Java programs need to run. When someone says, "You need Java to run this application," they typically mean you need to install the JRE.

The JRE contains core libraries for tasks like input/output operations, networking, and graphics. Without these, even a simple program would require you to write an immense amount of code from scratch. The JRE packages the JVM and these core classes together into a single, installable unit, creating the "runtime environment" necessary for executing Java applications.

Composition: JVM + Core Java Libraries.

Role:

run

Audience:

The Java Development Kit (JDK): The Developer's Toolbox

This is what we, as developers, will be installing. The JDK is the "superset" of the three. It contains everything the JRE has (which, in turn, contains the JVM), but it adds a crucial collection of tools necessary for developing Java applications.

The most important tool in the JDK is the Java compiler (`javac`). This is the program that takes your human-readable Java source code (files ending in `.java`) and compiles it into the universal bytecode (files ending in `.class`) that the JVM can understand. The JDK also includes other useful utilities like a debugger (`jdb`) for finding and fixing errors, a documentation generator (`javadoc`), and tools for packaging and deploying applications.

Composition: JRE + Development Tools (like `javac`, `jdb`, `javadoc`).
Role: To write, compile, and debug Java applications.
Audience: Java developers.

In summary, the relationship is hierarchical: JDK > JRE > JVM. To develop Java, you need the JDK. The JDK includes the JRE to run your programs, and the JRE includes the JVM to execute the bytecode.

Chapter 2: Setting Up Your Development Environment

Now that we understand what we need—the JDK—it's time to install it and configure our system to recognize it. This process involves two main stages: downloading and installing the JDK, and then setting up environment variables so our operating system knows where to find the Java development tools.

Choosing a JDK Distribution

In the past, Oracle's JDK was the default choice. However, licensing changes have led to the rise of many excellent, free, and open-source JDK distributions built from the OpenJDK project. For beginners, these are fantastic choices. Popular distributions include:

Amazon Corretto: A production-ready distribution of OpenJDK used internally by Amazon. It's well-supported and free.
Adoptium (formerly AdoptOpenJDK): A community-led project providing high-quality OpenJDK builds.
Oracle OpenJDK: Oracle's own free, open-source build.

For this guide, we will use Amazon Corretto 17. Version 17 is a Long-Term Support (LTS) release, meaning it will be supported with security updates for many years, making it a stable and reliable choice for learning.

Step-by-Step Installation Guide

The installation process varies slightly depending on your operating system. Follow the section relevant to you.

A. Installation on Windows 10/11

Download the Installer:
- Navigate to the Amazon Corretto download page.
- Find Corretto 17 and select the "Windows x64" version.
- Download the `.msi` installer file.
Run the Installer:
- Locate the downloaded `.msi` file in your Downloads folder and double-click it to launch the installation wizard.
- [Image: Corretto Installer Welcome Screen] The first screen will be a welcome message. Click "Next".
- [Image: Corretto Installation Path Screen] The wizard will propose an installation path, typically `C:\Program Files\Amazon Corretto\jdk17.x.x_x`. It is highly recommended to keep this default path. Click "Next".
- [Image: Corretto Feature Selection Screen] This screen allows you to customize the installation. Crucially, ensure that the feature "Set `JAVA_HOME` variable" is enabled. This will automatically perform part of the environment variable setup for you, which is a huge convenience. Also, ensure "Add to `PATH`" is enabled. Click "Next".
- [Image: Ready to Install Screen] The wizard is now ready to begin. Click "Install". You may be prompted by User Account Control (UAC) to allow the installer to make changes to your device; click "Yes".
- [Image: Installation Complete Screen] Once the process is finished, you will see a completion screen. Click "Finish".

B. Installation on macOS

For macOS, using a package manager like Homebrew is often the easiest and cleanest way to manage software installations.

Install Homebrew (if you don't have it):
- Open the Terminal application (you can find it in `/Applications/Utilities/` or by searching with Spotlight).
- Paste the following command into the Terminal and press Enter:
```
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```
- Follow the on-screen instructions. This may take a few minutes.
Install Amazon Corretto 17 via Homebrew:
- Once Homebrew is installed, run the following commands in your Terminal:
```
# First, tap into the corretto repository
brew tap homebrew/cask-versions

# Second, install corretto 17
brew install --cask amazon-corretto17
```
- Homebrew will handle the download, installation, and placement in the correct system directory (`/Library/Java/JavaVirtualMachines/`).

C. Installation on Linux (Ubuntu/Debian)

For Debian-based Linux distributions like Ubuntu, we can use the `apt` package manager.

Update Your Package List:
- Open a terminal and run the following command to make sure your package list is up to date:
```
sudo apt update
```
Install Amazon Corretto 17:
- Amazon Corretto provides its own repository for easy installation. First, import the public key:
```
wget -O - https://apt.corretto.aws/corretto.key | sudo apt-key add -
```
- Next, add the Corretto repository to your system's sources:
```
sudo add-apt-repository 'deb https://apt.corretto.aws stable main'
```
- Finally, update your package list again and install the JDK:
```
sudo apt-get update; sudo apt-get install -y java-17-amazon-corretto-jdk
```

Configuring Environment Variables

This is often the most confusing part for beginners. So, what are environment variables, and why do we need to set them?

Think of environment variables as global settings for your operating system. One of these variables is named `Path`. The `Path` variable holds a list of directories. When you type a command like `javac` into your terminal or command prompt, the OS doesn't magically know where that program is. Instead, it looks through every directory listed in the `Path` variable until it finds an executable file named `javac`. If it can't find it, it gives you an error like "`javac` is not recognized as an internal or external command."

We need to do two things:

Create a variable called `JAVA_HOME` that points to the main directory of our JDK installation. This is a standard convention used by many Java-based tools (like build tools and application servers) to locate the Java installation.
Add the `bin` directory from our JDK installation to the `Path` variable. The `bin` directory is where all the command-line tools like `javac` (the compiler) and `java` (the runtime launcher) are located.

A. Environment Variables on Windows

If you used the Corretto `.msi` installer and selected the "Set `JAVA_HOME`" and "Add to `PATH`" options, this should already be done for you! The following steps are for manual configuration or verification.

Open System Properties:
- Press the Windows Key, type "Edit the system environment variables", and press Enter.
- [Image: System Properties window] In the window that appears, click the "Environment Variables..." button at the bottom.
Set `JAVA_HOME`:
- [Image: Environment Variables window] In the "System variables" section (the bottom half), look for a variable named `JAVA_HOME`.
- If it exists and points to the correct Corretto 17 directory (e.g., `C:\Program Files\Amazon Corretto\jdk17.x.x_x`), you're all set.
- If it doesn't exist, click "New...".
  - For "Variable name", enter `JAVA_HOME`.
  - For "Variable value", enter the path to your JDK installation directory. You can use the "Browse Directory..." button to find it. It should be something like `C:\Program Files\Amazon Corretto\jdk17.0.5_8`.
  - Click "OK".
Update the `Path` variable:
- In the "System variables" section, find and select the `Path` variable, then click "Edit...".
- [Image: Edit environment variable window for Path] A new window will open showing a list of paths.
- Look for an entry that points to the Java `bin` directory. If the installer worked, you should see something like `C:\Program Files\Amazon Corretto\jdk17.x.x_x\bin`.
- If it's not there, click "New" and add a new entry: `%JAVA_HOME%\bin`. Using `%JAVA_HOME%` is better than hardcoding the full path, as it means if you ever update Java and change your `JAVA_HOME` variable, the `Path` will update automatically.
- Click "OK" on all open windows to save your changes.

B. Environment Variables on macOS and Linux

On Unix-like systems (macOS, Linux), you typically configure environment variables in a shell configuration file, such as `.zshrc` (for Zsh, the default on modern macOS) or `.bashrc` / `.bash_profile` (for Bash).

Identify your JDK installation path:
- On macOS, if installed via Homebrew, it's typically in `/Library/Java/JavaVirtualMachines/`. You can run `/usr/libexec/java_home` in the terminal to find the exact path.
- On Linux, if installed via `apt`, it might be in `/usr/lib/jvm/java-17-amazon-corretto`.
Edit your shell configuration file:
- Open your configuration file in a text editor. For example, if you use Zsh:
```
nano ~/.zshrc
```
- If you use Bash:
```
nano ~/.bash_profile
```
Add the export commands:
- Add the following lines to the end of the file. Replace `/path/to/your/jdk` with the actual path you identified in step 1.
```
export JAVA_HOME="/path/to/your/jdk"
export PATH="$JAVA_HOME/bin:$PATH"
```
  For a typical macOS Homebrew installation, this might look like:
```
export JAVA_HOME=$(/usr/libexec/java_home)
export PATH="$JAVA_HOME/bin:$PATH"
```
- The `export` command makes these variables available to any programs you run from the shell. The `PATH` command line adds the Java `bin` directory to the *beginning* of the existing `PATH`.
Apply the changes:
- Save the file (in `nano`, press `Ctrl+X`, then `Y`, then `Enter`).
- To make the changes take effect in your current terminal session, "source" the file:
```
source ~/.zshrc  # or source ~/.bash_profile
```
- The changes will apply automatically to any new terminal windows you open.

Verification: The Moment of Truth

After all that setup, how do we know if it worked? We can ask Java itself. Open a new terminal or command prompt (this is important, as old sessions may not have the new environment variables). Type the following commands, pressing Enter after each one.

First, check the Java runtime version:

java -version

You should see output that looks something like this, confirming that the `java` command is found and it's the version we installed:

openjdk version "17.0.5" 2022-10-18 LTS
OpenJDK Runtime Environment Corretto-17.0.5.8.1 (build 17.0.5+8-LTS)
OpenJDK 64-Bit Server VM Corretto-17.0.5.8.1 (build 17.0.5+8-LTS, mixed mode, sharing)

Next, and just as importantly, check the Java compiler version:

javac -version

The output should be very simple, confirming the `javac` command is also working:

javac 17.0.5

If you see these outputs, congratulations! Your Java Development Kit is successfully installed and configured. Your machine is now ready to develop and run Java programs. If you get an error message, carefully re-read the environment variable steps, as a small typo in a path is the most common culprit.

Chapter 3: Your First Java Program: "Hello, World!"

With the environment ready, it's time to write some code. We'll start with the traditional "Hello, World!" program. Its purpose is not to be complex, but to prove that all the components—the editor, the source code, the compiler, and the runtime—are working together correctly.

Choosing Your Weapon: A Text Editor

You don't need a fancy, complex program to write Java code. Java source code is just plain text. You can use any plain text editor, but a good programmer's editor will offer features like syntax highlighting (coloring your code to make it more readable), which is extremely helpful.

Windows: Notepad++ is a great step up from the built-in Notepad.
macOS/Linux: Gedit, Kate, or even command-line editors like `nano` or `vim` work well.
Cross-Platform (Recommended): Visual Studio Code (VS Code) or Sublime Text are excellent, free choices that work on all three operating systems.

For now, we are deliberately avoiding a full-blown Integrated Development Environment (IDE) like IntelliJ IDEA or Eclipse. While IDEs are incredibly powerful, they hide many of the compilation and execution steps from you. For your first program, it's essential to perform these steps manually to understand what's happening under the hood.

Writing the Source Code

Create a new folder on your computer where you can store your Java projects. For example, `C:\Users\YourName\JavaProjects` or `~/Documents/JavaProjects`.
Open your chosen text editor.

Type the following code into the editor exactly as it appears. Java is case-sensitive, so `public` is different from `Public`.

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

Save the file. This is a critically important step. The file must be named exactly the same as the public class name, followed by the `.java` extension. In this case, the class name is `HelloWorld`, so you must save the file as `HelloWorld.java` in the folder you created.
- Correct: `HelloWorld.java`
- Incorrect: `helloworld.java`, `HelloWorld.txt`, `MyFirstProgram.java`

Anatomy of the "Hello, World!" Program

Let's break down this seemingly simple piece of code line by line. Every symbol and word has a specific meaning.

public class HelloWorld { ... }

public: This is an access modifier. It means that this class is visible and can be used by any other class in any package. For now, just think of it as making your class globally accessible.
class: This is a Java keyword that declares a new class. A class is the fundamental building block of an object-oriented program. It's a blueprint for creating objects, containing data (fields) and methods (functions) that operate on that data. Our entire program will be contained within this `HelloWorld` class.
HelloWorld: This is the name we've given our class. By convention, Java class names start with a capital letter and use "CamelCase" for multiple words.
{ ... }: The curly braces define the scope of the class. Everything between these two braces belongs to the `HelloWorld` class.

public static void main(String[] args) { ... }

This line is the single most important line in many Java applications. It defines the main method, which is the entry point for the program. When you tell the JVM to run this class, it looks for a method with this exact signature to begin execution.

public: Again, an access modifier. The main method must be public so that the JVM can call it from outside the class.
static: This keyword means the method belongs to the class itself, not to a specific instance (object) of the class. This allows the JVM to run the method without having to create an object of `HelloWorld` first.
void: This indicates the method's return type. `void` means that this method does not return any value after it finishes executing.
main: This is the special name that the JVM looks for.
(String[] args): This defines the method's parameters. It's a way to pass information into the program from the command line. `String[]` declares an array of `String` objects, and `args` is the name given to this array. We won't be using this feature today, but it must be included for the method signature to be correct.

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

This is the statement that does the actual work of printing text to the console.

System: This is a built-in final class from Java's core libraries. It provides access to system-level resources.
out: This is a `static` member field of the `System` class. It is an object of type `PrintStream` and represents the standard output stream, which by default is your terminal or command prompt window.
println(...): This is a method of the `out` object. The name is short for "print line". It prints the text you provide inside the parentheses to the console, and then moves the cursor to the next line.
"Hello, World!": This is a String literal. Text enclosed in double quotes is treated as a String in Java.
;: The semicolon marks the end of a statement in Java. It's like the period at the end of a sentence. Forgetting it is one of the most common syntax errors for beginners.

Chapter 4: The Two-Step Dance: Compilation and Execution

Now we have our plain-text source code (`HelloWorld.java`). A computer cannot directly understand this. We need to use the tools from the JDK we installed to translate it into a language the JVM can understand (bytecode) and then ask the JVM to run it.

Step 1: Compilation

The first step is to use the Java compiler, `javac`, to convert our `.java` file into a `.class` file containing bytecode.

Navigate to your project directory: Open your command prompt (Windows) or terminal (macOS/Linux). You need to be "in" the same folder where you saved `HelloWorld.java`. Use the `cd` (change directory) command.
For example, on Windows:
```
cd C:\Users\YourName\JavaProjects
```
On macOS/Linux:
```
cd ~/Documents/JavaProjects
```
You can use the `dir` (Windows) or `ls` (macOS/Linux) command to list the files in the directory and confirm that `HelloWorld.java` is there.
Run the compiler: Type the following command and press Enter:
```
javac HelloWorld.java
```

What happens now? If you made no mistakes in your code, the command prompt will simply... return. It will show a new, blank line. This silence is a sign of success! The compiler has done its job. If you now list the files in your directory again (`dir` or `ls`), you will see a new file: `HelloWorld.class`. This file contains the platform-independent bytecode, ready for the JVM.

If the compiler found an error (e.g., a missing semicolon, a typo), it will print one or more error messages to the console, telling you the file, line number, and what it thinks is wrong. You would then need to go back to your text editor, fix the error, save the file, and run the `javac` command again.

Step 2: Execution

Now that we have our compiled bytecode in `HelloWorld.class`, we can use the Java runtime launcher, `java`, to execute it.

Run the Java Virtual Machine: In the same terminal window (still in your project directory), type the following command and press Enter:
```
java HelloWorld
```

Notice two very important things about this command:

We use the command `java`, not `javac`. `javac` is for compiling, `java` is for running.
We provide only the class name, `HelloWorld`, without the `.class` extension. This is a common point of confusion. You are telling the JVM which class to load and execute, not which file to open. The JVM knows to look for a file named `HelloWorld.class`.

If all went well, you will see the following output on your screen:

Hello, World!

Success! You have just written, compiled, and executed your very first Java program. You've successfully navigated the entire core development cycle.

Visualizing the Workflow

Let's recap the entire process from start to finish:

You (The Developer) write human-readable source code in a file named `HelloWorld.java`.
The Compiler (`javac`) reads `HelloWorld.java`, checks it for syntax errors, and translates it into platform-independent bytecode, saving it as `HelloWorld.class`.
The Runtime (`java`) starts up the Java Virtual Machine (JVM).
The JVM loads the `HelloWorld.class` file, verifies the bytecode for security and correctness, and then translates it into native machine code for the specific operating system it's running on.
The Operating System executes that machine code, which results in the text "Hello, World!" being printed to your console.

Chapter 5: Troubleshooting Common First-Timer Problems

It's rare for everything to go perfectly on the first try. Here are some of the most common errors beginners encounter and how to solve them.

Problem 1: `javac is not recognized as an internal or external command...` (or `command not found: javac`)

Cause: This is the classic environment variable problem. Your operating system's `Path` variable does not include the directory where `javac.exe` (or `javac` on macOS/Linux) is located.
Solution:
1. Carefully review Chapter 2: Configuring Environment Variables. Double-check every step.
2. The most common mistake is a small typo in the path you added to `JAVA_HOME` or `Path`.
3. Ensure the path you added to the `Path` variable is the `bin` directory (e.g., `...jdk17.x.x\bin`), not just the main JDK directory.
4. Crucially: After changing environment variables, you must open a new command prompt or terminal window. Existing windows will not see the changes.

Problem 2: `Error: Could not find or load main class HelloWorld`

Cause: This error occurs during the execution step (`java HelloWorld`). The JVM is telling you it cannot find the `HelloWorld.class` file or the `main` method within it. There are several possible reasons:
- You are running the `java` command from the wrong directory. You must be in the same directory as your `HelloWorld.class` file. Use `ls` or `dir` to verify the file is there.
- You made a typo in the command. Are you typing `java Helloworld` instead of `java HelloWorld`? Remember, it's case-sensitive.
- You are incorrectly adding the `.class` extension. The command is `java HelloWorld`, not `java HelloWorld.class`. The latter will always cause this error.
- The `main` method signature in your `.java` file is incorrect. It must be `public static void main(String[] args)`. Any deviation (e.g., `private`, `Main`, `string[]`) will cause the JVM to fail to find the entry point.
Solution: Check each of the potential causes above. Start by verifying you're in the right directory and that the `HelloWorld.class` file exists. Then double-check your command for typos. Finally, scrutinize the `main` method declaration in your source code, recompile, and try again.

Problem 3: `HelloWorld.java:1: error: class MyProgram is public, should be declared in a file named MyProgram.java`

Cause: The public class name inside the file does not match the filename. For example, you saved the file as `HelloWorld.java`, but the code inside says `public class MyProgram { ... }`.
Solution: In Java, a public class must be in a file of the same name. Either rename the file to `MyProgram.java` or change the class name inside the file to `public class HelloWorld` to make them match.

Problem 4: Compilation errors like `error: ';' expected` or `error: cannot find symbol`

Cause: These are syntax errors caught by the `javac` compiler.
- `';' expected`: You forgot a semicolon at the end of a statement.
- `cannot find symbol`: You've misspelled a variable, class, or method name (e.g., `system.out.println` instead of `System.out.println`). Remember Java is case-sensitive.
- `unclosed string literal`: You forgot the closing double-quote for a string.
Solution: Read the compiler error message carefully. It will give you the filename and the line number where it thinks the error occurred. Go to that line in your text editor and look for the mistake. Fix it, save the file, and try compiling again.

Conclusion and Your Next Steps

You have taken a significant first step into the vast world of software development. By setting up your own development environment from scratch and manually compiling and running a program, you have gained a deep, practical understanding of the fundamental Java workflow—a process that is often hidden by modern development tools. You now understand the roles of the JDK, JRE, and JVM, the importance of environment variables, the nature of source code, and the critical distinction between compilation and execution.

The "Hello, World!" program is just the beginning. The path forward involves learning the core constructs of the language:

Variables and Data Types: How to store and manipulate information like numbers, text, and true/false values.
Operators: Performing arithmetic, logical comparisons, and more.
Control Flow Statements: Making decisions with `if/else` statements and creating loops with `for` and `while` to repeat actions.
Object-Oriented Programming (OOP): The paradigm that Java is built on. You will learn more about classes, objects, inheritance, and polymorphism.

As you progress, you will want to graduate from a simple text editor to an Integrated Development Environment (IDE). An IDE like IntelliJ IDEA Community Edition (free) or Eclipse will automate the compile-and-run cycle, provide intelligent code completion, offer powerful debugging tools, and manage complex projects for you. Now that you understand what an IDE is doing for you behind the scenes, you can leverage its power effectively.

Keep experimenting. Change the "Hello, World!" message. Try to print multiple lines. This hands-on practice is the key to solidifying your knowledge. Welcome to the community of developers. Happy coding!

Saturday, October 18, 2025

Your First Java Program: From Installation to Execution