What do the static and final keywords mean?

Question

Accepted Answer

**`static`** means "belongs to the class itself, not to instances." **`final`** means "cannot be changed/extended." They're independent keywords often confused, but they address different concerns — and combine to make constants. ## static — class-level, shared across all instances ```java public class Counter { static int count = 0; // ONE shared variable for the whole class int id; // each instance has its OWN id Counter() { count++; // increments the shared counter id = count; } static void reset() { // static method — called on the class count = 0; } } Counter.count; // access via the CLASS name, no instance needed Counter.reset(); // call a static method on the class new Counter(); // each new instance shares `count` ``` `static` members belong to the class, not individual objects — there's one copy shared by all instances, accessed via the class name. Static methods can't use `this` or instance fields (no instance exists). ## final — cannot be reassigned / overridden / extended ```java final int MAX = 100; // a constant — can't be reassigned MAX = 200; // ❌ compile error final class Util { } // a final CLASS can't be subclassed (e.g. String is final) class Base { final void critical() { } // a final METHOD can't be overridden } ``` `final` has three uses: a final **variable** can't be reassigned (a constant), a final **method** can't be overridden, and a final **class** can't be extended. ## A subtle point: final references ```java final List list = new ArrayList<>(); list.add("a"); // ✅ ALLOWED — modifying the OBJECT, not the reference list = new ArrayList<>(); // ❌ ERROR — can't REASSIGN the reference ``` For a `final` reference, the *reference* can't be reassigned, but the *object it points to* can still be mutated — a common point of confusion. ## Combined: static final = a constant ```java public static final double PI = 3.14159; // class-level, unchangeable constant public static final String APP_NAME = "MyApp"; // convention: UPPER_SNAKE_CASE for static final constants ``` `static final` together create true constants — one shared, unchangeable value for the whole class, the standard way to define constants in Java. ## Why it matters `static` and `final` are fundamental Java keywords with distinct, important meanings: `static` enables class-level state and utility methods (shared counters, factory methods, `Math.PI`, the `main` method itself), while `final` enforces immutability and prevents inheritance/overriding (constants, immutable classes like String, sealing critical methods). Understanding them — including the subtle final-reference behavior (reference fixed, object mutable) and their combination into constants — is essential for designing classes correctly, defining constants properly, controlling extensibility, and reasoning about shared vs per-instance state. They're pervasive in Java code and frequent interview topics.