Getting Started

Everything you need to build Java programs ships in the JDK (Java Development Kit): the javac compiler that turns source into bytecode, the java launcher that runs that bytecode on the JVM, the interactive jshell, and packaging tools such as jar. This chapter walks through installing a JDK, compiling and running a first program, the layout real projects use, and choosing an editor.

Installing a JDK

Several vendors publish JDK builds. They are all built from the OpenJDK sources, so the language and standard library are identical; what differs is the support window and the license. If you are just starting out, a free build such as Eclipse Temurin or Oracle's OpenJDK builds is a safe choice. Teams usually standardize on a long-term support (LTS) release.

Once it is installed, confirm that both tools are on your path:

java -version
javac -version

If the shell cannot find them, add the JDK's bin directory to PATH. Build tools and IDEs commonly locate the JDK through the JAVA_HOME environment variable, so point that at the install directory as well.

Your first program

Java code lives inside classes, and a program starts at a public static void main(String[] args) method. Save the following as Hello.java. A public class must be declared in a file with the same name.

public class Hello {
    public static void main(String[] args) {
        String name = args.length > 0 ? args[0] : "world";
        System.out.println("Hello, " + name + "!");
    }
}

The classic workflow is two steps: compile with javac to produce a .class file of bytecode, then run it with java. Note that java takes the class name here, not the file name.

javac Hello.java # produces Hello.class
java Hello # Hello, world!
java Hello Java # Hello, Java!

Running a source file directly

For small programs and scripts you can skip the explicit compile step. Hand a .java file straight to the launcher and it compiles the code in memory and runs it, without leaving .class files behind.

java Hello.java Java

Recent JDKs also accept compact source files where you write just a void main() method with no surrounding class. Most tutorials and existing code bases still use the traditional form shown above, so it is worth getting comfortable with that first.

Experimenting with JShell

jshell is a REPL: type an expression or statement and see the result immediately, with no class or main method required. It is a great way to explore an unfamiliar API. Use /vars and /methods to list what you have defined and /exit to quit.

jshell> var nums = java.util.List.of(3, 1, 2)
nums ==> [3, 1, 2]

jshell> nums.stream().sorted().toList()
$2 ==> [1, 2, 3]

jshell> "java".toUpperCase()
$3 ==> "JAVA"

Project layout

As soon as you have more than a handful of files, reach for a build tool such as Maven or Gradle. Both expect the same conventional directory structure, and package names must mirror the directory path.

my-app/
├── pom.xml # Maven (build.gradle.kts for Gradle)
└── src/
    ├── main/
    │   ├── java/com/example/app/App.java
    │   └── resources/ # config files and other assets
    └── test/
        └── java/com/example/app/AppTest.java

• src/main/java holds production code.
• Files under src/main/resources end up on the classpath next to your classes.
• src/test/java holds tests, which are never packaged into the release artifact.
• Build output goes to target/ with Maven and build/ with Gradle.

Setting up an IDE

Java has excellent tooling, and a good IDE pays for itself quickly. The common choices are:

• IntelliJ IDEA: strong refactoring and code analysis; the free edition is plenty to get started.
• Visual Studio Code: install Microsoft's Extension Pack for Java for completion, debugging, and test running.
• Eclipse IDE: a long-standing open-source IDE that is still widely used in enterprises.

All of them import a project by reading its pom.xml or build.gradle.kts, which wires up dependencies and source folders for you. Make sure you also select the project's JDK explicitly in the IDE settings so the editor and the build agree.

Summary

• Install a JDK and verify it with java -version and javac -version.
• Compile with javac and run with java ClassName, or launch a single file directly with java File.java.
• Use jshell to try out syntax and APIs interactively.
• Real projects follow the src/main/java and src/test/java layout and are built with Maven or Gradle.