Why Is Java Platform Independent?

Java is platform independent because your source is compiled into an intermediate bytecode format rather than into machine instructions for a particular processor and operating system. The compiler, javac, emits class files whose format is specified byte-for-byte by the Java Virtual Machine specification — the same on Windows, on Linux and on macOS. At runtime, the JVM on that machine interprets or JIT-compiles that bytecode into native instructions for the local CPU.

The platform-specific part therefore lives entirely inside the JVM implementation, which is a native component written in C++ and linked against the operating system. It is the JVM that knows how to open a socket, spawn a process or read a file. Your bytecode contains no such knowledge; it only contains calls into the Java class library, and the class library's native methods are the layer that ultimately calls into the operating system.

public class Main {
    public static void main(String[] args) {
        // The source contains no OS-specific calls at all.
        // The platform knowledge lives in the JVM and the class library.
        System.out.println("os.name    : " + System.getProperty("os.name"));
        System.out.println("os.arch    : " + System.getProperty("os.arch"));
        System.out.println("file.sep   : " + System.getProperty("file.separator"));
        System.out.println("line.sep   : " + System.getProperty("line.separator").trim());
        System.out.println("jvm        : " + System.getProperty("java.vm.name"));
        System.out.println("class file : CA FE BA BE (same bytes on every platform)");
    }
}

Two honest caveats. Portability is at the bytecode level, not the source level — the same bytecode runs everywhere, but the same source may not compile everywhere if it touches platform APIs. And the JVM itself is not portable: it is a native binary, so you still need a JVM build for each operating system and processor architecture you intend to support.

A platform-dependent program produces different behaviour depending on the machine it runs on; a platform-independent one behaves identically everywhere. In Java the portability test is simple: if the only difference between two runs is the operating system underneath, the program is platform independent at the bytecode level.

The trap for juniors is writing the platform check inside the business logic. The moment a method starts asking about the operating system, that method becomes untestable on other platforms and impossible to reason about. The cleaner design pushes the decision to the edge of the system, where it is made once, and lets the core of the program depend on an abstraction instead.

public class Main {
    public static void main(String[] args) {
        // The platform-specific decision lives here, at the edge.
        String os = System.getProperty("os.name").toLowerCase();
        boolean windows = os.contains("win");

        String separator = windows ? "\\\\" : "/";
        System.out.println("os          : " + os);
        System.out.println("separator   : " + separator);

        // The core logic only ever sees the abstraction, never the OS.
        String path = join("etc", "hosts");
        System.out.println("joined path : " + path);
    }

    static String join(String first, String second) {
        char sep = System.getProperty("file.separator").charAt(0);
        return first + sep + second;
    }
}

In a real system the edge is a small adapter class — a PathStrategy or a FileSystemPort — injected into the component that needs it. Then the tests supply a fake, and the core never learns that it is running on Windows. That is the practical meaning of platform independence: not that the program ignores the operating system, but that only one small piece of it has to.