What is Java?

What is Java?

Java is a statically typed, object-oriented, compiled language that runs on the Java Virtual Machine (JVM). Its core promise — "Write Once, Run Anywhere" (WORA) — means bytecode compiled on any platform runs unchanged on any other platform with a JVM installed. No recompilation needed.

Released in 1995 by Sun Microsystems, Java became the dominant language for enterprise software and remains one of the top 2 languages by usage in 2026. It powers the backend of companies like LinkedIn, Netflix, Uber, and most of the global banking infrastructure.

How Java Works: Compile Once, Run Anywhere

Unlike C or C++ which compile directly to platform-specific machine code, Java uses a two-stage process. This is what enables platform independence.

/*
 *  YOUR CODE          BYTECODE              NATIVE CODE
 *  (HelloWorld.java)  (HelloWorld.class)    (Platform-specific)
 *        │                   │                     │
 *        │  ┌─────────────┐  │  ┌──────────────┐   │
 *        └─▶│ javac       │──┴─▶│     JVM      │──▶│
 *           │ (compiler)  │     │  (java cmd)  │   │
 *           └─────────────┘     └──────────────┘   │
 *                                      │
 *                       ┌──────────────┼──────────────┐
 *                  ┌────▼────┐   ┌─────▼────┐   ┌─────▼─────┐
 *                  │ Windows │   │  macOS   │   │   Linux   │
 *                  │   JVM   │   │   JVM    │   │    JVM    │
 *                  └─────────┘   └──────────┘   └───────────┘
 *
 *  The SAME .class file runs on ANY platform with a JVM installed.
 */

Your first program

// File: HelloWorld.java  (filename must match public class name)
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

# Compile → produces HelloWorld.class (bytecode)
javac HelloWorld.java

# Run → JVM executes the bytecode
java HelloWorld

# Java 11+ shortcut: compile and run in one step
java HelloWorld.java

# Java 25+: compact source files drop the class/main boilerplate entirely
# for scripts and small programs — see the "Which version" box below

JVM Architecture

The JVM is not a simple interpreter. It has three main components working together:

/*
 *  ┌──────────────────────────────────────────────────────────┐
 *  │                   Java Virtual Machine                    │
 *  │                                                          │
 *  │  ┌──────────────────────────────────────────────────┐   │
 *  │  │  Class Loader                                     │   │
 *  │  │  • Loads .class files into memory                 │   │
 *  │  │  • Verifies bytecode integrity                    │   │
 *  │  └──────────────────────────────────────────────────┘   │
 *  │                          │                               │
 *  │  ┌──────────────────────────────────────────────────┐   │
 *  │  │  Runtime Data Areas                               │   │
 *  │  │  ┌──────────┬──────────┬────────────────────────┐│   │
 *  │  │  │  Method  │   Heap   │  Stack (per thread)    ││   │
 *  │  │  │  Area    │ (Objects)│  (Local vars, frames)  ││   │
 *  │  │  └──────────┴──────────┴────────────────────────┘│   │
 *  │  └──────────────────────────────────────────────────┘   │
 *  │                          │                               │
 *  │  ┌──────────────────────────────────────────────────┐   │
 *  │  │  Execution Engine                                 │   │
 *  │  │  • Interpreter: line-by-line for cold code        │   │
 *  │  │  • JIT Compiler: compiles hot paths to native     │   │
 *  │  │  • GC: automatic heap memory management           │   │
 *  │  └──────────────────────────────────────────────────┘   │
 *  └──────────────────────────────────────────────────────────┘
 */

What Can You Build With Java?

Java LTS Versions: What Actually Matters

Java releases every 6 months but only LTS (Long-Term Support) versions get multi-year patches. Use LTS for production. Non-LTS releases — including 22, 23, 24 and 26 — are 6-month previews: fine for trying a language feature early, not for a production baseline.

Java vs Modern Alternatives

The honest comparison — not "Java is best everywhere", but when each language genuinely wins:

Java in Production: What Seniors Actually Use

The gap between "learning Java" and "working with Java professionally" is significant. This is the real stack you'll encounter in enterprise teams:

The Standard Enterprise Stack (2026)

• Spring Boot 3.x — the de facto framework. Auto-configuration, embedded Tomcat/Netty, production-ready Actuator endpoints. Requires Java 17+; runs cleanly on 25.
• Spring Data JPA + Hibernate — ORM layer. Know the N+1 problem, lazy loading pitfalls, and when to drop to native queries or JOOQ.
• Spring Security + OAuth2/JWT — every production API needs it. Know the filter chain, not just the annotations.
• Apache Kafka — async communication between microservices. If you haven't used it in production, it's the single biggest gap most Java developers have.
• Docker + Kubernetes — Java apps run in containers. Knowing how to tune JVM memory for containers is not optional.
• Gradle — winning over Maven for new projects. Faster incremental builds, Kotlin DSL for type-safe build scripts.

JVM Flags Every Senior Must Know

// Container-aware memory — CRITICAL in Kubernetes
// Without this, JVM reads host memory instead of container limits
-XX:MaxRAMPercentage=75.0

// GC selection
// G1GC (default since Java 9): best for most web services
// ZGC (production since Java 15): sub-millisecond pauses regardless of heap size
// Generational Shenandoah (stable since Java 25): same low-pause goal as ZGC,
// different algorithm — worth benchmarking both under your actual load
-XX:+UseZGC -Xmx4g

// Virtual threads — the biggest concurrency change since Java 5 (Java 21+)
// In Spring Boot 3.2+ application.properties:
spring.threads.virtual.enabled=true
// That's it. Your app now handles dramatically more concurrent requests.
// Blocking I/O is fine again — virtual threads are cheap (< few KB each).

// Compact object headers (Java 25): shrinks per-object header from 12-16 to
// 8 bytes. Free heap-density win for object-heavy workloads — enable and measure.
-XX:+UseCompactObjectHeaders

Interview Questions: Junior vs Senior