Wat betekenen de static en final keywords?

Question

Accepted Answer

**`static`** betekent "hoort bij de klasse zelf, niet bij instanties." **`final`** betekent "kan niet worden gewijzigd/uitgebreid." Het zijn onafhankelijke keywords die vaak worden verward, maar ze adresseren verschillende concerns — en combineren om constanten te vormen. ## static — op klasseniveau, gedeeld over alle instanties ```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 behoren tot de klasse, niet tot individuele objecten — er is één kopie die door alle instanties wordt gedeeld, toegankelijk via de klassenaam. Statische methoden kunnen `this` of instantievelden niet gebruiken (er bestaat geen instantie). ## final — kan niet opnieuw worden toegewezen / overschreven / uitgebreid ```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` heeft drie toepassingen: een final **variabele** kan niet opnieuw worden toegewezen (een constante), een final **methode** kan niet worden overschreven, en een final **klasse** kan niet worden uitgebreid. ## Een subtiel punt: final referenties ```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 ``` Bij een `final` referentie kan de *referentie* niet opnieuw worden toegewezen, maar het *object waar het naar wijst* kan nog steeds worden gemuteerd — een veel voorkomende bron van verwarring. ## Gecombineerd: static final = een constante ```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` vormen samen echte constanten — één gedeelde, onveranderbare waarde voor de hele klasse, de standaard manier om constanten in Java te definiëren. ## Waarom het belangrijk is `static` en `final` zijn fundamentele Java keywords met verschillende, belangrijke betekenissen: `static` maakt klasseniveau state en utility methods mogelijk (gedeelde tellers, factory methods, `Math.PI`, de `main` methode zelf), terwijl `final` immutability afdwingt en inheritence/overschrijving voorkomt (constanten, immutable klassen zoals String, het afsluiten van kritieke methoden). Het begrijpen ervan — inclusief het subtiele gedrag van final-referenties (referentie vast, object mutabel) en hun combinatie tot constanten — is essentieel voor het correct ontwerpen van klassen, het correct definiëren van constanten, het controleren van uitbreidbaarheid, en het redeneren over gedeelde versus per-instantie state. Ze zijn alomtegenwoordig in Java code en komen frequent voor in interviews.