Getting Started with Java: Your First Program Explained

1. What is a program?

A computer is extremely fast and extremely obedient, but it has no common sense. It does exactly what it is told, step by step. A program is a list of precise instructions that tells the computer what to do.

2. The language problem

Deep down, a computer's processor (CPU) only understands machine code: patterns of 0s and 1s. Writing programs in 0s and 1s is almost impossible for humans. So we write in high-level languages like Java, Python or C, which look closer to English, and a translator converts them to machine code.

There are two classic kinds of translator:

3. How Java does it: both

Java uses a clever two-step approach:

1. The Java compiler (javac) translates your .java file into bytecode, stored in a .class file. Bytecode is not machine code for any real CPU. It is machine code for an imaginary computer.

2. The JVM (Java Virtual Machine) is that imaginary computer, implemented as a program. It reads the bytecode and runs it on the real machine.

This is why Java's famous slogan is "Write Once, Run Anywhere" (WORA). You compile once, and the same .class file runs on Windows, Mac and Linux, because each of those systems has its own JVM that understands the same bytecode.

4. JDK, JRE and JVM

These three terms confuse every beginner, and they come up in almost every Java interview.

• JVM: the engine that runs bytecode.

• JRE: the JVM plus the standard libraries a program needs while running. It is enough to run Java programs.

• JDK: the JRE plus developer tools such as the compiler. You need it to write and compile Java programs.

Note

Since Java 11, Oracle no longer ships a separate JRE download; you simply install the JDK. The JDK/JRE/JVM distinction still matters for understanding and for interviews.

5. A little context about Java

• Created by James Gosling's team at Sun Microsystems and released in 1995. Oracle bought Sun in 2010.

• A new Java version comes out every 6 months. Every 2 years, one version becomes an LTS (Long-Term Support) release that companies use for years: Java 8, 11, 17, 21 and 25. We use Java 21, which is what most companies run in production today, and everything you learn here works unchanged on newer versions.

• Where Java is used: banking and payment systems, large company backends (often with Spring Boot), Android apps, big-data tools such as Hadoop and Kafka, and much more.

6. Setting up

1. Install JDK 21. A good free option is Eclipse Temurin 21 from adoptium.net. Choose your operating system and download the installer (on Windows, tick "Set JAVA_HOME" and "Add to PATH" during installation).

2. Open a terminal (Command Prompt on Windows) and check the installation:

java -versionjavac -version

You should see 21.x.x in both. If you see "command not found" or "not recognized", the JDK is not on your PATH; reinstall and tick the PATH option.

3. Install IntelliJ IDEA Community Edition. Create a new project: New Project → Java → choose JDK 21 as the SDK → untick "Add sample code" → Create.

7. Your first program

In IntelliJ, right-click the src folder → New → Java Class → type Hello. Type this (don't paste):

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

Click the green ▶ next to public static void main and choose Run.

Output

Hello, World!

That's a complete Java program. Now let's look at it honestly.

The frame and the picture

Think of the program as a photo frame with a picture inside it:

For the next several sessions every program has the same frame, and all the thinking happens inside the inner braces. Today we explain what we can:

• System.out.println("Hello, World!"); prints the text inside the quotes and then moves to a new line.

• The text inside double quotes "..." is printed exactly as written.

• The semicolon ; ends an instruction, like a full stop ends a sentence.

• Curly braces { } group things. The inner pair holds the instructions of main; the outer pair holds everything that belongs to the class Hello. Every { needs a matching }, and IntelliJ highlights the partner when you click next to one.

• Java is case-sensitive: System works, but system or SYSTEM do not.

• The file name must match the class name: public class Hello must be saved in Hello.java.

And the words in the frame? Here is the honest deal with the candidate:

Promise: We will open this box properly later

The frame, public class Hello and public static void main(String[] args): for now, "this is the fixed shape every Java program lives in." Nothing in it is magic, and none of it will be left unexplained. Each word gets its full meaning at the right time: main and void in Session 9, String[] args in Sessions 11–12, class in Session 14, public in Session 16, and static in Session 17, where we read the whole line together, word by word.

Promise: We will open this box properly later

main: for now, "the program starts running here." When you run the program, Java looks for main and runs the lines inside its braces from top to bottom. void: for now, "this part does its job and gives no answer back." Both become precise in Session 9, when we write our own methods.

Promise: We will open this box properly later

System.out.println: for now, "the command that prints something to the screen and moves to the next line." Why it's written with two dots, and what System and out actually are, becomes clear in Session 17.

8. Running from the terminal: seeing both steps

IntelliJ hides the two steps from section 3. The terminal shows them. Open a terminal in the folder containing Hello.java:

javac Hello.javajava Hello

Output

Hello, World!

• javac Hello.java compiles: it creates a new file, Hello.class, containing bytecode. List the folder (dir on Windows, ls on Mac/Linux) to see it.

• java Hello starts the JVM, which loads Hello.class and runs main. Note: no .class at the end.

Try opening Hello.class in a text editor: it's unreadable binary. That's bytecode, meant for the JVM, not for humans.

Promise: We will open this box properly later

The JVM does much more than run bytecode: it manages memory, cleans up unused data (garbage collection) and even speeds up frequently-run code while the program is running. For now, "the JVM is the virtual computer that runs bytecode" is enough. We'll look inside it in Session 37.

9. Your first error (on purpose)

Remove the semicolon and run again:

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

Output

Hello.java:3: error: ';' expected        System.out.println("Hello, World!")                                           ^1 error

How to read an error message: Hello.java:3 means file name and line number. Then comes the problem (';' expected), and the ^ points at the exact spot. This is a compile-time error: the compiler refused to translate the code, so nothing ran.

Interview questions

Practice

1. easy Print your name, your city and your favourite food on three separate lines.

2. easy Print this box using several System.out.println calls:

+--------+|  JAVA  |+--------+

3. easy Introduce each of these errors one at a time, run, and write down the error message and line number: missing semicolon, missing closing brace, println misspelt as printn, missing closing quote, and the class renamed to Hi while the file is still Hello.java.

4. medium In the terminal, run javac Hello.java and then list the folder. What new file appeared? Now run java Hello. Explain in two sentences what each command did. What happens if you then delete Hello.java and run java Hello again? And if you delete Hello.class instead?