javac Hello.java      # produces Hello.class (bytecode)
java Hello            # JVM loads Hello.class and runs main

java Hello.java       # Java 11+: compile in memory and run a single-file program

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, Java");
    }
}

long big = 3_000_000_000L;   // L suffix required beyond int range; underscores aid readability
float f = 3.14f;              // f suffix required, otherwise it is a double
int hex = 0xFF;               // 255
int bin = 0b1010;             // 10
char c = 'A';
var list = new ArrayList<String>(); // Java 10+: local variable type inference

int i = 100;
long l = i;            // widening, implicit
double d = i;          // widening, implicit

double pi = 3.99;
int truncated = (int) pi;   // 3, decimals dropped (not rounded)

int big = 130;
byte b = (byte) big;        // -126, overflow wraps around

byte a = 10, b = 20;
// byte c = a + b;          // compile error: a + b is an int
byte c = (byte) (a + b);    // OK

char ch = 'a';
System.out.println(ch + 1);        // 98 (int)
System.out.println((char) (ch + 1)); // b
ch += 1;                            // OK: compound assignment casts implicitly

System.out.println(5 / 2);          // 2   (integer division truncates toward zero)
System.out.println(-5 / 2);         // -2
System.out.println(-5 % 2);         // -1  (result takes the sign of the dividend)
System.out.println(5 / 2.0);        // 2.5

System.out.println(Integer.MAX_VALUE + 1); // -2147483648, silent overflow

// Detect overflow instead of wrapping
Math.addExact(Integer.MAX_VALUE, 1);       // throws ArithmeticException

System.out.println(0.1 + 0.2);           // 0.30000000000000004
System.out.println(0.1 + 0.2 == 0.3);    // false

BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");
System.out.println(a.add(b));                    // 0.3
System.out.println(new BigDecimal(0.1));         // 0.1000000000000000055511151231257827...

Integer boxed = 42;        // autoboxing: Integer.valueOf(42)
int prim = boxed;          // unboxing: boxed.intValue()

List<Integer> nums = new ArrayList<>();
nums.add(5);               // autoboxed
int first = nums.get(0);   // unboxed

Integer a = 127, b = 127;
System.out.println(a == b);       // true  (same cached object)

Integer c = 128, d = 128;
System.out.println(c == d);       // false (two different objects)
System.out.println(c.equals(d));  // true

Map<String, Integer> stock = new HashMap<>();
int count = stock.get("apple");   // NullPointerException: get returns null, unboxing null fails

int safe = stock.getOrDefault("apple", 0); // fix

static void reassign(StringBuilder sb) {
    sb = new StringBuilder("new");   // changes only the local copy of the reference
}

static void mutate(StringBuilder sb) {
    sb.append(" world");             // follows the copied reference to the SAME object
}

StringBuilder sb = new StringBuilder("hello");
reassign(sb);
System.out.println(sb);   // hello
mutate(sb);
System.out.println(sb);   // hello world

String s = "hello";
s.toUpperCase();              // result discarded, s is still "hello"
s = s.toUpperCase();          // now s refers to a new "HELLO"

String a = "java";
String b = "java";
String c = new String("java");
String d = c.intern();

System.out.println(a == b);        // true  (same pooled object)
System.out.println(a == c);        // false (new String always creates a new heap object)
System.out.println(a.equals(c));   // true  (same characters)
System.out.println(a == d);        // true  (intern returns the pooled instance)

// Bad
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i;
}

// Good
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
String result2 = sb.toString();

String s = "  Hello, World  ";

s.trim();                       // "Hello, World"  (strip() is Unicode-aware, Java 11+)
s.length();                     // 16
s.charAt(2);                    // 'H'
s.substring(2, 7);              // "Hello"  (end index is exclusive)
s.indexOf("World");             // 9
s.contains("Hello");            // true
s.replace("l", "L");            // "  HeLLo, WorLd  "
s.toLowerCase();
s.isBlank();                    // Java 11+: true for empty or whitespace-only
"a,b,c".split(",");             // ["a", "b", "c"]
String.join("-", "a", "b");     // "a-b"
"ab".repeat(3);                 // "ababab" (Java 11+)
String.valueOf(42);             // "42"
"Java".equalsIgnoreCase("JAVA"); // true

String msg = String.format("%s scored %d (%.1f%%)", "Sam", 42, 87.456);
// Sam scored 42 (87.5%)

// Java 15+: text block preserves line breaks, no escaping needed for quotes
String json = """
    {
      "name": "Sam",
      "age": 30
    }
    """;

for (int i = 0; i < 5; i++) { /* ... */ }

for (String name : names) { /* enhanced for over arrays and Iterables */ }

while (condition) { /* ... */ }
do { /* runs at least once */ } while (condition);

outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (j == 2) continue outer;   // labeled continue
        if (i == 2) break outer;      // labeled break
    }
}

switch (day) {
    case 1:
        System.out.println("Mon");
        // no break: falls through into case 2
    case 2:
        System.out.println("Tue");
        break;
    default:
        System.out.println("Other");
}

String type = switch (day) {
    case 6, 7 -> "Weekend";
    case 1, 2, 3, 4, 5 -> "Weekday";
    default -> throw new IllegalArgumentException("Invalid day: " + day);
};

int len = switch (word) {
    case "one" -> 1;
    case "two" -> 2;
    default -> {
        System.out.println("unknown");
        yield 0;               // yield returns a value from a block
    }
};

// Java 16+: pattern matching for instanceof
if (obj instanceof String s && s.length() > 3) {
    System.out.println(s.toUpperCase());   // s is already cast and in scope
}

// Java 21: pattern matching for switch, with guards and null handling
static String describe(Object o) {
    return switch (o) {
        case null -> "null";
        case Integer i when i > 100 -> "big int " + i;
        case Integer i -> "int " + i;
        case String s -> "string of length " + s.length();
        default -> "something else";
    };
}

int[] a = new int[5];              // [0, 0, 0, 0, 0]
int[] b = {1, 2, 3};
int[][] grid = new int[3][4];      // 3 rows, 4 columns
int[][] jagged = new int[3][];     // rows can have different lengths
jagged[0] = new int[2];

System.out.println(b.length);      // length is a field, not a method
b[3] = 10;                         // ArrayIndexOutOfBoundsException

int[] nums = {5, 3, 9, 1};

Arrays.sort(nums);                          // [1, 3, 5, 9]  (dual-pivot quicksort for primitives)
Arrays.binarySearch(nums, 5);               // 2 (array must be sorted)
Arrays.toString(nums);                      // "[1, 3, 5, 9]"
Arrays.deepToString(new int[][]{{1}, {2}}); // "[[1], [2]]"
Arrays.fill(nums, 0);
int[] copy = Arrays.copyOf(nums, 6);        // pads with defaults if longer
int[] part = Arrays.copyOfRange(nums, 1, 3);
Arrays.equals(new int[]{1}, new int[]{1});  // true (== would be false)

List<String> fixed = Arrays.asList("a", "b"); // fixed-size list backed by the array
fixed.set(0, "x");                             // OK
// fixed.add("c");                             // UnsupportedOperationException

Object[] objs = new String[2];
objs[0] = 42;   // compiles, but throws ArrayStoreException at runtime

public class Person {
    private final String name;
    private int age;

    public Person(String name) {
        this(name, 0);                  // constructor chaining with this(...)
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Parent {
    static { System.out.println("1. Parent static block"); }
    { System.out.println("3. Parent instance block"); }
    Parent() { System.out.println("4. Parent constructor"); }
}

class Child extends Parent {
    static { System.out.println("2. Child static block"); }
    { System.out.println("5. Child instance block"); }
    Child() { System.out.println("6. Child constructor"); }
}

new Child();

class Base {
    Base() { init(); }              // calls overridden method
    void init() {}
}

class Derived extends Base {
    private String value = "set";
    @Override void init() {
        System.out.println(value);  // prints null: Derived's field initializers have not run yet
    }
}

class Counter {
    private static int total = 0;      // one copy shared by all instances
    private int id;

    Counter() { id = ++total; }

    static int getTotal() { return total; }   // cannot touch instance fields or use this
}

final List<String> names = new ArrayList<>();
names.add("Sam");              // OK: the list is mutable
// names = new ArrayList<>();  // compile error: cannot reassign

public class Point {
    private final int x, y;

    public Point(int x, int y) { this.x = x; this.y = y; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Point p)) return false;   // pattern matching, Java 16+
        return x == p.x && y == p.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }

    @Override
    public String toString() {
        return "Point(" + x + ", " + y + ")";
    }
}

Set<Point> set = new HashSet<>();
set.add(new Point(1, 2));
System.out.println(set.contains(new Point(1, 2)));
// false if hashCode is not overridden: the two objects land in different buckets

class Animal {
    String sound() { return "..."; }
}

class Dog extends Animal {
    @Override
    String sound() { return "Woof"; }
}

Animal a = new Dog();          // upcasting, always safe and implicit
System.out.println(a.sound()); // Woof: method chosen at runtime from the actual object
Dog d = (Dog) a;               // downcasting needs an explicit cast, can throw ClassCastException

class Printer {
    void print(Object o) { System.out.println("Object"); }
    void print(String s) { System.out.println("String"); }
}

Object x = "hello";
new Printer().print(x);        // Object: overload chosen by the declared type of x
new Printer().print("hello");  // String

class A { String name = "A"; String get() { return "A.get"; } }
class B extends A { String name = "B"; String get() { return "B.get"; } }

A obj = new B();
System.out.println(obj.name);   // A       (field hiding, resolved at compile time)
System.out.println(obj.get());  // B.get   (overriding, resolved at runtime)

class Manager extends Employee {
    Manager(String name) {
        super(name);                    // call parent constructor
    }

    @Override
    double pay() {
        return super.pay() + 1000;      // reuse parent behavior
    }
}

abstract class Shape {
    private final String color;

    Shape(String color) { this.color = color; }   // abstract classes can have constructors and state

    abstract double area();                         // no body, subclasses must implement

    String describe() { return color + " shape of area " + area(); }
}

interface Drawable {
    void draw();                                    // implicitly public abstract

    default void drawTwice() { draw(); draw(); }    // Java 8+: default method with a body

    static Drawable noop() { return () -> {}; }     // Java 8+: static method

    private void helper() {}                        // Java 9+: private helper for defaults
}

class Circle extends Shape implements Drawable, Comparable<Circle> { /* ... */ }

interface A { default String hello() { return "A"; } }
interface B { default String hello() { return "B"; } }

class C implements A, B {
    @Override
    public String hello() {
        return A.super.hello();     // explicitly pick one
    }
}

class Outer {
    private int value = 10;

    static class StaticNested {
        // cannot access Outer.this.value
    }

    class Inner {
        int read() { return value; }   // has an implicit reference to Outer.this
    }
}

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
Outer.StaticNested nested = new Outer.StaticNested();

// Anonymous class
Runnable r = new Runnable() {
    @Override public void run() { System.out.println("run"); }
};

// Lambda: same idea, far shorter
Runnable r2 = () -> System.out.println("run");

enum Status { PENDING, ACTIVE, CLOSED }

Status s = Status.ACTIVE;
s.name();                       // "ACTIVE"
s.ordinal();                    // 1
Status.valueOf("CLOSED");       // CLOSED (throws IllegalArgumentException if missing)
Status.values();                // [PENDING, ACTIVE, CLOSED]

enum Operation {
    ADD("+") {
        @Override int apply(int a, int b) { return a + b; }
    },
    MULTIPLY("*") {
        @Override int apply(int a, int b) { return a * b; }
    };

    private final String symbol;

    Operation(String symbol) { this.symbol = symbol; }   // constructors are implicitly private

    abstract int apply(int a, int b);
    String symbol() { return symbol; }
}

Operation.ADD.apply(2, 3);   // 5

public record User(String name, int age) {
    // compact constructor for validation
    public User {
        if (age < 0) throw new IllegalArgumentException("age must be >= 0");
    }

    // extra methods are allowed
    public boolean isAdult() { return age >= 18; }
}

User u = new User("Sam", 30);
u.name();            // accessor (no "get" prefix)
System.out.println(u);          // User[name=Sam, age=30]
u.equals(new User("Sam", 30));  // true

public sealed interface Shape permits Circle, Square {}
public record Circle(double r) implements Shape {}
public record Square(double side) implements Shape {}

static double area(Shape s) {
    return switch (s) {                       // no default needed: compiler knows all cases
        case Circle c -> Math.PI * c.r() * c.r();
        case Square q -> q.side() * q.side();
    };
}

public final class Order {
    private final String id;
    private final List<String> items;

    public Order(String id, List<String> items) {
        this.id = id;
        this.items = List.copyOf(items);          // defensive copy, immutable
    }

    public String getId() { return id; }
    public List<String> getItems() { return items; }   // already immutable, safe to return
}

try {
    int result = Integer.parseInt(input);
    process(result);
} catch (NumberFormatException e) {
    log.warn("Bad number: " + input, e);
} catch (IOException | SQLException e) {          // multi-catch (types must be unrelated)
    throw new ServiceException("Failed to process", e);   // wrap and keep the cause
} finally {
    cleanup();                                    // runs whether or not an exception occurred
}

static int test() {
    try {
        return 1;
    } finally {
        return 2;      // method returns 2. Never do this.
    }
}

try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"));
     PrintWriter writer = new PrintWriter("out.txt")) {
    String line;
    while ((line = reader.readLine()) != null) {
        writer.println(line.toUpperCase());
    }
}   // writer then reader are closed here

public class InsufficientFundsException extends Exception {     // checked
    private final double shortfall;

    public InsufficientFundsException(String message, double shortfall) {
        super(message);
        this.shortfall = shortfall;
    }

    public double getShortfall() { return shortfall; }
}

void withdraw(double amount) throws InsufficientFundsException {
    if (amount > balance) {
        throw new InsufficientFundsException("Not enough funds", amount - balance);
    }
    balance -= amount;
}