Platform Independence in Java

Suppose you have written one Java program and want it to run on several different types of computers. Each of those computers may have different hardware and a different operating system. A natural question follows: how can one program be ready for all of them? This article answers that question by following a Java program from the moment its source is written to the moment it runs on a real machine.

The short answer is that Java does not ask every computer to understand the same physical machine language directly. Instead, the program is translated into a different kind of machine language, one designed for a computer that is virtual rather than physically present. Keep that idea in mind as we trace the steps.

A Java program starts as Java source code, which is the text that a programmer writes. That source is compiled into Java bytecode. Bytecode is the machine language of the Java Virtual Machine, so it is the form the program takes once it is ready to be run in Java's own environment. The bytecode is then handled by a Java bytecode interpreter, which carries out the program on a particular type of computer.

The word virtual is the key to understanding the JVM. A physical computer is a real piece of hardware sitting on a desk or in a rack. The JVM is not that kind of machine. It is a computer that is defined in software and imitated on top of whatever real computer is actually present. Because the JVM is a defined machine with its own machine language, a compiled Java program can be written against that machine rather than against the specific processor of any one computer.

Bytecode cannot do its work alone, because the physical computer does not understand the JVM's machine language directly. A Java bytecode interpreter fills that gap. The interpreter implements the JVM for a particular type of computer, so it knows how the virtual machine's instructions correspond to the real hardware and operating system in front of it.

Each interpreter is tailored to one type of computer. The bytecode itself stays the same. What changes from one machine to another is the interpreter that is paired with it. This pairing is how Java achieves platform independence: the same compiled bytecode is combined with a suitable interpreter on each different computer.

The interpreter's work is repetitive. It handles the bytecode one instruction at a time, and the loop below shows the pattern that repeats until the program is finished.

Now we can answer the opening question. The same compiled Java program can run on different types of computers because the program is compiled into bytecode for the JVM, and each type of computer receives its own suitable interpreter. The bytecode is shared; the interpreter is specific to the machine.