Setting Up VS Code for Java Development

#java #tooling #tutorial #vscode

VS Code is the most popular code editor on the planet. It's fast, free, and runs everywhere. But out of the box, it knows nothing about Java. Open a .java file and you get syntax highlighting. That's it. No autocomplete for your imports, no "click to run" button, no debugger.

The fix takes about two minutes. You install a Java extension, point it at a JDK, and you're writing real Java with a real debugger. Let me walk through the whole thing.

Install the Java extension

VS Code calls everything an "extension." For Java, you have a couple of options. This guide follows the one Oracle maintains, called the Oracle Java Platform extension. (Microsoft also publishes an "Extension Pack for Java" that bundles several tools together. Both get you up and running. Pick whichever you like.)

To install it:

Open VS Code.
Go to Code > Settings > Extensions (or press Ctrl+Shift+X).
Search for "Oracle Java Platform" and click Install.

That's the setup. The extension handles compiling, running, debugging, and project management under the hood.

Make sure you have a JDK

A JDK (Java Development Kit) is what actually compiles and runs your code. VS Code can't do Java without one.

Here's the nice part: if you don't have a JDK installed, the extension can download one for you. Open the command palette (Ctrl+Shift+P, or Cmd+Shift+P on Mac) and run:

Download, install, and Use JDK

Pick a version from the list. 17 and 21 are both good choices for new projects. The extension downloads it and saves the path in your settings, so you never have to wrestle with environment variables.

Already have a JDK? The extension finds it automatically by checking JAVA_HOME and JDK_HOME, then your system PATH. You can override it later in settings under jdk.jdkhome.

One thing to keep in mind: the extension needs JDK 11 or newer. If you're stuck on Java 8 for an old project, you can still write code that targets 8. But VS Code itself runs on a newer JDK.

Create your first project

Now you can actually build something. Open the command palette again and run:

Java: New Project

Choose Java with Maven. It asks for a folder name (let's say myapp) and a package name (something like com.example). Hit Enter.

The extension generates a basic Maven project: a pom.xml file, a src/main/java folder, and a starter class. Maven is a build tool that manages dependencies and packaging. For now, all you need to know is that pom.xml is where your project configuration lives.

Write some code and run it

Open the generated Java class and replace its contents with something simple:

package com.example;

public class MyApp {
    public static void main(String[] args) {
        System.out.println("Hello from VS Code!");
    }
}

To run it, look just above the main method. You'll see two little links: Run main and Debug main. Click Run main.

Your output appears in the terminal panel at the bottom. No manual compile step, no javac command. The extension compiles and runs behind the scenes.

Debug like you mean it

Click Debug main instead, and VS Code drops you into the debugger. Set breakpoints by clicking in the gutter next to line numbers, then step through your code one line at a time.

The debugger supports what you'd expect:

Pause and resume
Step over, step into, step out
Inspect variables mid-run
Evaluate expressions on the fly

Need to pass arguments to your program, like a list of numbers? Open the Run and Debug panel, find your launch configuration, and add them to the Program Arguments field. There's a launch.json file generated for you where all of this lives.

Refactoring and shortcuts

This is where a real editor earns its keep. The Oracle extension can:

Generate toString(), hashCode(), and equals() for you
Organize and sort imports automatically (turn on "Organize Imports on Save" in settings and forget about it)
Rename methods and move classes between packages without breaking references
Convert .get(0) to the newer .getFirst() syntax (Java 21 and up) across your whole project

Most of these live under the Source Action right-click menu, or the little lightbulb icon that appears next to your code.

Generate tests

Right-click a class, pick Source Action > Create Test Class, and the extension scaffolds a test file with empty test methods. Fill them in with your assertions, then use the Test Explorer to run individual tests or the full suite. Green checkmarks mean passing tests, red means something broke. Straightforward.

JavaDoc in two keystrokes

Type /** above any method and press Enter. The extension generates a JavaDoc comment with placeholders for each parameter and the return value. It sounds minor, but you'll reach for this constantly once you know it's there.

Summary

Install the Oracle Java Platform extension (or Microsoft's Extension Pack for Java) from the VS Code marketplace.
No JDK? The extension downloads one for you. It needs JDK 11 or newer.
Create a project through Java: New Project in the command palette.
Click Run main or Debug main above your main method to execute code.
The debugger gives you breakpoints, stepping, and live variable inspection.
Use Source Actions to generate boilerplate, organize imports, and refactor safely.
Type /** above a method to auto-generate JavaDoc.