Java Bytecode

Java bytecode is a set of instructions of Java code that the JVM understands. As soon as a Java program is compiled, bytecode for that code is generated. In simple terms, Java bytecode is the machine code in the form of a .class file. With the help of Java bytecode, we achieve platform independence in Java. Machine or platform-independent code is code that runs on multiple computer architectures without requiring any changes.

Low-level and high-level sets of instructions are separated by bytecode. Because we write our code in a high-level language, it is compiled into bytecode, which the JVM then interprets into machine code, which is a low-level set of executable instructions. For this reason, we refer to bytecode as a code that spans low-level and high-level languages.

How does it work?

When we compile Java code, the compiler compiles that program and a bytecode (.class file) is generated for that piece of code. When we execute this .class file on any other platform, it executes easily.

After the first compilation, the bytecode generated is now run by the Java Virtual Machine and not the processor in consideration. It means that we only need to have a basic Java installation on any platform that we want to run our code on.

Resources required to run the bytecode are made available by the Java Virtual Machine, which calls the processor to allocate the required resources. JVMs are stack-based, so the JVM maintain a stack to read the code.

Advantages of Java Bytecode

The set of instructions for the JVM may differ from system to system, but all can interpret the bytecode. A point to keep in mind is that bytecodes are non-runnable codes and rely on the availability of an interpreter to execute; thus, the JVM comes into play.

• Platform Independence: Bytecode runs on the Java Virtual Machine (JVM), which is available on many platforms. It means that we can write code once and run it anywhere (on different platforms) without modification.
• Security: Bytecode runs within the JVM, which functions like a sandbox. It helps to stop malicious code from damaging the host system. The JVM also verifies bytecode to identify unsafe operations before running.
• Performance Optimization: The JVM uses Just-In-Time (JIT) compilation to convert bytecode into native machine code at runtime, improving performance over time as the program runs.
• Portability of Libraries and Tools: Since bytecode is standardized, Java libraries and tools can be shared across platforms without recompilation. It makes development and deployment much smoother.
• Compact and Efficient: Bytecode is more compact than source code, which reduces the size of compiled programs and speeds up loading and execution.
• Supports Dynamic Linking: Bytecode allows classes to be dynamically loaded and linked at runtime, enabling modular and flexible application design.

Example of Java Bytecode

Consider the following Java program that adds two numbers.

Output:

15

Compile the above program using the command javap -c Main. After compilation, we get the following bytecode.

We observe that the Java code gets converted into bytecode (an unreadable form).

• iconst_5 and bipush 10 load constants 5 and 10.
• iadd adds the two integers.
• getstatic and invokevirtual handle the System.out.println call.
• new, dup, and invokespecial create and initialize a StringBuilder.