Before knowing why java is platform independent let’s have some brief about compiler phases:

Lexical Analyser:

Accepts high-level language code and tokenize the input to a valid set of tokens.

Syntax Analyser:

It checks the syntactical structure of the given input, i.e. whether the given input is in the correct syntax.

Semantic Analyser:

Interpret symbols, their types, and their relations with each other.

Intermediate Code Generation:

In the analysis-synthesis model of a compiler, the front end of a compiler translates a source program into an independent intermediate code.

Code Optimizer:

It transforms the code and tries to improve the code by making it consume fewer resources (i.e. CPU, Memory) and deliver high speed.

Target Code Generation:

Use the optimized intermediate code and generates target code or machine code on which machine can operate easily.

A Java program whenever compiled, the compiler only generates the intermediate code called bytecode and on runtime, it generates machine code. Hence Java program has lesser compile-time and has higher runtime. Let’s have some elaboration on this:

• High-level language code (i.e.: java code) goes to java compiler.
  

• Java compiler follows the lexical analyzer phase, syntax analyzer phase, semantic analyzer phase and then goes the intermediate code generation phase.
  

• On Intermediate code generation, phase Java compiler creates intermediate code i.e. bytecode
  

• Bytecode is the machine-independent code ready to run on any environment or platform. This is responsible for java portability.

• We can run Java bytecode on any machine having JDK installed and running, JVM takes up the bytecode and runs it on the machine.
  

• We pass bytecode and run the java program. JDK first converts bytecode to machine code than it runs that code on that machine.