Bytecode vs Machine Code

Direct Answer

JVM bytecode is the platform-independent instruction and metadata format stored in class files; machine code is the processor-specific instruction sequence executed directly by a CPU. A JVM interprets bytecode or translates selected parts into native machine code for the current platform.

Deep Dive & Architecture

Bytecode instructions and native execution

A small add(int, int) method can load two local values, execute the JVM instruction iadd, and return the result. Those operations target the JVM's operand-stack model. An x86-64 processor and an ARM processor have different native instruction sets, so neither executes the class-file bytes directly as its normal machine code.

Symbols are linked at runtime

Bytecode instructions often refer indirectly to classes, fields, methods, strings, and dynamic call-site data through a runtime constant pool. Loading and linking turn symbolic references such as a method owner and descriptor into runtime structures under type, access, and loader rules. Resolution may be lazy, within the timing allowed by the JVM specification.

Translation is not one-to-one

An interpreter can execute a bytecode sequence instruction by instruction. A JIT compiler can instead inline several methods, remove a redundant allocation, hoist a check, or fold a result. The final native path may contain fewer, more, or very different machine instructions than a line-by-line bytecode translation suggests.

Use javap -c to learn the class-file instruction flow; use runtime-specific assembly or compilation diagnostics only when the native result matters. The class file is the portable contract and the generated machine code is one run's platform-specific execution form. Source, bytecode, and native code are three related but distinct representations.

Code Example

class BytecodeVsMachineCode {
    static int add(int left, int right) {
        return left + right;
    }

    public static void main(String[] args) {
        System.out.println(add(20, 22));
    }
}

After javac BytecodeVsMachineCode.java, run javap -c BytecodeVsMachineCode to see instructions such as local loads, iadd, and return.