Java Development Kit

Definition

The Java Development Kit (JDK) is the software development kit developers use to build Java applications, bundling a compiler, debugging tools, standard libraries, and a bundled runtime needed to compile and test Java code. It is the primary toolchain distribution for anyone writing Java software, distinct from runtime-only distributions meant solely for running already-compiled applications. Several vendors distribute their own builds of the JDK based on the shared open-source OpenJDK project.

Overview

Writing Java source code and turning it into a running program requires more than a language specification: developers need a compiler to translate source files into bytecode, a set of standard libraries to call into, and tools for packaging, documenting, and debugging code. The JDK bundles all of these together so that a developer can go from source code to a working, testable application without assembling separate tools individually. Mechanically, the JDK includes the javac compiler that translates '.java' source files into '.class' bytecode files, along with command-line tools for packaging classes into distributable archives, generating documentation from source comments, and attaching a debugger to a running process. It also bundles a full Java Runtime Environment internally, since compiled code needs to be run and tested during development, meaning a JDK installation is a superset of what a JRE alone provides. The JDK differs from the JRE in scope: the JRE contains only what is needed to execute already-compiled Java bytecode, while the JDK adds the development-time tools needed to produce that bytecode in the first place. It also differs from IDE-bundled tooling in that IDEs like popular Java editors wrap and invoke the JDK's underlying compiler and tools rather than replacing them, meaning the JDK remains the actual engine doing compilation regardless of which editor a developer uses on top of it. In practice, every Java developer installs a JDK as a prerequisite for writing and building Java code, and build tools invoke the JDK's compiler as part of automated build pipelines. Multiple vendors, including the language's original steward and several other companies, distribute their own JDK builds derived from the shared OpenJDK source, and developers commonly manage multiple JDK versions side by side on one machine using version-switching tools, since different projects may target different Java language levels. A key consideration when choosing a JDK distribution is long-term support and licensing terms, since different vendor builds have historically differed in update cadence and support windows even though they share the same underlying open-source codebase. The JDK itself has no meaningful functional limitation for typical development, but developers deploying finished applications generally only need the lighter JRE, or increasingly, a custom minimal runtime image built specifically for their application, rather than shipping the full development toolkit to production. Continuous integration systems typically pin an exact JDK version and vendor build for reproducibility, since subtle differences in bundled libraries or default settings between distributions can otherwise cause a project to compile cleanly on one machine and fail on another.

Key Features

• Bundles the javac compiler for translating source to bytecode
• Includes command-line tools for packaging, docs, and debugging
• Contains a full Java Runtime Environment for testing code
• Multiple vendors distribute builds based on shared OpenJDK source
• Required prerequisite for compiling any Java project
• Supports side-by-side installation of multiple JDK versions

Use Cases

Alternatives

Frequently Asked Questions

Related in Programming