NullPointerException Java: Penyebab dan Cara Mengatasinya

Error Java yang Paling Umum

NullPointerException (semua orang menyebutnya NPE) terjadi saat kamu mencoba memakai referensi yang tidak menunjuk ke apa pun, yaitu null, seolah-olah menunjuk ke objek sungguhan. Variabel Java bertipe objek berisi sebuah objek atau berisi null, nilai yang berarti "tidak ada objek di sini". Begitu kamu meminta null melakukan sesuatu, misalnya memanggil method-nya, membaca salah satu field-nya, atau mengakses indeksnya, tidak ada apa pun yang bisa dikenai operasi itu, jadi JVM melempar exception.

Berbeda dengan try-catch, yang kamu pakai di halaman sebelumnya untuk menangani kegagalan yang diharapkan, NPE hampir selalu adalah bug biasa. Tujuan halaman ini bukan untuk menangkapnya, melainkan memahami kenapa NPE terjadi dan menulis kode yang tidak menghasilkannya.

public class Main {
    public static void main(String[] args) {
        String name = null;
        System.out.println(name.length());  // boom: name is null
    }
}

Tidak ada String tempat length() bisa dijalankan, jadi program berhenti dengan NullPointerException.

Membaca Pesannya

Sejak Java 14, pesannya memberi tahu dengan tepat apa yang null. Fitur ini disebut Helpful NullPointerException. Baca pesannya sebelum mengubah apa pun:

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.length()" because "name" is null
	at Main.main(Main.java:4)

Ada dua bagian yang penting. Cannot invoke "String.length()" adalah operasi yang gagal, dan because "name" is null menyebut pelakunya. Baris at Main.main(Main.java:4) adalah stack trace yang menunjuk ke baris yang tepat. Jadi perbaikannya bukan "bungkus baris 4 dengan try", melainkan "cari tahu kenapa name bernilai null di baris 4". Hampir selalu bug-nya ada di bagian sebelumnya, di tempat nilai itu seharusnya diisi tetapi tidak diisi.

Cara-Cara Memicunya

NPE berasal dari segelintir operasi, semuanya variasi dari "menyentuh null":

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

public class Main {
    public static void main(String[] args) {
        // 1. Calling a method on null
        String s = null;
        // System.out.println(s.toUpperCase());  // NPE

        // 2. A map lookup that missed returns null
        Map<String, Integer> ages = new HashMap<>();
        Integer age = ages.get("Ada");   // no such key -> null
        System.out.println("Lookup returned: " + age);

        // 3. Unboxing a null wrapper into a primitive
        // int n = age;   // NPE: can't unbox null Integer to int

        System.out.println("Reached the end safely");
    }
}

Pencarian di map adalah sumber klasik: get mengembalikan null kalau key-nya tidak ada, dan NPE sering baru muncul beberapa baris kemudian saat kamu akhirnya memakai nilai itu. Unboxing adalah yang paling licik: menyimpan Integer yang null ke int akan melempar exception, karena tidak ada angka yang bisa disalin.

Melindungi dengan Pengecekan Null

Pertahanan paling sederhana adalah if yang memastikan sebuah referensi tidak null sebelum kamu memakainya:

public class Main {
    public static void main(String[] args) {
        String name = lookupName(7);

        if (name != null) {
            System.out.println(name.toUpperCase());
        } else {
            System.out.println("No name found");
        }
    }

    static String lookupName(int id) {
        return null;  // pretend the lookup found nothing
    }
}

Saat membandingkan variabel dengan String konstan, taruh konstantanya di depan: "yes".equals(answer), bukan answer.equals("yes"). Kalau answer bernilai null, bentuk pertama dengan tenang mengembalikan false, sedangkan bentuk kedua melempar exception.

public class Main {
    public static void main(String[] args) {
        String answer = null;

        // Safe even when answer is null:
        System.out.println("yes".equals(answer));   // false, no NPE

        // answer.equals("yes") here would throw a NullPointerException
    }
}

Gagal Lebih Awal dengan Objects.requireNonNull

Menyebar pengecekan null di mana-mana membuat kode berantakan. Kalau sebuah nilai tidak boleh null, misalnya argumen constructor, validasi di batasnya dengan Objects.requireNonNull. Method ini langsung melempar exception dengan pesan yang jelas, tepat di titik nilai yang salah itu masuk, bukan jauh di dalam kodemu nanti:

import java.util.Objects;

public class Main {
    public static void main(String[] args) {
        try {
            new Account(null);
        } catch (NullPointerException e) {
            System.out.println("Rejected: " + e.getMessage());
        }
    }

    static class Account {
        final String owner;

        Account(String owner) {
            this.owner = Objects.requireNonNull(owner, "owner must not be null");
        }
    }
}

Kebiasaan "gagal lebih awal" ini mengubah NPE yang samar 200 baris jauhnya menjadi keluhan yang tepat di sumbernya. Exception ditangkap di sini hanya untuk menampilkan pesannya. Di kode sungguhan, kamu akan membiarkannya muncul supaya bug-nya diperbaiki.

Menghindari Null Sejak Awal

NPE terbaik adalah yang tidak mungkin terjadi karena tidak ada null yang bisa tersentuh. Beberapa kebiasaan ini sangat membantu:

• Kembalikan collection atau string kosong, jangan pernah null. Collections.emptyList() dan "" aman untuk di-loop dan dipanggil method-nya.
• Pakai getOrDefault pada map supaya pencarian yang gagal menghasilkan nilai sungguhan, bukan null.
• Inisialisasi field saat mendeklarasikannya, daripada membiarkannya null sampai "nanti".

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);

        // No null, no risk of unboxing trouble:
        int boris = ages.getOrDefault("Boris", 0);
        System.out.println("Boris: " + boris);
    }
}

Kalau sebuah nilai memang opsional, misalnya pencarian yang wajar saja kalau tidak menemukan apa-apa, Java menyediakan Optional, sebuah wadah yang memaksa pemanggil menangani kasus "tidak ada" daripada diam-diam menerima null. Itulah konsep terkait yang sebaiknya kamu baca berikutnya kalau ingin menghilangkan celah seperti ini dari API-mu sepenuhnya.

Rangkuman

NullPointerException adalah cara Java memberi tahu bahwa kamu memakai referensi berisi null seolah-olah berisi objek. Perbaikannya jarang berupa menangkap exception itu, melainkan membaca pesannya yang membantu, menelusuri kembali ke tempat nilai itu seharusnya diisi, lalu memastikan nilainya tidak null atau melindungi tempat kamu memakainya. Andalkan Objects.requireNonNull untuk gagal lebih awal di batas kode, utamakan nilai kosong dan getOrDefault daripada null, dan pakai Optional saat ketiadaan nilai adalah hasil yang nyata dan memang diharapkan. Kuasai pola pikir ini, dan error yang paling umum di Java akan menjadi salah satu yang paling jarang di kodemu sendiri.