What is Java Development Kit (JDK)?

JDK components, tools and utilities

The JDK provides a variety of features and tools that aid in the software development process. Some of these tools in this software development kit are considered basic, including the following:

• Javac. This utility is used to compile Java source code into Java bytecode class files. It provides multiple options to read Java class and interface definitions and compile them into bytecode. Additionally, it can process annotations in Java source files and classes. For the compiler to run properly, the source and class files must have root names that identify the class.
• Javah. This command is used to generate C header and source files from a Java class. These headers and files are needed by C programs to reference an object's instance variables from native source code.
• JAR. This compression utility aggregates a multitude of files into a single Java Archive (JAR) file. Based on ZIP and the ZLIB compression formats, JAR allows developers to package Java applets or applications into one archive. They can quickly download the components of the JAR file using a web browser in a single HTTP transaction. The author can sign the individual entries in a JAR file; this allows for the origin of those entries to be authenticated.
• Javadoc. This utility is an application programming interface (API) documentation generator. It can analyze the declarations and comments in source files and produce HTML pages describing the classes, interfaces, constructors, methods and fields. Developers can use the Javadoc Doclet API to inspect the source-level structures of programs and libraries and to generate customized Javadoc output. By creating a Doclet program (using the Doclet API), they can generate any kind of text file output, including HTML, SGML, XML, RTF and maker interchange format (MIF).
• Extcheck. The Extcheck utility detects conflicts between a target JAR file and currently installed extension JAR files. It is useful to check whether the same or a more recent version of the extension is already installed.
• Javap. Javap disassembles class files, and prints the package, protected and public fields, and methods of the classes passed to it. It provides numerous options to print help messages, print local variable tables, show all classes and members, and more.
• Jdeps. This Java class dependency analyzer shows the package-level or class-level dependencies of Java class files and then generates those dependencies in DOT language.
• Jdb (Java Debugger). Jdb is a command-line debugger for Java classes that finds and fixes bugs in Java platform programs (in local or remote JVMs).

The JDK also includes numerous security tools, internationalization tools, Remote Method Invocation (RMI) tools and tools for the following:

• Java deployment.
• Java Web Start.
• Java monitoring.
• Java troubleshooting.
• Java web services.
• Scripting.

One of the many RMI tools in the JDK is called rmic. This utility creates skeletons and stubs (both are class files) using the Java Remote Method Protocol (JRMP). Oracle recommends the use of dynamically generated JRMP stubs and skeletons because support for static generation of these entities has been deprecated.

One example of a JDK security tool is jarsigner. Developers can use this command to both sign and verify JAR files. The command uses a public key and private key, plus certificate information from a keystore to generate digital signatures for the files. A JAR file is successfully verified if and only if two conditions are met: the signatures are valid and the files that were in the JAR file have not changed since the signatures were generated. Apart from jarsigner, other security tools are available in the JDK to do the following:

• Manage keystores and certificates.
• Manage policy files.
• Obtain Kerberos v5 tickets.
• List entries in credential cache and key tab.
• Manage entries in the key table.

A popular Java deployment tool is javapackager. This utility manages tasks related to packaging, compiling and signing Java and JavaFX applications for distribution. The JDK also provides javaws, a tool to launch Java Web Start (JWS), a useful software to download and run Java applications from the web, as well as wsgen, a web services tool that generates portable artifacts required by Java API for XML Web Services (JAX-WS).

Developers can also pick from numerous Java monitoring and troubleshooting tools within the JDK, as well as tools to run scripts that interact with the Java platform. For example, the Java Mission Control (JMC) tools are useful to monitor and manage Java applications with minimal performance overhead. Similarly, jvisualvm is a useful graphical tool to gather detailed information about Java applications running in a JVM. That said, many of the monitoring and troubleshooting tools in the JDK are experimental and might not be available in future JDK versions. Also, some of the troubleshooting tools are not currently (as of May 2025) available on Windows platforms.

JDK vs. JVM

The JDK is needed to develop Java applications, while the JVM is needed to execute bytecode. When a Java application's source code (.java) is compiled by the Java compiler, it is compiled into bytecode. Bytecode is an intermediary between Java source code and low-level machine code. The bytecode is contained within .class files, which have the same class names present in the .java file. All of this is possible because of the JVM.

JVMs, which are part of the JRE, exist for operating systems (OSes). In fact, different JVM implementations are required to interact with different OSes and the specific machine's underlying hardware. However, bytecode is platform independent. The ability of JVMs to facilitate on-the-fly conversion from Java bytecode to low-level computer instructions (machine code) is the key to making a Java application cross-platform and hardware-agnostic, or write once run anywhere (WORA). WORA means that Java code can be written on any machine with any OS and run it on a different machine (with a different OS) without making any modifications or adjustments to the code.

JDK vs. JRE

The Java Development Kit also includes the Java Runtime Environment (JRE). It consists of the following:

• JVM.
• Java platform core classes.
• Supporting Java platform libraries.
• Integration libraries.
• Additional libraries, e.g., internationalization libraries, IDL libraries and Java packages for versioning and management.
• Java plug-in software.
• Java Naming and Directory Interface (JNDI) directory service.

The main difference between the JDK and JRE is that the tools within the JDK are used for developing Java programs, while the JRE is only for running those programs. The JDK contains a compiler, a debugger and other development tools. These resources are needed to write and compile code and then pass the bytecode to the JRE. In contrast, the JRE contains the resources needed to run the bytecode on any device and platform, including class libraries, supporting files and the JVM.

The JRE is where all Java source code is executed and where the various software plugins, JAR files and support libraries (required for the source code to run) are integrated. Its main job is to facilitate communication between the Java program and the underlying OS so that the program can run on that OS without requiring developers to modify the code for each OS the program is meant to run on.

The JRE uses the JDK and its libraries (which are nothing but additional built-in code) to create a JVM instance (local copy) that will run the Java program. While JVMs can exist for different OSes, the JRE creates a single OS-agnostic copy of the Java code. This is what makes it possible for developers to write Java code only once and then run it from anywhere.

In addition to facilitating platform independence for Java apps, the JRE allows the programs to access all required system resources, such as memory, program files and dependencies, so that they can run. Within the JDK, the JRE is separated from the regular JRE, which is why it is also known as the private runtime.

Some Java applications can be launched via some browsers using the JRE. For example, to run Java Web Start applications from a supported web browser, only the JRE is needed.

JDK libraries

The JDK does not include support for components such as servlets, Java Server Pages (JSP) and Enterprise JavaBeans (EJB). These components are part of the Java EE platform, which is built on top of Java SE. Similarly, the JDK does not have inherent support for microdevice development with Java ME, although Java ME does build on top of and utilize all of the features and tools that are made available through the JDK. The JDK represents a core set of libraries, utilities and tools that Java developers can use. Subsequent APIs, platforms and frameworks that are built with Java all build upon the facilities provided by the JDK.

JDK versions and the Java platform

The JDK is a software package that contains a variety of tools and utilities to develop, package, monitor and deploy applications for the Java Platform, Standard Edition (Java SE).

Java SE is meant for developing and deploying Java applications on desktops and servers. As of May 2025, the latest edition of Java SE is Java SE 24.0.1. Multiple JDK versions are available for Java SE:

• JDK 24.
• JDK 21.
• JDK 17.
• JDK 11.
• JDK 8.

Some older versions (JDK 23, JDK 16, JDK 15, JDK 7, etc.) are also available, but they are currently in sustaining support, meaning Oracle provides maintenance only for as long as users use the software.

Within Java SE, Oracle provides the JDK Mission Control (JMC), a set of advanced tools for managing, monitoring and troubleshooting Java applications.

JDK and other (non-Java) languages

In the past, the JDK was specifically meant for the Java programming language. From Java 7 onward, special constructs were introduced that made it easier for peripheral programming languages, such as Groovy, Clojure, Scala or Kotlin, to run on a JVM, compile source code into Java bytecode and then execute it using the JRE.

These languages provide various features that overcome some limitations of Java. For example, Groovy provides strong scripting features and the scripts can run on any platform that supports JVMs. Scala and Clojure solve various scalability issues that Java program might run into in high-traffic environments. And Kotlin greatly simplifies Android application development, thanks to its concise syntax and support for functional programming. All these languages take advantage of the standard libraries and other features that are built into the Java platform.

Once an application is developed using the JDK on one system, it can be used on another system, thanks to Java class files. Because these files are portable to any standard JVM, there's no need to change or recompile the code to use the application on multiple JVMs.

How to get started with JDK

The Java Development Kit, with all the tools needed to compile and run Java applications, is distributed by the open source OpenJDK project. Developers can download and install JDK 24 for Java SE from the OpenJDK site. Since Mar. 18, 2025, this version of the JDK is in general availability, meaning it is ready for production use.

Developers can download free, GPL-licensed, production-ready OpenJDK JDK 24 binaries for Linux, macOS and Windows. In addition, Oracle's commercially licensed JDK 24 binaries and commercial builds of JDK 24.0.1 from Oracle, under a non-open source license can be downloaded directly from Oracle.

Early access builds for OpenJDK JDK 25 are also available. These open source builds are provided under the GNU General Public License, version 2, and can be downloaded from here. It's important to note that EA builds might be removed at any time. Also, they might include some security vulnerabilities, and Oracle does not provide support for them.

Learn more about Java and why it was designed to be platform independent. Explore seven benefits of Java and the top Java programming tools used in application development.