Apa arti keyword `static` dan `final`?

Question

IT Interview Practice · Accepted Answer

**`static`** berarti "belongs to the class itself, not to instances." **`final`** berarti "cannot be changed/extended." Keduanya adalah keyword independen yang sering membingungkan, namun mereka mengatasi concerns berbeda — dan bergabung untuk membuat 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 belongs to the class, bukan object individual — ada satu copy yang di-share oleh semua instances, diakses via class name. Static methods tidak bisa menggunakan `this` atau instance fields (tidak ada instance yang exist). ## 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` memiliki tiga kegunaan: sebuah `final` **variable** tidak bisa di-reassign (sebuah constant), sebuah `final` **method** tidak bisa di-override, dan sebuah `final` **class** tidak bisa di-extend. ## 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 ``` Untuk sebuah `final` reference, *reference* tidak bisa di-reassign, tetapi *object yang ditunjuknya* masih bisa di-mutate — sebuah point of confusion yang umum. ## 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` bersama-sama membuat true constants — satu shared, unchangeable value untuk seluruh class, cara standard untuk define constants di Java. ## Mengapa ini penting `static` dan `final` adalah fundamental Java keywords dengan meanings yang distinct dan important: `static` enables class-level state dan utility methods (shared counters, factory methods, `Math.PI`, method `main` itu sendiri), sementara `final` enforces immutability dan prevents inheritance/overriding (constants, immutable classes seperti String, sealing critical methods). Memahami mereka — termasuk subtle final-reference behavior (reference fixed, object mutable) dan kombinasi mereka menjadi constants — essential untuk design classes dengan benar, define constants dengan proper, control extensibility, dan reason tentang shared vs per-instance state. Mereka pervasive dalam Java code dan frequent interview topics.

static — class-level, shared across all instances

final — cannot be reassigned / overridden / extended

A subtle point: final references

Combined: static final = a constant

Mengapa ini penting

Pertanyaan terkait