[!NOTE] Welcome to your first step into the Java ecosystem. By the end of this chapter, you will understand the fundamental architecture of the Java language, how its compilation process differs from languages like C++, and you will write your very first program.
The Core Philosophy of Java
Java was introduced by Sun Microsystems in 1995 with a revolutionary mantra: "Write Once, Run Anywhere" (WORA).
In previous decades, if you wrote a program in C or C++, you had to manually compile separate versions of your program for Windows, for Mac, and for Linux. Furthermore, you had to manage memory manually, leading to catastrophic system crashes if you accidentally caused a "memory leak".
Java solved this by introducing an abstraction layer over the operating system: The Java Virtual Machine (JVM).
The Lifecycle of Java Code
Unlike interpreted languages (like Python) that read code line-by-line, and unlike fully compiled languages (like C) that translate directly into raw machine code, Java takes a hybrid approach.
| Step | Component | Action | Output |
|---|---|---|---|
| 1 | Programmer | Writes human-readable code. | .java source file |
| 2 | Compiler (javac) | Checks syntax and translates to intermediate code. | .class bytecode file |
| 3 | JVM (java) | Reads bytecode and translates it to machine instructions. | Execution on OS |
[!TIP] TL;DR: Always remember the pipeline: Source -> Compiler -> Bytecode -> JVM -> OS.
Writing Your First Program
Let's look at the absolute minimum amount of code required to print something to the screen.
public class HelloWorld {
// This is the entry point
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
Let's break down this famously verbose syntax line by line:
public class HelloWorld
public class HelloWorldJava is aggressively Object-Oriented. Everything must live inside a class (a blueprint). The keyword public means this class is accessible from anywhere.
[!CAUTION] If your class is
public, the filename must exactly match the class name. This file must be saved asHelloWorld.java, matching the casing perfectly.
public static void main(String[] args)
public static void main(String[] args)This is the Entry Point of your application. When the JVM starts your program, it specifically looks for a method with this exact, precise signature.
- public: The JVM can access it from outside the class.
- static: The JVM can run this method without needing to create an instance (object) of the HelloWorld class first.
- void: This method does not return any data back to the JVM when it finishes.
- String[] args: An array of Strings that allows you to pass command-line arguments into your program when you start it.
System.out.println("Hello, World!");
System.out.println("Hello, World!");This is the command that actually prints the text to your console.
- System: A built-in class providing access to system resources.
- out: A static member of the System class representing the standard output stream (your console/terminal).
- println: A method that prints the text and then moves the cursor to a new line.
Summary
While Java may seem terribly wordy at first compared to Python (print("Hello")), this rigid, strictly typed structure is exactly what makes Java the backbone of massive enterprise architectures. It prevents silly mistakes and naturally forces you into organized design patterns.
How This Looks in a Real Java Setup
When you write Java professionally, you usually do not run only one tiny file forever. You write many classes, organize them into packages, compile them into bytecode, and run them with a chosen JDK. The important mental model is still the same: your .java source is compiled into .class bytecode, and the JVM executes that bytecode.
A beginner mistake is to think the JVM is only an interpreter. Modern JVMs are much smarter. They start by reading bytecode, then use a Just-In-Time compiler to optimize frequently executed code while the program runs. That is one reason Java can be both portable and fast for long-running server applications.
JDK vs JRE vs JVM
| Term | Meaning | When you care |
|---|---|---|
| JVM | Runs Java bytecode | When understanding execution and memory |
| JRE | Runtime environment for running Java apps | When only executing an already-built app |
| JDK | Developer kit with compiler, runtime, and tools | When writing and compiling Java code |
Practice From the Terminal
javac HelloWorld.java
java HelloWorldIf compilation succeeds, you should see a HelloWorld.class file. If running succeeds, the JVM finds the main method and starts there.
Common Mistakes
- Saving
public class HelloWorldinside a file namedhelloWorld.java. Java class names are case-sensitive. - Running
java HelloWorld.class. Usejava HelloWorldwithout the.classextension. - Changing the
mainmethod signature. The JVM expectspublic static void main(String[] args).
Mini Practice
Create a file named Profile.java. Print your name, your learning goal, and one reason you want to learn Java. Compile it, run it, then intentionally rename the file incorrectly and observe the compiler error.
Practice Lab: Run Java Like a Developer
Build confidence with the compile-and-run flow instead of only reading about it.
- Create
HelloProfile.java. - Print your name, city, and current Java learning goal.
- Compile with
javac HelloProfile.java. - Run with
java HelloProfile. - Rename the class or file incorrectly and read the compiler error carefully.
Goal: You should be able to explain the difference between source file, bytecode file, and JVM execution.
Revision Checkpoint
- Pipeline:
.javasource is compiled byjavacinto.classbytecode, then executed by the JVM. - JDK: Needed for development because it includes compiler tools.
- JVM: Runs bytecode and provides portability across operating systems.
- Main method:
public static void main(String[] args)is the application entry point. - Filename rule: A public class name must match the filename exactly.
Before the quiz: Explain the difference between JDK, JRE, and JVM in your own words.