JVM, JRE, JDK, and Your First Program

The three names

The conceptual nesting is still useful. Modern JDKs may not ship a separate folder or download named JRE.

Use these working definitions:

• The JVM executes class files under the JVM rules.
• A runtime environment adds the libraries and files applications need.
• The JDK adds tools used to build, inspect, and debug programs.

For this course, install a JDK. It contains what you need for both development and execution.

Install one

Get a build of OpenJDK version 21. It is a long-term support release, and every command in this course works on it. Version 17 also works if you already have it. Anything older is missing language features used later in the course.

Adoptium publishes free, well-maintained builds for all three operating systems. Download the installer for your machine, not a .zip or .tar.gz, and choose the package marked JDK. A package marked JRE gives you java without javac.

Confirm the installation

Open a terminal and run:

java -version
javac -version

The first command checks the launcher. The second checks the compiler.

If java works but javac does not, you may have only a runtime on your command path. If neither works, the JDK may be missing or its bin directory may not be on PATH.

PATH is the list of directories your shell searches for commands. It is an operating-system feature, not a Java keyword.

Write a complete program

Create a plain text file named Demo.java:

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

Every part has a job:

public class Demo                 declares a class named Demo
public static void main(...)      declares the program entry method
String[] args                     receives command-line arguments
System.out.println(...)           prints one line

You do not need the full meaning of public, static, or String[] yet. Their later lessons will rebuild this line from known parts.

One rule matters now: a public top-level class named Demo belongs in Demo.java. Capitalisation must match.

Compile it

Change the terminal to the directory containing the file. Run:

javac Demo.java

If compilation succeeds, the command usually prints nothing. It creates Demo.class in the same directory.

You now have two different artifacts:

Run it

Run the class through the Java launcher:

java Demo

Expected output:

Hello, Java!

javac accepts a file name, including .java. The java launcher accepts a binary class name, so you write Demo without an extension.

Answer from memory before opening the explanation. Then compare your rule with the answer and revisit the example if they differ.

1. You want to write, compile, and run Java programs. Which package do you install?

   Show the answer

   Install a JDK. It provides the Java runtime, the javac compiler, and development tools. A JVM is the execution engine. JRE is the traditional name for a JVM plus runtime libraries and supporting files.

2. Why does compilation use "javac Demo.java", while execution uses "java Demo"?

   Show the answer

   javac compiles a source file, so it receives the file path. The launcher receives a binary class name. It searches the class path for Demo.class, loads that class, and calls its entry method.

3. What happens before the first statement in main runs?

   Show the answer

   The launcher starts a JVM. The runtime locates and loads the class, checks its bytecode, links it, and initializes required class state. It then invokes a valid main method.

Start with the warm-ups. Continue to practice exercises when the basic idea works. Challenges are optional: skip them on a first pass and return after the next lesson.

1. Warm up: one idea with close guidance.
2. Practice: combine the idea with earlier material.
3. Challenge: investigate an edge case or implementation detail.

4 exercises60 pointsabout 36 minutes

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

javac Demo.java
java Demo

Hello from bytecode