Java’da NullPointerException’ı Önleme

NullPointerException’ı önlemek için x != null kullanmak ilk akla gelen yöntem.

NullPointerException’ı önlemek için x != null kullanmak ilk akla gelen yöntem. Peki başka bir alternatif var mı?

if (x != null) {
    // ...
}

Bu yeni başlayan ve orta seviyedeki geliştiricilerin bir noktada karşılaştığı oldukça yaygın bir sorun gibi. Geliştiriciler bu noktada ya kullandıkları kodu bilmiyorlar ya da güvenmiyorlar. Böylece null için defansif olarak aşırı kontrol yapıyorlar. Ek olarak, kendi kodlarını yazarken, bir şeyi belirtmek için null döndürmeye güvenme eğilimindeler, böylece çağrı yapanın null kontrol etmesini gerektiriyorlar.

Bunu başka bir şekilde ifade etmek gerekirse, null kontrolünün gündeme geldiği iki örnek bulunur:

  1. null’ın geçerli bir cevap olduğu durumlarda; ve
  2. Geçerli bir yanıt olmadığı yerde.

(2) kolay. Java 1.7’den itibaren Objects.requireNonNull(foo) kullanabilirsiniz. (Eğer önceki bir sürümde takılı kaldıysanız, assertions iyi bir alternatif olabilir).

Bu yöntemin “doğru” kullanımı aşağıdaki gibi olacaktır. Yöntem, içine aktarılan nesneyi döndürür ve nesne null ise bir NullPointerException fırlatır. Bu, döndürülen değerin her zaman null olmadığı anlamına gelir. Yöntem öncelikle parametreleri doğrulamak için tasarlanmıştır.

public Foo(Bar bar) {
    this.bar = Objects.requireNonNull(bar);
}

Nesne null ise bir istisna fırlattığı için bir assertion gibi de kullanılabilir. Her iki kullanımda da, istisnada gösterilecek bir mesaj eklenebilir. Aşağıda bir assertion gibi kullanılıyor ve bir mesaj veriliyor.

Objects.requireNonNull(someobject, "if someobject is null then something is wrong");
someobject.doCalc();

Genellikle, bir değer null olduğunda ancak olmaması gerektiğinde NullPointerException gibi belirli bir istisna atmak, AssertionError gibi daha genel bir istisna atmaya tercih edilir. Java kütüphanesinin benimsediği yaklaşım budur; bir argümanın null olmasına izin verilmediğinde NullPointerException’ı IllegalArgumentException’a tercih eder.

null geçerli bir cevapsa NullPointerException’dan kaçınma

(1) biraz daha zordur. Çağırdığınız kod üzerinde hiçbir kontrolünüz yoksa, takılıp kalırsınız. Eğer null geçerli bir yanıtsa, bunu kontrol etmeniz gerekir.

Ancak kontrol ettiğiniz bir kodsa (ve bu genellikle böyledir), o zaman durum farklıdır. Yanıt olarak null kullanmaktan kaçının. Koleksiyon döndüren yöntemlerde bu kolaydır: hemen hemen her zaman null yerine boş koleksiyonlar (veya diziler) döndürür.

Koleksiyon olmayanlarda bu daha zor olabilir. Bunu bir örnek olarak düşünün: eğer aşağıdaki interface’lere sahipseniz:

public interface Action {
  void doSomething();
}

public interface Parser {
  Action findAction(String userInput);
}

Parser’ın ham kullanıcı girdisini aldığı ve yapacak bir şey bulduğu yer, belki de bir şey için bir komut satırı arayüzü uyguluyorsanız. Şimdi, uygun bir eylem yoksa null döndürmesi için bir şeyler yapabilirsiniz. Bu da bahsettiğiniz null kontrolüne yol açar.

Alternatif bir çözüm, asla null döndürmemek ve bunun yerine Null Object desenini kullanmaktır:

public class MyParser implements Parser {
  private static Action DO_NOTHING = new Action() {
    public void doSomething() { /* hiç bir şey yapma */ }
  };

  public Action findAction(String userInput) {
    // ...
    if ( /* herhangi bir eylem bulamıyoruz */ ) {
      return DO_NOTHING;
    }
  }
}

Bir sonraki kodu :

Parser parser = ParserFactory.getParser();
if (parser == null) {
  // Şimdi ne olacak?
  // bu, null'un geçerli bir yanıt olmadığı (veya olmaması gerektiği) bir örnek olabilir
}
Action action = parser.findAction(someInput);
if (action == null) {
  // bir şey yapma
} else {
  action.doSomething();
}

aşağıdaki ile karşılaştıralım:

ParserFactory.getParser().findAction(someInput).doSomething();

Bu çok daha iyi bir tasarım, çünkü daha özlü bir kod elde edilmesini sağlıyor.

Bununla birlikte, findAction() yönteminin anlamlı bir hata mesajıyla birlikte bir Exception fırlatması belki de tamamen uygundur – özellikle de kullanıcı girdisine güvendiğiniz bu durumda. findAction yönteminin bir Exception fırlatması, çağıran yöntemin hiçbir açıklama yapmadan basit bir NullPointerException ile patlamasından çok daha iyi olacaktır.

try {
    ParserFactory.getParser().findAction(someInput).doSomething();
} catch(ActionNotFoundException anfe) {
    userConsole.err(anfe.getMessage());
}

Ya da try/catch mekanizmasının çok çirkin olduğunu düşünüyorsanız, varsayılan eyleminiz Hiçbir Şey Yapma yerine kullanıcıya geri bildirim sağlamalıdır.

public Action findAction(final String userInput) {
    /* Bulunduğunda istenen Eylemi döndüren kod */
    return new Action() {
        public void doSomething() {
            userConsole.err("Eylem bulunamadı: " + userInput);
        }
    }
}
Bu yazı topluluk tarafından oluşturuldu. Lisans bilgisine bakabilirsiniz. Yanlış veya eksik bilgileri düzenlemek için github üzerinden katkıda bulunabilirsiniz.

Kategoriler: Yazı, Java

Okumaya devam et!

Java’da NullPointerException’ı Önleme

NullPointerException’ı önlemek için x != null kullanmak ilk akla gelen yöntem.

NullPointerException Nedir?

Bu yazıda Null Pointer Exception (java.

Yorum Gönderin

E-posta hesabınız yayımlanmayacak.

koddla
Tema Mundana by WowThemes.net.