Java NullPointerException: Nedenleri ve Nasıl Düzeltilir

Java'nın En Yaygın Hatası

Bir NullPointerException (herkes ona NPE der), hiçbir şeye -null'a- işaret eden bir referansı gerçek bir nesneye işaret ediyormuş gibi kullanmaya çalıştığınızda oluşur. Nesne türündeki Java değişkenleri ya bir nesne tutar ya da "burada nesne yok" değeri olan null'ı tutar. null'dan bir şey yapmasını istediğiniz anda -üzerinde bir metot çağırmak, alanlarından birini okumak, içine indekslemek- üzerinde işlem yapılacak hiçbir şey olmadığından JVM hata fırlatır.

Bir önceki sayfada beklenen hataları ele almak için başvurduğunuz try-catch'in aksine, bir NPE neredeyse her zaman sıradan bir programlama hatasıdır. Bu sayfanın amacı onları yakalamak değil, neden olduklarını anlamak ve onları üretmeyen kod yazmaktır.

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

length()'in üzerinde çalışabileceği bir String yok, bu yüzden program bir NullPointerException ile durur.

Mesajı Okumak

Java 14'ten beri mesaj size tam olarak neyin null olduğunu söyler - buna Helpful NullPointerException (Yardımcı NPE) denir. Herhangi bir şeyi değiştirmeden önce onu okuyun:

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

İki parça önemlidir. Cannot invoke "String.length()" başarısız olan işlemdir ve because "name" is null suçluyu adlandırır. at Main.main(Main.java:4) satırı tam satırı gösteren yığın izidir (stack trace). Dolayısıyla çözüm "4. satırı bir try içine sarmak" değil, "4. satırda name'in neden null olduğunu bulmaktır". Hata neredeyse her zaman daha öncede, değerin atanması gerektiği ama atanmadığı bir yerdedir.

Onu Tetiklemenin Yolları

NPE'ler, hepsi "null'a dokunmak"ın çeşitlemeleri olan bir avuç işlemden gelir:

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

public class Main {
    public static void main(String[] args) {
        // 1. null üzerinde bir metot çağırmak
        String s = null;
        // System.out.println(s.toUpperCase());  // NPE

        // 2. Bir şey bulamayan map araması null döndürür
        Map<String, Integer> ages = new HashMap<>();
        Integer age = ages.get("Ada");   // böyle bir anahtar yok -> null
        System.out.println("Lookup returned: " + age);

        // 3. null bir wrapper'ı bir primitif türe kutudan çıkarmak (unboxing)
        // int n = age;   // NPE: null bir Integer int'e unbox edilemez

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

Map aramaları klasik bir kaynaktır: anahtar yoksa get null döndürür ve NPE genellikle o değeri sonunda kullandığınızda, satırlarca sonra ortaya çıkar. Unboxing sinsi olanıdır - null bir Integer'ı bir int'e atamak hata fırlatır, çünkü kopyalanacak bir sayı yoktur.

Bir Null Kontrolü ile Korunmak

En basit savunma, bir referansı kullanmadan önce null olmadığını doğrulayan bir if'tir:

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;  // aramanın hiçbir şey bulmadığını varsayalım
    }
}

Bir değişkeni sabit bir String ile karşılaştırırken sabiti başa koyun - answer.equals("yes") yerine "yes".equals(answer). Eğer answer null ise, ilk biçim sakince false döndürür, ikincisi ise hata fırlatır.

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

        // answer null olsa bile güvenli:
        System.out.println("yes".equals(answer));   // false, NPE yok

        // answer.equals("yes") burada bir NullPointerException fırlatırdı
    }
}

Objects.requireNonNull ile Hızlı Başarısız Olun

null kontrollerini her yere saçmak gürültülü hale gelir. Bir değer asla null olmamalıysa -bir kurucu (constructor) argümanı gibi- onu sınırda Objects.requireNonNull ile doğrulayın. Bu, kötü değerin geldiği noktada, daha sonra kodunuzun derinliklerinde değil, anında ve net bir mesajla hata fırlatır:

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");
        }
    }
}

Bu "hızlı başarısız olma" alışkanlığı, 200 satır ötedeki belirsiz bir NPE'yi kaynağında kesin bir şikâyete dönüştürür. Burada istisnayı yakalamak yalnızca mesajı göstermek içindir - gerçek kodda, hatanın düzeltilmesi için onun ortaya çıkmasına izin verirdiniz.

Null'lardan Baştan Kaçınmak

En iyi NPE, ulaşılacak hiçbir null olmadığı için asla gerçekleşemeyendir. Birkaç alışkanlık çok işe yarar:

• null yerine boş bir koleksiyon ya da dize döndürün. Collections.emptyList() ve "" üzerinde döngü kurmak ve metot çağırmak güvenlidir.
• Başarısız bir aramanın null yerine gerçek bir değer üretmesi için map'lerde getOrDefault kullanın.
• Alanları "sonraya" kadar null bırakmak yerine, bildirirken ilk değerlerini atayın.

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);

        // null yok, unboxing sorunu riski yok:
        int boris = ages.getOrDefault("Boris", 0);
        System.out.println("Boris: " + boris);
    }
}

Bir değer gerçekten isteğe bağlı olduğunda -meşru biçimde hiçbir şey bulamayabilecek bir arama- Java, Optional sunar; bu, çağıranı sessizce bir null geri vermek yerine "yok" durumunu ele almaya zorlayan bir kapsayıcıdır. API'lerinizdeki bu boşlukları tamamen tasarımdan çıkarmak isterseniz, sırada okunacak ilgili kavram budur.

Toparlarsak

Bir NullPointerException, Java'nın size null tutan bir referansı bir nesne tutuyormuş gibi kullandığınızı söylemesidir. Çözüm nadiren onu yakalamaktır - çözüm, yardımcı mesajı okumak, değerin atanması gereken yere kadar geri izlemek ve ya null olmadığını garanti etmek ya da onu kullandığınız noktayı korumaktır. Sınırlarda hızlı başarısız olmak için Objects.requireNonNull'a yaslanın, null yerine boş değerleri ve getOrDefault'u tercih edin ve yokluk gerçek, beklenen bir sonuç olduğunda Optional'a başvurun. Bu zihniyeti kavradığınızda, Java'nın en yaygın hatası kendi kodunuzda en nadirlerinden biri haline gelir.