Java static Keyword Explained — Variables, Methods, Blocks and Classes

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) {
        if (celsius < -273.15) {
            // Absolute zero check — a constructor couldn't do this as cleanly
            throw new IllegalArgumentException(
                "Temperature below absolute zero is physically impossible: " + celsius
            );
        }
        double fahrenheit = celsiusToFahrenheit(celsius);
        return String.format("%s: %.1f°C / %.1f°F", location, celsius, fahrenheit);
    }

    public static void main(String[] args) {
        // No 'new TemperatureConverter()' needed — call directly on the class
        double boilingCelsius    = 100.0;
        double bodyTempFahrenheit = 98.6;

        System.out.println("Boiling point in °F : " + TemperatureConverter.celsiusToFahrenheit(boilingCelsius));
        System.out.println("Body temp in °C     : " + TemperatureConverter.fahrenheitToCelsius(bodyTempFahrenheit));
        System.out.println(TemperatureConverter.formatReading(36.6, "Patient Room 4"));
    }
}

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class AppConfiguration {

    // Static variable that needs complex initialisation
    private static final Map<String, Integer> DEFAULT_TIMEOUTS;
    private static final String ENVIRONMENT;

    // Static block runs once when AppConfiguration class is loaded
    // Perfect for setup that can't be done in a single-line field declaration
    static {
        System.out.println("[Static block] AppConfiguration class loading...");

        // Build an immutable lookup map — too complex for a field initialiser
        Map<String, Integer> timeouts = new HashMap<>();
        timeouts.put("database",    5000);  // 5 seconds
        timeouts.put("httpRequest", 3000);  // 3 seconds
        timeouts.put("cacheRead",    500);  // 0.5 seconds

        // Wrap in unmodifiable so no caller can accidentally mutate shared config
        DEFAULT_TIMEOUTS = Collections.unmodifiableMap(timeouts);

        // In real code this might read a system property or environment variable
        String env = System.getProperty("app.env");
        ENVIRONMENT = (env != null && !env.isBlank()) ? env : "development";

        System.out.println("[Static block] Config ready. Environment: " + ENVIRONMENT);
    }

    // Static nested class — logically belongs here but needs no AppConfiguration instance
    // This is the classic Builder pattern use case
    public static class Builder {
        private String serviceName;
        private int customTimeout;

        public Builder serviceName(String name) {
            this.serviceName = name;
            return this;
        }

        public Builder customTimeout(int milliseconds) {
            this.customTimeout = milliseconds;
            return this;
        }

        public AppConfiguration build() {
            return new AppConfiguration(this);
        }
    }

    // Private instance fields set by the builder
    private final String serviceName;
    private final int resolvedTimeout;

    // Private constructor — only the inner Builder can call this
    private AppConfiguration(Builder builder) {
        this.serviceName = builder.serviceName;
        // Use custom timeout if provided, otherwise fall back to the shared default
        this.resolvedTimeout = builder.customTimeout > 0
            ? builder.customTimeout
            : DEFAULT_TIMEOUTS.getOrDefault(builder.serviceName, 2000);
    }

    public static int getDefaultTimeout(String service) {
        return DEFAULT_TIMEOUTS.getOrDefault(service, 2000);
    }

    @Override
    public String toString() {
        return String.format("AppConfiguration{service='%s', timeout=%dms}",
            serviceName, resolvedTimeout);
    }

    public static void main(String[] args) {
        // First reference to the class triggers the static block
        System.out.println("DB default timeout: " + AppConfiguration.getDefaultTimeout("database") + "ms");

        // Builder is a static nested class — no AppConfiguration instance needed to use it
        AppConfiguration dbConfig = new AppConfiguration.Builder()
            .serviceName("database")
            .build(); // uses default 5000ms from the map

        AppConfiguration customConfig = new AppConfiguration.Builder()
            .serviceName("paymentGateway")
            .customTimeout(8000)
            .build(); // uses explicitly provided 8000ms

        System.out.println(dbConfig);
        System.out.println(customConfig);
    }
}