“`html

If you are an emerging Java Programmer or an experienced professional, one of the initial elements you have encountered is the Java Development Kit (JDK). Though Java is an effective programming language, the JDK enables developers to construct, compile, and execute Java applications. JDK works in conjunction with JVM (Java Virtual Machine) and JRE (Java Runtime Environment).

In this article, we will explore what JDK is, what it comprises, and why it is a crucial resource for Java developers. Let’s dive in!

Table of Contents:

• What is JDK?
• Why is JDK Significant?
• How Does Java Function?
• Structure of JDK
  • Java Development Kit (JDK)
  • Java Runtime Environment (JRE)
  • Java Virtual Machine (JVM)
• Elements of JDK
• Installation and Configuration of JDK
• Compiling and Executing Java Code using JDK
• Oracle JDK vs. Open JDK vs. Other Distributions
• The Jar Component
  • Creating a JAR File
• Final Thoughts

What is JDK?

The Java Development Kit (JDK) serves as a software development environment that is offered by Oracle and other providers tasked with creating Java applications. It encompasses a collection of tools essential for developing, debugging, and executing Java programs. The JDK is the primary component required to write a Java application.

In contrast to the Java Runtime Environment (JRE), which is mainly for running Java programs, the JDK supplies all the necessary resources for development, including writing the source code, converting it to bytecode, and executing it on the Java Virtual Machine (JVM).

Why is JDK Significant?

The JDK is vital for developers for several reasons:

• Code Compilation: Without utilizing javac, it is impossible to transform your source code into an executable format.

• Application Development: The JDK contains essential APIs and tools necessary for creating, packaging, and documenting applications.

• Debugging and Monitoring: Multiple tools like jdb and jconsole assist you in identifying issues and monitoring performance.

• Flexibility: By utilizing JDK, you can build Java applications ranging from basic utilities to extensive enterprise systems.

How Does Java Function?

The functioning of Java elucidates the procedure by which Java programs are crafted, compiled, and executed. The preceding image illustrates the sequential execution of a Java program. A detailed explanation of the Java process is provided below:

1. Source Code: The initial step in Java’s architecture involves crafting the source code. This can be done with a text editor or an IDE, which establishes the logic and structure of the application.

2. Java Compiler: The Java compiler then translates the source code into platform-independent bytecode executable on any device equipped with a compatible JVM.

3. Bytecode: Bytecode refers to the compiled Java code that remains platform-independent. It operates on any device possessing a compatible JVM, underscoring Java’s platform independence.

4. Java Virtual Machine (JVM): The Java Virtual Machine (JVM) is tasked with converting bytecode into machine code. This allows Java applications to run on any operating platform, facilitating the “Write Once, Run Anywhere” capability of Java.

5. Operating System (OS): The JVM transfers the machine code to the operating system, which then interfaces with the hardware to execute tasks as outlined in the source code.

Structure of JDK

Now, let us delve into the architecture of Java and examine the three key software components of JDK. They are: JVM (Java Virtual Machine), JRE (Java Runtime Environment), and JDK (Java Development Kit). The JDK serves as the superset encompassing the JRE, which in turn contains the JVM.

Each of these three components is detailed below:

Java Development Kit (JDK)

It is a software suite utilized to construct Java applications and applets. It comprises the JRE and multiple tools necessary for development. These tools feature a compiler (javac), which is responsible for converting source code into bytecode, an interpreter/loader (java), among others.

“““html
) for executing applications, an archiver (jar) for packaging files, and a documentation creator (javadoc). The JDK supplies all the necessary tools for a developer to compose, compile, and execute Java applications.

In the diagram above, the blue section signifies the JDK. 

Java Runtime Environment (JRE)

The JRE (Java Runtime Environment) offers the necessary environment to execute Java applications. It encompasses all the essentials needed to run your Java code, such as the JVM and key libraries. When a Java program is initiated, the JRE merges your code with the libraries, subsequently launching the JVM to run the code. While JRE is included in the JDK, it can be separately downloaded if you solely require it for running Java applications without engaging in development.

Java Virtual Machine (JVM)

Java applications utilize the concept of “Write Once, Run Anywhere” owing to the capability to execute the code across any platform, facilitated by the JVM. The JVM is a vital component of Java that provides an environment for executing Java programs. It is accountable for translating bytecode into machine code.

In summary, the JVM carries out the following tasks:

• Initially, it loads the code.
• Next, it conducts code verification.
• Then it executes the code.
• Finally, it supplies a runtime environment.

Now, let’s explore the architecture of the JVM.

The description of the JVM architecture concerning the above image is provided below:

• Class Loader: This is a component of the Java Virtual Machine (JVM) that loads class files into memory. Upon running a Java program, the class loader is the first component to retrieve the necessary classes to initiate program execution.

• Method Area: It is a memory segment within the JVM where class-related information is retained, including static variables, static blocks, static methods, and instance methods.

• Heap: The heap is essentially a memory space that is allocated when the JVM begins operation. As the Java program executes, the heap size may increase or decrease based on the application’s memory requirements.

• Stack: The stack in the JVM, also known as the thread stack, is a memory region created for each thread when it begins execution. It is utilized by that thread to store crucial data such as local variables, temporary outcomes, and details required to invoke methods and return from them. Each thread possesses an independent JVM stack.

• Native Method Stack: This part of the JVM memory is tasked with managing all native methods utilized in a Java application. Native methods are functions written in languages like C or C++ rather than Java. The native stack tracks these methods during execution.

• Execution Engine: The execution engine comprises the JIT compiler and Garbage Collector.

• JIT Compiler: The JIT (Just-In-Time) compiler is a component of the Java runtime environment that enhances the performance of Java applications. It converts bytecode into machine code while the program is actively running, executing this process only when necessary, hence the term “just-in-time.” By default, the JIT compiler is enabled, and once a method is compiled, the JVM operates more efficiently.

• Garbage Collector: The Garbage Collector within the JVM is responsible for identifying and removing unused or redundant objects from memory. Its operation involves monitoring all objects in the JVM’s heap space and disposing of those that are no longer utilized by the program. Garbage collection follows two primary phases:
  • Mark: During this phase, the garbage collector identifies objects that are still in use by the program versus those that are not.
  • Sweep: This phase involves eliminating the objects that are no longer in use, freeing up memory for future allocation.

Components of JDK

Below are some significant elements of the JDK:

• java: This is the launcher utilized for all Java applications.
• javac: This is the compiler designed for the Java programming language.
• javadoc: This tool is used to produce the API documentation.
• jar: This functions to create and manage all the JAR files.
• jps: This stands for Java Virtual Machine Process Status Tool, which is utilized to oversee the currently running JVMs for the executing program.
• idlj: This is used to generate Java bindings from a specific Java IDL file.
• javap: This is employed to disassemble files.
• JConsole: This serves as a Java Management and Monitoring tool.
• javac -h: This is a stub generator; a C header is used for writing native methods.
• javaws: Previously utilized as the Web Start launcher for JNLP applications, it has now been deprecated in the latest JDK iterations.
• jhat: This is a tool for heap analysis.
• jmc: This is an abbreviation for Java Mission Control.
• xjc: This takes an XML schema and produces Java classes.
• apt: This stands for Annotation Processing Tool.
• jdb: This is a debugging utility.
• extcheck: This is a utility employed for detecting conflicts in JAR files.
• keytool: This is a keystore management tool.
• jstatd: This is a background tool for monitoring JVM performance and resource usage.
• jstat: This serves as a statistics monitoring utility within the JVM.
• jshell: This was introduced in Java 9.
• jstack: This tool prints Java thread stack traces for debugging purposes.
• jrunscript: This is a Java command-line script shell.
• jpackage: This is utilized for creating self-contained application bundles.
• jarsigner: This is a tool for signing and verifying JAR files.

“““html

• jinfo: This shows the configuration and system attributes of a running Java process.

Installation and Setup of JDK

Setting up the JDK in your development environment is straightforward. Please adhere to the following steps:

1. First, navigate to the Official Oracle JDK website to download the JDK.

2. Select the newest version of the JDK. At present, the latest release of JDK is JDK 24. Click to download and add it to your classpath. Obtain the .exe file for Windows.

3. Once the .exe file is downloaded, you will be taken to the page shown below.

4. Click Next. Specify the file location where you wish to keep JDK-24 on your device. Afterward, you will be directed to the page outlined below.

5. To configure the JAVA_HOME variable, first access the control panel, then select System, proceed to Advanced System Settings, and then Environment Variables. In the Environment Variables section, simply add a new system variable titled JAVA_HOME with the installation path of the JDK as its value.

Congratulations, you have successfully downloaded and installed JDK-24 on your system.

Once JDK is installed, JRE appends the Java command to your command line interface. You can confirm this by entering java -version in the command line.

Compiling and Executing Java Code with JDK

Now that the JDK is installed on your system, you can utilize it to compile your Java text file into an executable program. During this process, your Java text is transformed into bytecode after compilation. That bytecode has the .class extension.

You can test this by writing the code given below in VSCode and naming the text file index.java.

Example:

var isMobile = window.innerWidth “);

editor4501.setValue(decodedContent); // Set the default text editor4501.clearSelection();

editor4501.setOptions({ maxLines: Infinity });

function decodeHTML4501(input) { var doc = new DOMParser().parseFromString(input, “text/html”); return doc.documentElement.textContent; }

// Function to copy code to clipboard function copyCodeToClipboard4501() { const code = editor4501.getValue(); // Get code from the editor navigator.clipboard.writeText(code).then(() => { // alert(“Code copied to clipboard!”);

jQuery(“.maineditor4501 .copymessage”).show(); setTimeout(function() { jQuery(“.maineditor4501 .copymessage”).hide(); }, 2000); }).catch(err => { console.error(“Error copying code: “, err); }); }

function runCode4501() {

var code = editor4501.getSession().getValue();

jQuery(“#runBtn4501 i.run-code”).show(); jQuery(“.output-tab”).click();

jQuery.ajax({ url: “https://intellipaat.com/blog/wp-admin/admin-ajax.php”, type: “post”,

data: { language: “java”, code: code, cmd_line_args: “”, variablenames: “”, action:”compilerajax” }, success: function(response) { var myArray = response.split(“~”); var data = myArray[1];

jQuery(“.output4501”).html(“

"+data+"");
									jQuery(".maineditor4501 .code-editor-output").show();
									jQuery("#runBtn4501 i.run-code").hide();
									
								}
							})
					

						}
						
						
		function closeoutput4501() {	
		var code = editor4501.getSession().getValue();
		jQuery(".maineditor4501 .code-editor-output").hide();
		}

``````javascript
    // Attach event listeners to the buttons
    document.getElementById("copyBtn4501").addEventListener("click", copyCodeToClipboard4501);
    document.getElementById("runBtn4501").addEventListener("click", runCode4501);
    document.getElementById("closeoutputBtn4501").addEventListener("click", closeoutput4501);
 
    



Results:







To guarantee the seamless execution of the previously mentioned code on VSCode, ensure that you install the suggested extension packages for Java.







Oracle JDK vs. Open JDK vs. Other Variants




    

        

            
            

                
JDK Variant
                
Licensing Type
                
Commercial Assistance
                
Essential Features
                
Suitable For
            
            
            

                
Oracle JDK
                
Oracle NFTC (No-Fee Terms and Conditions)
                
Optional (Paid LTS accessible)
                
Java Flight Recorder, Java Mission Control, Performance Gains
                
Businesses requiring sophisticated monitoring tools and optional paid support
            
            
            

                
OpenJDK
                
GPL v2 + Classpath Exception
                
Community-supported only
                
Authentic open-source reference implementation
                
Open-source initiatives, education, general programming
            
            
            

                
Amazon Corretto
                
Open Source (GPL + CE)
                
Yes (Free LTS from AWS)
                
Multi-platform compatibility, LTS, routine updates
                
Operational settings on AWS or cross-platform environments
            
            
            

                
Azul Zulu
                
Free & Commercial
                
Yes (Flexible Options)
                
Extensive OS support, compatibility with embedded systems
                
Developers needing cross-platform or embedded JDKs
            
            
            

                
Eclipse Temurin
                
Open Source
                
Community-driven assistance
                
Managed by Eclipse Adoptium, regular security and performance upgrades
                
Developers looking for a stable, reliable open-source JDK
            
            
            

                
Red Hat OpenJDK
                
Open Source (Red Hat Subscription for LTS)
                
Yes (via RHEL Subscription)
                
Optimized for Red Hat environments, secure updates
                
Companies leveraging RHEL or Red Hat infrastructure
            
            
            

                
SAP SapMachine
                
Open Source
                
Community + SAP-focused
                
Optimized for SAP applications, enterprise-grade runtime
                
SAP-centric enterprise solutions, systems prioritizing stability
            
        
    








The Jar Component



There exists a variety of valuable tools in JDK, and one of the most favored after javac (the Java compiler) is the jar  tool. A JAR (Java ARchive) file is a compilation of bundled Java classes that are consolidated within a single compressed file. Once you compile your Java program into .class files, you can utilize the jar tool to merge them into a .jar file. This simplifies the process of distributing, managing, and executing your Java application in an organized manner. For instance, you can transform your HelloWorld.class file into a .jar file for convenience.







Creating a JAR File



The procedure to generate a JAR file is as follows:




Initially, compose your Java code and save it. For instance,




Example:



			

				Java 
			
			

				

					
					

						
							 Duplicate Code
							
				

						

					
				
				

				Code Duplicated!
				

					

						

							 Close Code
						
						

					
				
			
		
  




Compile it using the following javac command.



javac HelloWorld.java
This command will produce the file HelloWorld.class

After you have generated the .class file, you need to create a file named manifest.txt by using the following line:

Main-Class: HelloWorld

Next, utilize the jar utility that comes with the JDK. Input the following command in the terminal:

jar cfm HelloWorld.jar manifest.txt HelloWorld.class
Where, 

• c = create
• f = specify filename
• m = include manifest file

This command generates the file HelloWorld.jar.

4. You can execute the JAR file using the following command:

java -jar HelloWorld.jar

Conclusion

The Java Development Kit (JDK) is the most crucial component of Java programming. It encompasses everything needed when you are developing, compiling, debugging, and executing Java applications. Java development cannot occur without the JDK. It's vital for you to grasp its elements and purpose to leverage its functionalities in building solid, scalable Java applications.

Installing the JDK is the initial phase in your pathway to Java development. It will introduce you to the capabilities of one of the most potent languages in the software realm.

What is a Java Development Kit (JDK) – FAQs

The post What is JDK (Java Development Kit)? appeared first on Intellipaat Blog.

```