What is Java and what is "write once, run anywhere"?

Question

Accepted Answer

**Java** is a high-level, statically-typed, object-oriented language designed to be **platform-independent**. Its famous slogan — **"write once, run anywhere" (WORA)** — captures its core feature: compiled Java runs on any device that has a JVM, without recompilation.

## How WORA works: compile to bytecode, not native code

```text
Java source (.java)
      │  javac (compiler)
      ▼
Bytecode (.class) — platform-INDEPENDENT intermediate code
      │  JVM (Java Virtual Machine) interprets/JIT-compiles it
      ▼
Runs on Windows / Linux / Mac — the SAME bytecode, any platform with a JVM
```

```java
// Hello.java
public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, World");
    }
}
// javac Hello.java → Hello.class (bytecode) → `java Hello` runs anywhere
```

Unlike C/C++ (which compile to platform-specific machine code), Java compiles to **bytecode** that the JVM translates to the host machine's instructions at runtime. So one compiled artifact runs unchanged across operating systems — the JVM abstracts away platform differences.

## Key characteristics

```text
✓ Statically typed   — types checked at compile time (catch errors early)
✓ Object-oriented    — everything organized in classes
✓ Platform-independent — bytecode + JVM = WORA
✓ Automatic memory management — garbage collection (no manual free)
✓ Strong ecosystem   — vast libraries, Spring, mature tooling
✓ Backward-compatible — old code keeps running on new JVMs
```

## What Java is used for

```text
✓ Enterprise back-ends (Spring) — banking, large-scale systems
✓ Android apps (historically the primary language)
✓ Big data (Hadoop, Spark, Kafka are JVM-based)
✓ Large, long-lived systems where stability and tooling matter
```

## Why it matters

Understanding Java's core identity — a statically-typed, OOP language whose **compile-to-bytecode + JVM** model delivers "write once, run anywhere" — explains why it became dominant in enterprise and Android development.

WORA was revolutionary: it freed software from platform-specific compilation, and the JVM's maturity (performance, garbage collection, tooling) plus strong static typing made Java a reliable choice for large, long-lived systems.

This foundation frames everything else about the language and its ecosystem.