Once Java is installed and your environment is configured, you need tools to actually develop Java applications. The JDK is more than a runtime for executing programs; it also provides a collection of development tools that help you write, compile, inspect, debug, and manage Java code.
Understanding these tools early is useful because you will see many of them repeatedly throughout your Java career. Some are simple command-line utilities, while others are commonly used through an IDE.
Key idea: The JDK provides the core tools required to turn Java source code into executable Java applications.
The Java Compiler
The most important development tool for a beginner is the Java compiler, commonly invoked using javac.
Its job is to compile Java source code into Java bytecode.
Hello.java
↓
javac
↓
Hello.class
For example, if you have a Java source file named Hello.java, you can compile it using:
javac Hello.java
If compilation succeeds, Java produces a corresponding class file containing bytecode.
The java Command
After compiling the program, you need a way to execute it. The java command is used to launch a Java application.
For example:
java Hello
Notice that you normally provide the class name rather than writing Hello.class in the command.
Easy memory trick: javac compiles. java runs.
Java Documentation Tool
The JDK also provides tools for working with documentation. One well-known tool is javadoc.
Javadoc can generate documentation from specially written comments in Java source code.
/**
* Represents a student.
*/
public class Student {
}
In larger applications, documentation is valuable because developers need to understand classes, methods, parameters, and expected behavior without reading every implementation detail.
Java Archive Tool
Java applications often contain many compiled classes and resources. Packaging these files into a single archive makes them easier to distribute.
The JDK provides the jar tool for creating and working with Java Archive files.
jar
A JAR file commonly uses the .jar extension and can contain compiled classes, resources, and metadata.
Java Application
↓
Compiled Classes + Resources
↓
JAR
↓
Distribution
Java Debugger
When a program does not behave as expected, simply reading the code is not always enough. Developers often need to inspect the program while it is running.
The JDK includes the jdb command-line debugger.
A debugger can help developers investigate things such as program execution, variable values, and the location where execution is currently paused.
Modern IDEs provide much more convenient graphical debugging interfaces, but understanding that debugging is part of the development process is important even if you rarely use jdb directly.
Java Monitoring and Diagnostic Tools
The JDK also includes tools that can help developers and administrators inspect Java applications and investigate runtime behavior.
These tools become particularly valuable when working with larger applications, performance problems, memory issues, or production systems.
As a beginner, you do not need to memorize every JDK utility. What matters is understanding that the JDK provides a broad set of tools beyond the basic compiler and runtime commands.
Common Java Development Tools
| Tool | Main Purpose |
|---|---|
| javac | Compiles Java source code into bytecode. |
| java | Launches and runs Java applications. |
| javadoc | Generates documentation from Java source comments. |
| jar | Creates and manages Java Archive files. |
| jdb | Provides command-line debugging capabilities. |
Development Tools vs Runtime
It is important to separate the idea of development from execution.
When you develop an application, you may need to write code, compile it, debug it, generate documentation, and package it. When you simply run an already-built application, you may only need the runtime environment.
Development
↓
Write
↓
Compile
↓
Debug
↓
Package
↓
Run
The JDK is designed to support the development side of this workflow.
Using javac and java Together
Let's look at the basic workflow with a tiny program.
public class Hello {
public static void main(String[] args) {
System.out.println("Hello Java");
}
}
Save the source code as:
Hello.java
Compile it:
javac Hello.java
This produces:
Hello.class
Then run the compiled class:
java Hello
The important sequence is therefore:
.java ↓ javac ↓ .class ↓ java ↓ Program Output
Why IDEs Are So Popular
You might wonder why developers use IDEs if the JDK already provides command-line tools.
The answer is convenience. An IDE combines many development activities into one interface. It can provide code completion, project management, compilation, debugging, navigation, refactoring, and many other features.
However, the IDE still relies on a Java development environment underneath. Understanding the basic JDK commands helps you understand what your IDE is doing behind the scenes.
Instructor tip: Do not become dependent on clicking a Run button without understanding compilation and execution. Knowing the command-line workflow makes IDE errors much easier to diagnose.
Command-Line Tools vs IDE
| Approach | Example | Main Advantage |
|---|---|---|
| Command Line | javac Hello.java | Simple and direct understanding of the Java process. |
| IDE | Run or Debug controls | Provides an integrated development experience. |
Common Beginner Mistakes
- Confusing javac with java.
- Trying to run a Java source file with the compiler command.
- Thinking that an IDE replaces the JDK.
- Learning only IDE buttons without understanding the underlying Java compilation process.
- Assuming every JDK tool must be memorized before learning Java programming.
Small Learning Checkpoint
Complete this workflow:
Java Source Code
↓
_____
↓
Java Bytecode
↓
_____
↓
Program Execution
The answers are javac and java.
Interview Insight
A common interview question is: "What is javac?"
A concise answer is: "javac is the Java compiler supplied with the JDK. It compiles Java source code into bytecode."
Another common question is: "What is the difference between java and javac?"
The answer is straightforward: javac compiles Java source code, while java launches a Java application and executes its bytecode through the JVM.
Quick Revision
| Tool | Remember This |
|---|---|
| javac | Compiles Java source code into bytecode. |
| java | Runs a Java application. |
| javadoc | Generates documentation from Java source comments. |
| jar | Packages Java classes and resources into JAR archives. |
| jdb | Provides command-line debugging capabilities. |
| IDE | Provides an integrated environment for Java development while relying on the underlying Java toolchain. |
The JDK is not simply something you install so that Java can run. It is a complete development toolkit containing the fundamental tools used throughout the Java development lifecycle. Once you understand the basic roles of javac, java, packaging, documentation, and debugging tools, you are ready to put everything together by creating and running your first Java program.