Setting Up the Java Development Environment

Downloading and Installing a JDK

You need a JDK (Java Development Kit), not just a JRE, because the JRE has no compiler. Two common, free sources are the Eclipse Adoptium project (formerly AdoptOpenJDK, distributing the OpenJDK builds known as Temurin) and Oracle's own JDK builds, which are also free to use under Oracle's current no-fee license for recent versions. Either works for learning; Adoptium is a popular default because its license terms are simple and unambiguous for all use cases.

• Go to the distributor's download page (e.g. adoptium.net) and pick a Long-Term Support (LTS) version such as JDK 17 or JDK 21 unless you have a specific reason to use a newer feature release.
• Choose the installer that matches your operating system and CPU architecture (Windows x64, macOS ARM/Apple Silicon, Linux x64, etc.).
• Run the installer. On Windows and macOS, the installer can usually configure environment variables for you if you check the relevant option; on Linux, extracting a tarball into a directory like /opt/java is common.

Setting JAVA_HOME and PATH

JAVA_HOME is an environment variable that many build tools (Maven, Gradle) and IDEs look up to find your JDK installation; it should point to the JDK's root folder (the one containing a "bin" subfolder), not to the "bin" folder itself. PATH is a separate environment variable that tells the operating system's shell where to look for executable programs — adding the JDK's "bin" directory to PATH is what lets you type "java" or "javac" directly in any terminal window without typing the full path. On Windows this is done through System Properties → Environment Variables; on macOS/Linux it is typically set by exporting the variables in a shell profile file such as ~/.zshrc, ~/.bashrc, or ~/.bash_profile.

Verifying the Installation

After installing and configuring the environment variables, open a fresh terminal window (existing ones will not see the new PATH) and run two commands to confirm both halves of the toolchain are visible: java -version checks the runtime launcher, and javac -version checks the compiler. Both should report the same version number; if only one works, or if they report different versions, PATH is likely pointing at more than one Java installation.

Choosing an IDE vs a Plain Text Editor

An IDE (Integrated Development Environment) such as IntelliJ IDEA or Eclipse bundles a code editor, a build system, a debugger, and project management into one application — it can detect a missing import, auto-complete method names, and let you set breakpoints and step through code visually. VS Code is a lighter-weight editor that becomes IDE-like for Java once you add Microsoft's "Extension Pack for Java." Alternatively, many learners start with a plain text editor and a terminal: you write the .java file yourself, then manually run javac and java. This "manual" workflow is slower for large projects but extremely valuable early on, because it forces you to understand the compile-then-run cycle instead of relying on a green "Run" button.

• IntelliJ IDEA — widely used in industry, strong refactoring tools, excellent build-tool integration (Maven/Gradle).
• Eclipse — free, mature, long history in enterprise Java development.
• VS Code + Java extensions — lightweight, fast startup, good for smaller projects or polyglot workflows.
• Plain text editor + terminal — no hidden magic; ideal for understanding exactly what javac and java do.

The Compile-Then-Run Cycle

Whichever tool you use, the same two-step cycle happens underneath: javac reads your .java source file, checks it for syntax and type errors, and — if it compiles cleanly — produces one or more .class files containing bytecode in the same directory. Then java (given the class name, not the file name, and without the .class extension) loads that bytecode and starts execution from its main method. An IDE's "Run" button is simply automating these two steps for you.

Example

// Terminal commands (not Java code) to verify setup:
// java -version
// javac -version

// File: EnvironmentCheck.java
public class EnvironmentCheck {
    public static void main(String[] args) {
        System.out.println("Java version property: " + System.getProperty("java.version"));
        System.out.println("Environment is ready.");
    }
}

// Terminal:
// javac EnvironmentCheck.java   -> produces EnvironmentCheck.class
// java EnvironmentCheck         -> runs the compiled bytecode

Java version property: 21.0.1
Environment is ready.

Exercise

Confirm your installation from the terminal without using an IDE. Check both tools report a version, then compile and run the program below.

The last command should print Setup works.

// Save this as SetupCheck.java
public class SetupCheck {
    public static void main(String[] args) {
        System.out.println("Setup works");
    }
}

// In a terminal, from the folder containing the file:
// 1. Check the runtime version
// 2. Check the compiler version
// 3. Compile the file
// 4. Run the class

// 1. java -version
// 2. javac -version
// 3. javac SetupCheck.java      -> creates SetupCheck.class
// 4. java SetupCheck            -> prints: Setup works

Quick quiz

Interview questions