Java static keyword — static counter race condition

public class BankAccount {

    // Static variable — shared across ALL BankAccount instances
    // Lives in class memory, allocated once when the class is loaded
    private static int totalAccounts = 0;

    // Instance variable — each account has its OWN balance
    private double balance;
    private String accountHolder;

    public BankAccount(String accountHolder, double initialDeposit) {
        this.accountHolder = accountHolder;
        this.balance = initialDeposit;

        // Every time a new account is created, the SHARED counter goes up
        // All accounts see this increment immediately
        totalAccounts++;
    }

    // Static method to read the static variable — no object needed
    public static int getTotalAccounts() {
        return totalAccounts;
    }

    public String getAccountHolder() {
        return accountHolder;
    }

    public static void main(String[] args) {
        System.out.println("Accounts before: " + BankAccount.getTotalAccounts()); // 0

        BankAccount alice = new BankAccount("Alice", 5000.00);
        BankAccount bob   = new BankAccount("Bob",   3200.50);
        BankAccount carol = new BankAccount("Carol", 8100.75);

        // All three objects share the same totalAccounts counter
        System.out.println("Accounts after:  " + BankAccount.getTotalAccounts()); // 3

        // Accessing via instance reference — compiles but is misleading, avoid this
        System.out.println("Via instance ref: " + alice.getTotalAccounts()); // still 3
    }
}

public class TemperatureConverter {

    // Private constructor — this class is pure utility, no instances needed
    private TemperatureConverter() {
        throw new UnsupportedOperationException("Utility class — do not instantiate");
    }

    // Static method: only uses its parameters, no instance state involved
    // Call it as TemperatureConverter.celsiusToFahrenheit(100) — no object required
    public static double celsiusToFahrenheit(double celsius) {
        return (celsius * 9.0 / 5.0) + 32.0;
    }

    public static double fahrenheitToCelsius(double fahrenheit) {
        return (fahrenheit - 32.0) * 5.0 / 9.0;
    }

    // Static factory method pattern — validates before constructing
    // Returns a formatted string; could return a full object in a real scenario
    public static String formatReading(double celsius, String location) {\n        if (celsius < -273.15) {\n            // Absolute zero check — a constructor couldn't do this as cleanly\n            throw new IllegalArgumentException(\n                \"Temperature below absolute zero is physically impossible: \" + celsius\n            );\n        }\n        double fahrenheit = celsiusToFahrenheit(celsius);\n        return String.format(\"%s: %.1f°C / %.1f°F\", location, celsius, fahrenheit);\n    }\n\n    public static void main(String[] args) {\n        // No 'new TemperatureConverter()' needed — call directly on the class\n        double boilingCelsius    = 100.0;\n        double bodyTempFahrenheit = 98.6;\n\n        System.out.println(\"Boiling point in °F : \" + TemperatureConverter.celsiusToFahrenheit(boilingCelsius));\n        System.out.println(\"Body temp in °C     : \" + TemperatureConverter.fahrenheitToCelsius(bodyTempFahrenheit));\n        System.out.println(TemperatureConverter.formatReading(36.6, \"Patient Room 4\"));\n    }\n}",
        "output": "Boiling point in °F : 212.0\nBody temp in °C     : 37.0\nPatient Room 4: 36.6°C / 97.9°F"
      },
      "callout": {
        "type": "tip",
        "title": "Pro Tip:",
        "text": "If you override a static method in a subclass, it isn't true polymorphism — Java uses method hiding, not dynamic dispatch. The method that runs depends on the compile-time type of the reference, not the runtime type. This distinction trips up nearly every Java interview candidate."
      },
      "production_insight": "In a logging library, a team added a static debug() method and later tried to override it per appender — logging silently broke because the compile-time type determined the call.\nRule: never rely on subclass behavior for static methods. Use instance methods if you need polymorphism.\nDiagnose method hiding by placing a breakpoint on the static method and checking the call stack — you'll see the compile-time type, not the runtime type.",
      "key_takeaway": "Static methods belong to the class, not objects.\nThey cannot access instance variables and are not polymorphic.\nUse static for utility methods and factories; use instance methods when behavior should vary by object type."
    },
    {
      "heading": "Static Blocks and Static Nested Classes — Advanced Initialisation and Encapsulation",
      "content": "A static initializer block runs exactly once when the class is first loaded into the JVM — before any objects are created and before any static method is called. It's the right place for initialization logic that's too complex for a simple field declaration: loading a config file, registering JDBC drivers, building an immutable lookup map, or computing a value that could throw a checked exception.\n\nYou can have multiple static blocks in a class; the JVM runs them top to bottom in source order. If initialization fails and throws an exception, the class enters a broken state and any subsequent attempt to use it throws an ExceptionInInitializerError — a nasty runtime failure that's hard to debug if you've never seen it before.\n\nA static nested class is a class declared inside another class with the static modifier. Unlike an inner (non-static) class, it has no implicit reference to an instance of the outer class. This makes it ideal for logical grouping without creating a hidden memory dependency. The Builder pattern famously uses this: OrderBuilder is logically part of Order, but it doesn't need a pre-existing Order instance to do its job. Static nested classes also appear in the Entry type of Map — Map.Entry is a static nested interface for exactly this reason.",
      "code": {
        "language": "java",
        "filename": "AppConfiguration.java",
        "code": "import java.util.Collections;\nimport java.util.HashMap;\nimport java.util.Map;\n\npublic class AppConfiguration {\n\n    // Static variable that needs complex initialisation\n    private static final Map<String, Integer> DEFAULT_TIMEOUTS;\n    private static final String ENVIRONMENT;\n\n    // Static block runs once when AppConfiguration class is loaded\n    // Perfect for setup that can't be done in a single-line field declaration\n    static {\n        System.out.println(\"[Static block] AppConfiguration class loading...\");\n\n        // Build an immutable lookup map — too complex for a field initialiser\n        Map<String, Integer> timeouts = new HashMap<>();\n        timeouts.put(\"database\",    5000);  // 5 seconds\n        timeouts.put(\"httpRequest\", 3000);  // 3 seconds\n        timeouts.put(\"cacheRead\",    500);  // 0.5 seconds\n\n        // Wrap in unmodifiable so no caller can accidentally mutate shared config\n        DEFAULT_TIMEOUTS = Collections.unmodifiableMap(timeouts);\n\n        // In real code this might read a system property or environment variable\n        String env = System.getProperty(\"app.env\");\n        ENVIRONMENT = (env != null && !env.isBlank()) ? env : \"development\";\n\n        System.out.println(\"[Static block] Config ready. Environment: \" + ENVIRONMENT);\n    }\n\n    // Static nested class — logically belongs here but needs no AppConfiguration instance\n    // This is the classic Builder pattern use case\n    public static class Builder {\n        private String serviceName;\n        private int customTimeout;\n\n        public Builder serviceName(String name) {\n            this.serviceName = name;\n            return this;\n        }\n\n        public Builder customTimeout(int milliseconds) {\n            this.customTimeout = milliseconds;\n            return this;\n        }\n\n        public AppConfiguration build() {\n            return new AppConfiguration(this);\n        }\n    }\n\n    // Private instance fields set by the builder\n    private final String serviceName;\n    private final int resolvedTimeout;\n\n    // Private constructor — only the inner Builder can call this\n    private AppConfiguration(Builder builder) {\n        this.serviceName = builder.serviceName;\n        // Use custom timeout if provided, otherwise fall back to the shared default\n        this.resolvedTimeout = builder.customTimeout > 0\n            ? builder.customTimeout\n            : DEFAULT_TIMEOUTS.getOrDefault(builder.serviceName, 2000);\n    }\n\n    public static int getDefaultTimeout(String service) {\n        return DEFAULT_TIMEOUTS.getOrDefault(service, 2000);\n    }\n\n    @Override\n    public String toString() {\n        return String.format(\"AppConfiguration{service='%s', timeout=%dms}\",\n            serviceName, resolvedTimeout);\n    }\n\n    public static void main(String[] args) {\n        // First reference to the class triggers the static block\n        System.out.println(\"DB default timeout: \" + AppConfiguration.getDefaultTimeout(\"database\") + \"ms\");\n\n        // Builder is a static nested class — no AppConfiguration instance needed to use it\n        AppConfiguration dbConfig = new AppConfiguration.Builder()\n            .serviceName(\"database\")\n            .build(); // uses default 5000ms from the map\n\n        AppConfiguration customConfig = new AppConfiguration.Builder()\n            .serviceName(\"paymentGateway\")\n            .customTimeout(8000)\n            .build(); // uses explicitly provided 8000ms\n\n        System.out.println(dbConfig);\n        System.out.println(customConfig);\n    }\n}",
        "output": "[Static block] AppConfiguration class loading...\n[Static block] Config ready. Environment: development\nDB default timeout: 5000ms\nAppConfiguration{service='database', timeout=5000ms}\nAppConfiguration{service='paymentGateway', timeout=8000ms}"
      },
      "callout": {
        "type": "info",
        "title": "Interview Gold:",
        "text": "Interviewers love asking: 'What's the difference between a static nested class and an inner class?' The answer: a static nested class has no hidden reference to the enclosing instance, so it can be instantiated independently and doesn't prevent garbage collection of the outer object. An inner class holds that reference, which can cause memory leaks if the inner class outlives the outer one."
      },
      "production_insight": "A config library used a static block to load a properties file. When the file was missing in one environment, the whole class failed to load and every endpoint returned a 500. The error was an ExceptionInInitializerError wrapped in a NoClassDefFoundError.\nRule: never throw unchecked exceptions in static blocks without a fallback. Log the failure and set a default instead.\nDiagnosis tip: look at the cause chain — the root exception is always nested inside ExceptionInInitializerError.",
      "key_takeaway": "Static blocks run once at class load — use them for complex initialization.\nA failure in a static block bricks the class for the JVM lifetime.\nStatic nested classes avoid memory leaks because they hold no outer instance reference."
    },
    {
      "heading": "Static Initialization Order and Class Loading Pitfalls",
      "content": "The order of static initialization matters. Static fields and static blocks are executed in the order they appear in the source file — top to bottom. This means if you declare a static field after a static block that tries to use it, that field will still have its default value (null, 0, false) at the time the block runs. This is a forward-reference trap.\n\nJava's compiler does warn about forward references in some cases, but not all. It's perfectly legal to write code that compiles but silently produces unexpected values due to ordering. The fix: always declare static fields before any static block that depends on them. If you cannot (e.g., fields are declared across multiple files via inheritance), move the initialization logic into a static method that is called after all fields are declared.\n\nAnother pitfall: static blocks in parent and child classes. When a subclass is loaded, the parent class's static blocks run first. Then the child's static blocks run. This order is safe, but if the parent's static block depends on something that the child's static block sets — that's impossible and will fail.\n\nThe most dangerous scenario: a static block throws a runtime exception. Java wraps it in ExceptionInInitializerError, and the class becomes permanently unusable. Any later attempt to use the class throws NoClassDefFoundError with the original cause buried in the error chain. This is especially nasty when it happens in a class that is used by many parts of the application — entire features become unreachable with a vague 'NoClassDefFoundError' log entry.",
      "code": {
        "language": "java",
        "filename": "ForwardReferenceTrap.java",
        "code": "public class ForwardReferenceTrap {\n\n    // Static block before a static field — TRAP!\n    static {\n        System.out.println(\"Static block runs first. x = \" + x);  // prints 0\n    }\n\n    private static int x = 42;\n\n    public static void main(String[] args) {\n        System.out.println(\"Main: x = \" + x);  // prints 42\n    }\n}",
        "output": "Static block runs first. x = 0\nMain: x = 42"
      }

import java.util.concurrent.atomic.AtomicInteger;

public class ThreadSafeCounter {

    // Wrong: plain static int — not thread-safe
    // private static int counter = 0;

    // Correct: AtomicInteger provides atomic increment and visibility
    private static final AtomicInteger counter = new AtomicInteger(0);

    public static int increment() {
        return counter.incrementAndGet();
    }

    public static void main(String[] args) throws InterruptedException {
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                ThreadSafeCounter.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Final count (expected 2000): " + counter.get());
    }
}