What is Java Architecture? Components of Java Architecture

Java Architecture is a combination of compilation and interpretation. This article explains how to create a Java programming program. Let me first introduce the article’s agenda.

These are the topics we will discuss:

What is Java Architecture?

In this article, I will show you how to use Java architecture in easy steps.

• Java has a process for compilation and interpretation.
• The Java Compiler converts Java code into byte codes.
• The JVM then converts the byte codes into machine code.
• The machine executes the Machine code directly.

This diagram shows the internal workings of Java Code, or more precisely Java Architecture.

Components of Java Architecture

The three main components of the Java language are JVM vs JRE vs JVM.

Java Virtual Machine, Java Runtime Environment, and Java Development Kit are the respective Java Virtual Machines.

Let me go over each one one by one.

Also read: The benefits of programming with Java software development

Java Virtual Machine:

Have you heard of WORA? WORA stands for Write once, Run Anywhere. Because Java applications can run code on any platform, they are known as WORA. JVM is the only reason this happens. JVM is a Java platform component that provides an environment for Java programs to be executed. JVM converts the bytecode to machine code, which is executed on the machine where the Java program runs.

In a nutshell, JVM does the following:

• Loads the code
• Verifies the code
• Executes the code
• Provides runtime environment

Show you the JVM architecture, here —

Explanation:

Class Loader: The class loader is a subsystem within JVM. It is used for loading class files. Class loader loads the Java program first when we run it.

Class method area: It is where Class data will be kept. This area stores static variables, static blocks, static methods, and instance methods.

Heap: A heap is created by the JVM when it starts up. It can grow or shrink depending on the application’s performance.

Stack is a JVM stack: It’s also known as a Thread Stack. It is a JVM memory data area that is used to store one execution thread. A thread uses the JVM stack to store different elements, e.g. The thread uses the JVM stack to store various elements, including local variables, partial results, and data for calling methods or returns.

Native stack: This includes all native methods that are used in your application.

Execution engine:

• JIT compiler
• Garbage collector

JIT compiler:  The Just-In-Time (JIT), compiler is part of the runtime environment. This compiler compiles bytecodes at runtime to improve the performance of Java applications. By default, the JIT compiler is activated. The JVM calls the compiled method a method when it is compiled. The JIT compiler converts the bytecode into machine code and compiles it “just-in-time” to run.

Garbage collector: The name Garbage Collector refers to the act of collecting unused material. This is what Garbage Collection does in JVM. It records every object in the JVM heap space and removes any that are not needed.

Two simple steps are required to collect garbage: Mark and Sweep

• Mark – It is where the garbage collector determines which memory pieces are in use and which ones are not
• Sweep – It is used to remove objects that were identified in the “mark” phase.

Java Runtime Environment:

The JRE software creates a runtime environment where Java programs can execute. The JRE software is an on-disk system that takes Java code and combines it with required libraries. Finally, the JVM starts to execute the Java code. JRE includes the libraries and software that Java programs need to run. JRE is part of JDK (which will be studied later), but you can download it separately.

Java Development Kit:

Java Development Kit (JDK), is a software environment that allows you to create Java applets and applications. It includes JRE, several development tools, an executor/loader (java), a compiler (javac), an archiver (jar), and a documentation generator(javadoc), along with another tool.

Let me explain the development tools to all of you.

• Java: It is the launcher of all java applications.
• javac: Complier of the Java programming languages.
• Javadoc: It is the API documentation generator.
• Jar: Creates and manages all JAR files

Let’s continue with Java architecture.

Also read: Essential Tips for Java Developer Should learn in 2021

How is Java platform independent?

When is any programming language called platform-independent? It is only possible if the programming language can be used on all operating systems that are available for its compilation and development.

Java is platform-independent because of the use of bytecode. Let me explain what bytecode is. In simple terms,
Bytecode is a code of the JVM which is machine-understandable. Java executes Bytecode, proving it to be a platform-independent programming language. This article will explain the steps involved with the execution of Java bytecode.

sample.java → javac (sample. class) → JVM(sample.obj) → final output

Java compiler uses the first source code and converts it in.class files. The class file code is in byte form. JVM uses that class file to convert into an object. The final output will be displayed on your screen.

JIT in Java

The Just In Time compiler, also known as JIT is responsible for optimizing Java-based applications’ performance at runtime. A compiler is a key factor in the performance of any application.

The JIT compiler converts the byte code into machine code and compiles it “Just in Time” for you to run. The JVM calls the compiled method when a method has been compiled.

Let’s dive deeper:

Based on the instruction set, the byte code must be interpreted and compiled to correct machine instructions. These can also be executed directly in the instruction architecture that uses byte code. The execution speed is affected by how the byte code is interpreted.

JIT compilers communicate with the Java Virtual Machine at run-time and convert suitable bytecode sequences to native machine code (as illustrated in the diagram). This improves performance. A JIT compiler is more efficient than having the JVM interpret the same bytecode sequence repeatedly, incurring overhead and causing delays in the translation process.

This brings me to the end of my article on Java Architecture. I trust the topics discussed above will add value to your Java knowledge.

After you’ve learned the basics of Java, take the Java Online Course from Edureka. This trusted online learning company has more than 250,000 learners around the world. Edureka’s Java J2EE/SOA certification and training course are for professionals and students who are interested in becoming a Java Developer. This course will give you a headstart in Java programming. It will teach you how to use both core and advanced Java concepts, as well as various Java frameworks such as Hibernate and Spring.

Image Credit: edureka