Member Static Java: Field dan Method static

Milik Class, Bukan Milik Objek

Sebagian besar field dan method yang sudah kamu tulis sejauh ini adalah milik objek: setiap kali kamu memanggil new, setiap instance mendapat salinan field-nya sendiri, dan method berjalan terhadap state milik objek tertentu itu. Kata kunci static membalik hal itu. Member static adalah milik class itu sendiri: hanya ada satu salinan yang dipakai bersama oleh setiap instance, dan salinan itu ada baik kamu membuat objek maupun tidak.

Satu perbedaan itu menjelaskan field static, method static, konstanta, bahkan kenapa main selalu static.

Field static yang Dipakai Bersama

Field non-static memberi setiap objek tempatnya sendiri. Field static memberi class satu tempat yang dipakai bersama oleh semua. Contoh klasiknya adalah counter yang menghitung berapa banyak objek yang sudah dibuat:

class User {
    static int count = 0;     // one shared slot for the whole class
    String name;              // one per object

    User(String name) {
        this.name = name;
        count++;              // bump the shared counter on every construction
    }
}

public class Main {
    public static void main(String[] args) {
        new User("Ada");
        new User("Linus");
        new User("Grace");

        System.out.println("users created: " + User.count);
    }
}

Perhatikan bahwa kamu membaca counter itu sebagai User.count, lewat nama class, karena nilainya bukan milik satu User tertentu. Sebaliknya, setiap name hidup di dalam objeknya masing-masing. Ubah count lewat instance mana pun, dan setiap instance melihat nilai barunya, karena hanya ada satu.

Method static

Method static juga milik class, jadi kamu memanggilnya lewat class tanpa objek:

class MathUtils {
    static int square(int x) {
        return x * x;
    }

    static int max(int a, int b) {
        return a > b ? a : b;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(MathUtils.square(7));
        System.out.println(MathUtils.max(3, 9));
    }
}

Inilah pola di balik library standar: Math.max, Integer.parseInt, Arrays.sort, dan List.of semuanya static, yaitu perilaku utilitas yang tidak butuh objek untuk bekerja. Pakai method static kalau pekerjaannya hanya bergantung pada argumennya, bukan pada state per objek.

Jebakan Besar: static Tidak Bisa Melihat Instance

Method static berjalan tanpa objek, jadi tidak ada this. Artinya, method itu tidak bisa menyentuh field instance atau memanggil method instance secara langsung, karena tidak ada objek tertentu tempat membacanya. Inilah error pemula yang paling umum seputar static:

class Account {
    int balance = 100;          // instance field

    static int show() {
        return balance;         // COMPILE ERROR: non-static field 'balance'
    }                           // cannot be referenced from a static context
}

Solusinya adalah mengubah method itu menjadi method instance (hapus static, supaya method punya this), atau mengirim objeknya secara eksplisit:

class Account {
    int balance = 100;

    static int show(Account a) {     // take the object as a parameter
        return a.balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account();
        System.out.println(Account.show(a));
    }
}

Arah sebaliknya tidak masalah: method instance boleh bebas membaca field static dan memanggil method static, karena data tingkat class yang dipakai bersama itu selalu ada.

Konstanta dengan static final

Gabungkan static dengan final, dan kamu mendapatkan konstanta: satu nilai bersama yang tidak pernah bisa berubah. Menurut konvensi, namanya ditulis dalam UPPER_SNAKE_CASE:

class Circle {
    static final double PI = 3.14159265;

    double radius;

    Circle(double radius) { this.radius = radius; }

    double area() {
        return PI * radius * radius;   // instance method using a static constant
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.printf("%.2f%n", new Circle(2).area());
    }
}

static final adalah cara idiomatis untuk menyatakan "nilai tetap yang menjadi milik tipe ini", seperti Integer.MAX_VALUE atau Math.PI di library standar. Menjadikannya static berarti kamu tidak membuang satu salinan per objek; menjadikannya final berarti tidak ada yang bisa mengisinya ulang.

Blok Inisialisasi static

Field static yang sederhana bisa langsung diinisialisasi di barisnya. Kalau penyiapannya butuh logika sungguhan, misalnya membangun tabel pencarian dengan HashMap atau membaca konfigurasi, pakai blok static. Blok ini berjalan sekali, saat class pertama kali dimuat, sebelum ada objek apa pun:

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

class Roman {
    static final Map<Character, Integer> VALUES = new HashMap<>();

    static {                       // runs once, at class load time
        VALUES.put('I', 1);
        VALUES.put('V', 5);
        VALUES.put('X', 10);
        VALUES.put('L', 50);
    }

    static int valueOf(char c) {
        return VALUES.get(c);
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(Roman.valueOf('X') + Roman.valueOf('I'));
    }
}

Blok itu hanya berjalan satu kali berapa pun kamu memakai class-nya, sehingga menjadi tempat yang tepat untuk penyiapan satu kali yang berlaku untuk seluruh class.

Kapan Memakai static

Pedoman singkatnya:

• Pakai field static hanya untuk data yang benar-benar dipakai bersama oleh semua instance, seperti counter, cache, atau konstanta. Kalau dua objek wajar saja menyimpan nilai yang berbeda, data itu seharusnya field instance.
• Pakai method static kalau hasilnya hanya bergantung pada argumen, bukan pada state objek mana pun (fungsi utilitas murni).
• Jadikan member instance sebagai pilihan default. Terlalu banyak memakai static diam-diam mengubah programmu menjadi tumpukan state global, yang sulit diuji dan dipahami. static adalah pengecualian, bukan titik awal.

Berikutnya: Enum

Konstanta static final cocok untuk satu nilai tetap, tetapi kalau kamu punya kumpulan kecil nilai tetap yang saling berkaitan, seperti arah mata angin, hari dalam seminggu, atau status pesanan, Java punya tipe khusus yang lebih aman dan lebih ekspresif daripada konstanta yang tersebar. Itulah enum, dan itu topik halaman berikutnya.