63 Soru: Avoiding! = Null ifadeleri

tarafından oluşturulan soru Tue, Apr 17, 2018 12:00 AM

object != null'u çok önlemek için NullPointerException .

Buna iyi bir alternatif var mı?

Örneğin:

 
if (someobject != null) {
    someobject.doCalc();
}

Bu, nesnenin NullPointerException olup olmadığı bilinmiyorsa, null’dan kaçınır.

Kabul edilen yanıtın güncel olmadığını unutmayın, bkz. https://stackoverflow.com/a/2386013/12943 daha yeni bir yaklaşım için.

    
3817
  1. @ Shervin Null değerlerinin sıfırlanması, kodu daha az anlaşılır ve daha az güvenilir kılar.
    2010-08-02 09: 17: 20Z
  2. Elvis operatörleri önerildi ancak görünmeyecek gibi görünüyor Java 7 . Çok kötü, ?. ?: ve? [] inanılmaz zaman kazandıran kişilerdir.
    2011-02-25 02: 46: 10Z
  3. Null kullanmamak, buradaki diğer pek çok öneriden daha üstündür. İstisnaları atın, geri dönmeyin veya boş vermeyin. BTW - 'assert' anahtar sözcüğü işe yaramaz, çünkü varsayılan olarak devre dışıdır. Her zaman etkin bir hata mekanizması kullanın
    2012-06-08 19: 40: 14Z
  4. Bu, şimdi Scala kullanmamın nedenlerinden biri. Scala'da her şey null olamaz. Eğer "hiçbir şey" i geçmek ya da geri vermek için izin vermek istiyorsanız, açıkça sadece T ars argümanı ya da dönüş tipi yerine Option [T] 'yi kullanmalısınız.
    2014-02-02 20: 33: 25Z
  5. @ thSoft Nitekim, Scala'nın harika Option türü, dilin null'u denetleme veya reddetme konusundaki isteksizliği ile sınırlıdır. Bu hackernews bu konuda bahsetti ve reddedildi ve "hiç kimse Scala'da boş kullanmaz" demiştim. Bil bakalım ne oldu, ben zaten iş arkadaşı tarafından yazılmış Scala'da boş buluyorum. Evet, "yanlış yapıyorlar" ve bu konuda eğitilmeleri gerekir, ancak gerçek şu ki dilin tür sistemi beni bundan korumalı ve yapmaz :(
    2014-05-19 19: 52: 51Z
30 Yanıtlar                              30                         

Bu bana, orta ila orta düzeydeki geliştiricilerin bir noktada karşı karşıya gelme eğiliminde olduğu oldukça yaygın bir sorun gibi geliyor: Katılmakta oldukları sözleşmeleri bilmez ya da güvenmezler ve nullları savunurlar. Ek olarak, kendi kodlarını yazarken, arayanın boş değerleri kontrol etmesini gerektiren bir şeyi belirtmek için boş değerlere geri dönmeye güvenirler.

Bunu başka bir deyişle, null kontrolünün ortaya çıktığı iki örnek vardır:

  1. Null, sözleşme anlamında geçerli bir cevap ise; ve

  2. Geçerli bir yanıt olmadığı yerlerde

(2) kolaydır. assert ifade (iddia) kullanın ya da başarısızlığa izin verin (örneğin, NullPointerException ). İddialar, 1.4'te eklenmiş oldukça az kullanılan bir Java özelliğidir. Sözdizimi şudur:

 
assert <condition>

veya

 
assert <condition> : <object>

buradaki <condition>, bir boolean ifadesidir ve <object>, toString() yönteminin çıktısı hataya dahil edilecek bir nesnedir.

Koşul doğru değilse bir assert ifadesi Error (AssertionError) atar. Varsayılan olarak, Java iddiaları dikkate almaz. -ea seçeneğini JVM'ye geçirerek iddiaları etkinleştirebilirsiniz. Bireysel sınıflar ve paketler için iddiaları etkinleştirebilir ve devre dışı bırakabilirsiniz. Bu, geliştirmem ve test ederken kodu onaylamanız ve bunları üretim ortamında devre dışı bırakmanızın yanı sıra, testlerimin iddialardan herhangi bir performans etkisi göstermemesine rağmen, üretim ortamında devre dışı bırakabileceğiniz anlamına gelir.

Bu durumda iddiaları kullanmamak tamamdır, çünkü kod sadece başarısız olur, iddiaları kullanırsanız ne olur. Tek fark, iddialarla daha erken, daha anlamlı bir şekilde ve muhtemelen de beklemiyorsanız neden olduğunu anlamanıza yardımcı olabilecek ilave bilgilerle gerçekleşebileceğidir.

(1) biraz daha zor. Aradığınız kod üzerinde kontrol sahibi değilseniz, o zaman sıkışmışsınız demektir. Null geçerli bir cevap ise, onu kontrol etmeniz gerekir.

Ancak kontrol ettiğiniz kod ise (ve bu genellikle durum böyledir), o zaman farklı bir hikaye. Yanıt olarak boş değer kullanmaktan kaçının. Koleksiyon döndüren yöntemlerle kolaydır: her zaman boş satırlar yerine boş koleksiyonlar (veya diziler) döndürün.

Tahsilatsız ürünlerde daha zor olabilir. Bunu örnek olarak kabul edin: eğer bu arayüzlere sahipseniz:

 
public interface Action {
  void doSomething();
}

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

Parser, ham kullanıcı girdisini alır ve yapılacak bir şey bulur, belki de bir şey için komut satırı arabirimi uyguluyorsanız. Şimdi, uygun bir işlem yapılmadığı takdirde iade edeceğiniz sözleşmeyi iptal edebilirsiniz. Bu, bahsettiğiniz boş kontrolü yol açar.

Alternatif bir çözüm hiçbir zaman boş döndürmemek ve bunun yerine Boş Nesne kalıbı kullanın:

 
public class MyParser implements Parser {
  private static Action DO_NOTHING = new Action() {
    public void doSomething() { /* do nothing */ }
  };

  public Action findAction(String userInput) {
    // ...
    if ( /* we can't find any actions */ ) {
      return DO_NOTHING;
    }
  }
}

karşılaştırın:

 
Parser parser = ParserFactory.getParser();
if (parser == null) {
  // now what?
  // this would be an example of where null isn't (or shouldn't be) a valid response
}
Action action = parser.findAction(someInput);
if (action == null) {
  // do nothing
} else {
  action.doSomething();
}

için

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

çok daha iyi bir tasarımdır çünkü daha kısa kodlara yol açar.

Bununla birlikte, belki de kullanıcı girişine güvendiğiniz bu durumda, FindAction () yönteminin anlamlı bir hata mesajıyla bir İstisna atması tamamen uygun olabilir. FindAction yönteminin bir İstisna atması, çağıran yöntemin açıklama olmadan basit bir NullPointerException ile havaya uçurulmasından çok daha iyi olurdu.  

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

Ya da dene /yakala mekanizmasının çok çirkin olduğunu düşünüyorsanız, Yapacağınız Şey yerine varsayılan işleminizin kullanıcıya geri bildirim yapması gerekir.

 
public Action findAction(final String userInput) {
    /* Code to return requested Action if found */
    return new Action() {
        public void doSomething() {
            userConsole.err("Action not found: " + userInput);
        }
    }
}
    
2542
2015-06-26 22: 32: 33Z
  1. DO_NOTHING işlemiyle ilgili ifadelerinize katılmıyorum. İşlem bulma yöntemi bir işlem bulamazsa, boş değeri döndürmek yapılacak doğru şeydir. Kullanılabilir bir işlem bulmak için, kodunuzda gerçekten bulunamayan, yöntemin ilkesini ihlal eden bir eylem "buldunuz".
    2008-11-07 18: 36: 22Z
  2. Java'da null'ın özellikle listelerle birlikte kullanıldığını kabul ediyorum. Çok sayıda apis, null yerine boş bir liste /dizi /koleksiyon döndürürse daha iyi olur. Çoğu zaman, bunun yerine bir istisna atılması gereken yerlerde null kullanılır. Ayrıştırıcı çözümlenemiyorsa bir istisna atılmalıdır.
    2008-11-14 01: 53: 17Z
  3. Buradaki ikinci örnek, IIRC, Null Nesne tasarım desenidir.
    2009-07-23 04: 26: 51Z
  4. @ Cshah (ve MetroidFan2002). Basit, bunu sözleşmeye koyun ve sonra bulunmayan bir iadenin hiçbir şey yapmayacağı açıktır. Arayan için bu önemli bir bilgi ise, bunun bulunamayan bir eylem olduğunu keşfetmenin bir yolunu sağlayın (örneğin, sonucun DO_NOTHING nesnesinin olup olmadığını kontrol etmek için bir yöntem sağlayın). Alternatif olarak, eğer eylem normal olarak bulunursa, o zaman hala boş bırakmamalısınız, bunun yerine özel olarak bu durumu gösteren bir istisna atmalısınız - bu hala daha iyi kodla sonuçlanır. İsterseniz, eylem olup olmadığını kontrol etmek için boolean döndüren ayrı bir yöntem sağlayın.
    2010-03-05 12: 25: 42Z
  5. Özlü kalite koduna eşit değil. Üzgünüm öyle düşünüyorsun. Kodunuz, bir hatanın avantajlı olacağı durumları gizler.
    2011-05-04 04: 33: 32Z

JetBrains IntelliJ IDEA , gibi bir Java IDE kullanıyorsanız (veya kullanmayı planlıyorsanız), Eclipse veya Netbeans veya findbugs benzeri bir araç bu sorunu çözmek için ek açıklamaları kullanabilirsiniz.

Temelde, @Nullable ve @NotNull’unuz var.

Bunun gibi yöntem ve parametrelerde kullanabilirsiniz:

 
@NotNull public static String helloWorld() {
    return "Hello World";
}

veya

 
@Nullable public static String helloWorld() {
    return "Hello World";
}

İkinci örnek derlenmeyecek (IntelliJ IDEA'da).

İlk helloWorld() işlevini başka bir kod parçasında kullandığınızda:

 
public static void main(String[] args)
{
    String result = helloWorld();
    if(result != null) {
        System.out.println(result);
    }
}

Artık IntelliJ IDEA derleyicisi, helloWorld() işlevi hiç bir zaman null döndürmeyeceğinden çekin işe yaramaz olduğunu size söyleyecektir.

Parametre kullanma

 
void someMethod(@NotNull someParameter) { }

şunun gibi bir şey yazarsanız:

 
someMethod(null);

Bu derlenmeyecek.

@Nullable’un son örneği

 
@Nullable iWantToDestroyEverything() { return null; }

Bunu yapmak

 
iWantToDestroyEverything().something();

Bunun olmayacağından emin olabilirsin. :)

Derleyicinin genellikle olduğundan daha fazlasını kontrol etmesine izin vermek ve sözleşmelerinizi daha güçlü olmaya zorlamak için iyi bir yol. Maalesef, tüm derleyiciler tarafından desteklenmiyor.

IntelliJ IDEA 10.5 ve sonrasında, diğer @Nullable @NotNull uygulamaları için destek eklediler.

Blog gönderisine bakın Daha fazla esnek ve yapılandırılabilir @ Nullable /@ NotNull ek açıklamalar .

    
580
2019-01-03 21: 03: 55Z
  1. @NotNull, @Nullable ve diğer boş bilgi notları
    2011-06-30 23: 33: 55Z
  2. kod taşınabilirliği jetbrains ile boşalıyor. ide düzeyine bağlamadan önce iki kere (kare) düşünürdüm.Like Jacek S, düşündüğüm herhangi bir şekilde JSR'nin bir parçası olduklarını söyledi. bu arada JSR303 idi.
    2011-09-08 09: 39: 52Z
  3. Özel bir derleyici kullanmanın bu sorun için uygun bir çözüm olduğunu düşünmüyorum.
    2012-08-19 08: 24: 25Z
  4. @NotNull ve @Nullable ek açıklamalarının iyi yanı, kaynak kod onları anlamayan bir sistem tarafından oluşturulduğunda güzel bir şekilde bozulduklarıdır. Bu nedenle, aslında, kodun taşınabilir olmadığı argümanı geçersiz olabilir - bu ek açıklamaları destekleyen ve anlayan bir sistem kullanıyorsanız, daha katı hata kontrolünün ek avantajlarından yararlanırsınız, aksi halde daha az alırsınız ancak kodunuz yine de iyi derleyin ve çalışan programınızın kalitesi aynıdır, çünkü bu ek açıklamalar çalışma zamanında zaten uygulanmadı. Ayrıca, tüm derleyiciler özel ;-)
    2013-03-20 09: 49: 23Z

Eğer boş değerlere izin verilmiyorsa

Eğer yönteminiz harici olarak çağrılırsa, şunun gibi bir şeyle başlayın:

 
public void method(Object object) {
  if (object == null) {
    throw new IllegalArgumentException("...");
  }

Öyleyse, bu yöntemin geri kalanında, object'un boş olmadığını bileceksiniz.

Eğer dahili bir yöntemse (bir API'nin parçası değil), sadece null olamayacağını belgeleyin ve bu kadar.

Örnek:

 
public String getFirst3Chars(String text) {
  return text.subString(0, 3);
}

Ancak, yönteminiz değeri sadece geçerse ve sonraki yöntem geçerse vb. sorunlu olabilir. Bu durumda, argümanı yukarıdaki gibi kontrol etmek isteyebilirsiniz.

Eğer boş değere izin verilirse

Bu gerçekten bağlıdır. Sık sık böyle bir şey yaptığımı tespit ederseniz:

 
if (object == null) {
  // something
} else {
  // something else
}

Böylece dallarım ve iki tamamen farklı şeyler yapıyorum. Çirkin kod pasajı yok çünkü verilere bağlı olarak iki farklı şey yapmam gerekiyor. Örneğin, giriş üzerinde çalışmalı mıyım, yoksa iyi bir varsayılan değer mi hesaplamalıyım?


"if (object != null && ..." deyimini kullanmam çok nadiren görülüyor.

Normalde deyimi kullandığınız yerlere örnekler gösterirseniz, size örnekler vermek daha kolay olabilir.

    
303
2016-07-19 09: 02: 46Z
  1. IllegalArgumentException'ı atmanın anlamı nedir? NullPointerException'ın daha net olacağını ve boş denetleme yapmazsanız bunun da atılacağını düşünüyorum. Ben ya assert kullanırdım ya da hiçbir şey kullanmam.
    2011-08-09 16: 47: 13Z
  2. null dışında her değerin kabul edilebilir olması olası değildir. IllegalArgumentException, OutOfRageException vb. Olabilir. Bazen bu mantıklı. Diğer zamanlarda, herhangi bir değer katmayan birçok istisna sınıfı oluşturursunuz, ardından sadece IllegalArgumentException kullanın. Boş giriş için bir istisna olması ve diğer her şey için bir tane daha olması anlamlı değildir.
    2011-08-15 12: 26: 59Z
  3. Evet, başarısız-hızlı-prensibi kabul ediyorum, ancak yukarıda verilen örnekte, değer iletilmedi, ancak bir yöntemin üzerinde olacağı nesne aradı. Bu nedenle, aynı derecede hızlı bir şekilde başarısız oluyor ve aynı anda aynı anda atılacak olan bir istisnayı atmak için boş bir denetim eklemek ve hata ayıklamayı daha kolay hale getirecek gibi görünmüyor.
    2011-08-22 11: 20: 14Z
  4. Bir güvenlik açığı? JDK böyle bir kodla doludur. Kullanıcının yığınları görmesini istemiyorsanız, onları devre dışı bırakın. Hiç kimse davranışın belgelenmediğini ima etmedi. MySQL, boş işaretçilerin tanımlanmasının tanımsız davranış olduğu, istisna atma gibi bir şey olmadığı C dilinde yazılmıştır.
    2013-04-08 00: 39: 35Z
  5. throw new IllegalArgumentException("object==null")
    2013-04-20 23: 35: 01Z

Vay, NullObject pattern’u önermek için 57 farklı yöntemimiz varken neredeyse başka bir cevap eklemekten nefret ediyorum, ancak bu soruya ilgi duyan bazı kişilerin masaya Java 7’nin eklenmesi için bir teklif olduğunu bilmek isteyebileceğini düşünüyorum. "sıfır güvenli işleme" - eğer eşit değilse boş mantık için basitleştirilmiş bir sözdizimi.

Alex Miller tarafından verilen örnek şöyle görünür:

 
public String getPostcode(Person person) {  
  return person?.getAddress()?.getPostcode();  
}  

?., boş değilse yalnızca sol tanımlayıcının referansını kaldırmayı ifade eder, aksi takdirde ifadenin kalanını null olarak değerlendirir. Java Posse üyesi Dick Wall ve gibi bazı insanlar Devoxx’teki seçmenler bu teklifi çok seviyor, ancak aslında null’un bir sentinel değeri olarak daha fazla kullanılmasını teşvik edeceği gerekçesiyle de muhalefet var.


Güncelleme: Bir Java 7'deki boş olmayan bir operatör için resmi teklif , Proje Madeni Parası. ında a> Sözdizimi yukarıdaki örnekten biraz farklı, ancak aynı fikir.


Güncelleme: Boş güvenli operatör teklifi, Project Coin içine girmedi. Dolayısıyla, sözdizimini Java 7'de görmeyeceksiniz.

    
227
2015-09-20 23: 12: 27Z
  1. Bunun yanlış olduğunu düşünüyorum. Belirli bir değişkenin HER ZAMAN boş değil olduğunu belirtmenin bir yolu olmalı.
    2009-05-26 11: 54: 03Z
  2. Güncelle: teklif Java7 yapmaz. blogs.sun.com/darcy/entry/project_coin_final_five adresine bakın.
    2009-08-29 18: 56: 34Z
  3. İlginç bir fikir ancak sözdizimi seçimi saçma; Her ekleme sabitlenmiş soru işaretleriyle dolu bir kod temeli istemiyorum.
    2012-05-16 11: 51: 58Z
  4. 2013-02-15 22: 53: 23Z
  5. Bu gördüğüm en ustaca fikir. C sözdiziminin her mantıklı diline eklenmelidir. Her yerde "soru işaretlerini" işaretlemeyi tercih ederim, bütün gün ekran dolgusunda ilerlemekten ya da "bekçi cümleciklerinden" kaçmayı tercih ederim.
    2015-10-01 20: 57: 20Z

Eğer tanımsız değerlere izin verilmiyorsa:

IDE'nizi, potansiyel sıfırdan arındırma konusunda sizi uyaracak şekilde yapılandırabilirsiniz. Örneğin. Eclipse'de, Tercihler > Java > Derleyici > Hatalar /Uyarılar /Null analizi .

Eğer tanımsız değerlere izin verilirse:

Tanımsız değerlerin anlamlı olduğu yeni bir API tanımlamak istiyorsanız , Seçenek Şablonu (işlevsel dillerden aşina olabilir). Aşağıdaki avantajlara sahiptir:

  • API’de bir giriş veya çıkışın var olup olmadığı açıkça belirtilir.
  • Derleyici sizi "tanımsız" durumla ilgilenmeye zorlar.
  • Seçenek bir monaddır , öyleyse orada Ayrıntılı boş denetlemeye gerek yok, yalnızca (örnek) .

Java 8’de yerleşik bir Optional sınıf (önerilen); önceki sürümler için kütüphane alternatifleri var, örneğin Guava 's Optional veya FunctionalJava 'nın Option . Fakat birçok fonksiyonel stilde olduğu gibi, Java'da Option (8 bile olsa) kullanmak, daha az ayrıntılı bir JVM dili, örneğin; Scala veya Xtend.

Null değerine sahip olabilecek bir API ile uğraşmak zorunda kalırsanız , Java’da fazla bir şey yapamazsınız. Xtend ve Groovy, Elvis operatörü ?:’da ve boş güvenli dereference operatörü ?., ancak boş referans olması durumunda boş döndüğünü unutmayın, bu yüzden" "null değerinin uygun şekilde kullanılmasını savunur.

    
187
2017-10-24 10: 38: 40Z
  1. Gerçekten, Seçenek kalıbı harika. Bazı Java eşdeğerleri mevcuttur. Guava, işlevsel öğelerin çoğunu dışarıda bırakan isteğe bağlı olarak adlandırılan sınırlı bir sürümünü içerir. Haskell'de bu desene Belki adı verilir.
    2011-05-20 18: 31: 03Z
  2. İsteğe bağlı bir sınıf Java 8’de kullanıma sunulacak
    2013-04-25 14: 59: 13Z
  3. ... ve (henüz) haritaya ya da flatMap'e sahip değil: indir.java.net/jdk8/docs/api/java/util/Optional.html
    2013-04-25 15: 28: 05Z
  4. İsteğe bağlı model hiçbir şeyi çözmez; potansiyel olarak boş bir nesne yerine, şimdi iki tane var.
    2013-11-04 04: 15: 57Z
  5. @ Boann, eğer dikkatli kullanılırsanız, tüm NPE probleminizi çözersiniz. Olmazsa, o zaman bir "kullanım" sorunu olduğunu tahmin ediyorum.
    2016-02-12 13: 34: 06Z

Sadece bu durum için -

Bir eşittir yöntemini çağırmadan önce bir değişkenin boş olup olmadığını kontrol etmeyin (aşağıdaki bir dize karşılaştırma örneği):

 
if ( foo.equals("bar") ) {
 // ...
}

NullPointerException yoksa foo ile sonuçlanır.

String s'nizi bu şekilde karşılaştırırsanız bundan kaçınabilirsiniz:

 
if ( "bar".equals(foo) ) {
 // ...
}
    
174
2018-05-25 15: 33: 50Z
  1. Kabul ediyorum - yalnızca bu durumda. Bunu bir sonraki gereksiz düzeye götüren programcılara dayanamıyorum ve eğer (null! = MyVar) ... sadece bana çirkin görünüyor ve hiçbir amaca hizmet etmiyorsa yazamıyorum!
    2011-05-23 18: 14: 16Z
  2. Bu genel bir iyi uygulamanın muhtemelen en çok kullanılan özel bir örneğidir: eğer biliyorsanız, her zaman <object that you know that is not null>.equals(<object that might be null>); yapın. Sözleşmeyi biliyorsanız ve bu yöntemler equals parametrelerini işleyebilirse, null dışındaki diğer yöntemlerde işe yarar.
    2011-09-23 01: 20: 38Z
  3. Bu, Yoda Koşulları gerçekten mantıklı geliyor
    2013-09-30 19: 37: 04Z
  4. NullPointerExceptions bir nedenle atılıyor. Onlar fırlatıldı, çünkü bir nesne olması gereken yerde boş. Bu sorunu çözmek HIDE değil, FIX'i yapmak programcıların işidir.
    2014-05-12 07: 49: 02Z
  5. Try-Catch-DoNothing sorunu gizlemiyor, bu, dilde eksik şekeri bulmak için geçerli bir uygulamadır.
    2014-05-12 11: 13: 00Z

Java 8 ile tartışılan bazı problemleri çözen yeni java.util.Optional sınıfı geliyor. En azından, kodun okunabilirliğini geliştirdiğini söyleyebiliriz ve genel API'ler söz konusu olduğunda, API sözleşmesini müşteri geliştiricisine daha açık hale getirir.

Böyle çalışırlar:

Belirli bir tür için isteğe bağlı bir nesne (Fruit), bir yöntemin dönüş türü olarak oluşturulur. Boş olabilir veya Fruit nesnesini içerebilir:

 
public static Optional<Fruit> find(String name, List<Fruit> fruits) {
   for (Fruit fruit : fruits) {
      if (fruit.getName().equals(name)) {
         return Optional.of(fruit);
      }
   }
   return Optional.empty();
}

Şimdi, belirli bir Meyve örneği için Fruit (fruits) listesini aradığımız bu koda bakın:

 
Optional<Fruit> found = find("lemon", fruits);
if (found.isPresent()) {
   Fruit fruit = found.get();
   String name = fruit.getName();
}

map() işlecini, isteğe bağlı bir nesnede hesaplama yapmak veya değer almak için kullanabilirsiniz. orElse(), eksik değerler için bir geri dönüş sağlamanıza izin verir.

 
String nameOrNull = find("lemon", fruits)
    .map(f -> f.getName())
    .orElse("empty-name");

Elbette, boş /boş değer kontrolü hala gereklidir, ancak en azından geliştirici değerin boş olabileceğinin ve kontrol etmeyi unutmanın riskinin sınırlı olduğunun bilincindedir.

Bir dönüş değeri boşken Optional kullanılarak sıfırdan oluşturulan bir API'de ve yalnızca null (kural) olamayacak şekilde düz bir nesne döndürürken, istemci kodu basit nesne dönüş değerleri üzerindeki boş denetimleri bırakabilir ...

Elbette Optional, bazı durumlarda 5 veya 10 aşırı yükleme yönteminden daha çok isteğe bağlı argümanları belirtmek için daha iyi bir yöntem olarak, bir yöntem argümanı olarak da kullanılabilir.

Optional, varsayılan değerin kullanılmasına izin veren orElse ve ifPresent gibi başka kullanışlı yöntemler sunar. > lambda ifadeleri .

Sizi bu makaleyi okumaya davet ediyorum (bu cevabı yazmak için ana kaynağım)NullPointerException'un (ve genel olarak boş göstericinin) Optional'un getirdiği (kısmi) çözümün yanı sıra problemli olduğu açıktır: Java İsteğe Bağlı Nesneleri .

    
154
2016-09-29 07: 39: 04Z
  1. Google’ın guava’nın Java 6+ sürümünde isteğe bağlı bir isteği yoktur.
    2013-05-27 17: 30: 26Z
  2. İsteğe bağlı seçeneğinin yalnızca ifPresent () ile yapmadığını normal null değerinin üstüne koymadığını vurgulamak önemlidir. kontrol etme. Temel değer, başka yerlerde bahsedilen Groovy'deki Elvis operatörüne benzer sonuçlar veren map /flapMap fonksiyon zincirlerinde kullanılabilecek bir monad olmasıdır. Bu kullanım olmasa bile, orElse /orElseThrow sözdizimini de çok faydalı buluyorum.
    2014-10-09 14: 57: 09Z
  3. 2015-12-09 00: 05: 53Z
  4. İnsanların neden bu kazan koduyla bu kadar mutlu olduklarını gerçekten anlamadım dzone.com/articles/java-8-elvis-operator
    2018-02-23 22: 10: 20Z
  5. Neden insanlar bunu if(optional.isPresent()){ optional.get(); } yerine optional.ifPresent(o -> { ...})'da yapmaya eğilimli?
    2018-03-07 15: 06: 39Z

Hangi tür nesneleri kontrol ettiğinize bağlı olarak, apache commons'daki bazı sınıfları kullanabilirsiniz: apache commons lang ve apache commons koleksiyonları

Örnek:

 
String foo;
...
if( StringUtils.isBlank( foo ) ) {
   ///do something
}

veya (neyi kontrol etmeniz gerektiğine bağlı olarak):

 
String foo;
...
if( StringUtils.isEmpty( foo ) ) {
   ///do something
}

StringUtils sınıfı, çoğundan yalnızca biri; Commons'da güvenli bir şekilde manipülasyon yapmayan birkaç iyi sınıf var.

Apache kütüphanesini (commons-lang-2.4.jar) eklerken JAVA'da null geçerliliği nasıl kullanabileceğinizi gösteren bir örnek aşağıdadır.

 
public DOCUMENT read(String xml, ValidationEventHandler validationEventHandler) {
    Validate.notNull(validationEventHandler,"ValidationHandler not Injected");
    return read(new StringReader(xml), true, validationEventHandler);
}

Spring kullanıyorsanız, Spring de paketinde aynı işlevselliğe sahiptir, kütüphaneye bakın (spring-2.4.6.jar)

Bu statik classf'ın bahardan nasıl kullanılacağına ilişkin örnek (org.springframework.util.Assert)

 
Assert.notNull(validationEventHandler,"ValidationHandler not Injected");
    
121
2016-02-23 12: 14: 13Z
  1. Ayrıca, Apache Commons'dan daha genel bir sürümü kullanabilirsiniz, bulamadıklarım paragrafları kontrol etmek için yöntemlerin başında oldukça kullanışlıdır. Validate.notNull (nesne, "nesne boş olmamalıdır"); commons.apache.org/lang/apidocs/org/apache /commons /lang /...
    2010-01-14 13: 57: 36Z
  2. @ monojohnny Validate, Assert deyimlerini? Assert’in JVM’de etkinleştirilmesi /devre dışı bırakılması ve üretimde kullanılmaması önerilmektedir.
    2017-12-09 16: 03: 31Z
  3. Sanmıyorum - Doğrulama başarısız olursa, sadece bir RuntimeException atar sanırım
    2018-01-06 14: 45: 25Z
  • Bir nesnenin boş olmaması gerektiğini düşünüyorsanız (veya bir hata ise) bir assert kullanın.
  • Metodunuz boş params kabul etmiyorsa, javadoc içinde söyleyin ve bir assert kullanın.

Nesne olup olmadığını kontrol etmelisiniz! = null, yalnızca nesnenin boş olabileceği vakayı ele almak istiyorsanız ...

Boş /notnull params için yardımcı olması için Java7'de yeni ek açıklamalar ekleme önerisi var: http://tech.puredanger.com/java7/#jsr308

    
93
2009-08-14 14: 44: 48Z
  1. Hayır, üretim kodundaki iddiaları kullanmayın .
    2017-02-26 00: 54: 41Z

    "Hızlı başarısız" kodunun hayranıyım. Kendinize sorun - parametrenin boş olması durumunda faydalı bir şey mi yapıyorsunuz? Eğer bu durumda kodunuzun ne yapması gerektiği konusunda net bir cevabınız yoksa ... ilk etapta hiçbir zaman boş olmamalı, sonra görmezden gelmeli ve NullPointerException'ın atılmasına izin vermelidir. Çağıran kod, bir NPE'yi bir IllegalArgumentException'da olduğu gibi algılayacaktır, ancak geliştiricinin bir NPE atılırsa, kodunuz beklenmedik bir durumla karşılaşmayı denemek yerine neyin yanlış gittiğini anlamak ve hata ayıklamak daha kolay olacaktır. mantık - sonuçta uygulamanın yine de başarısız olmasına neden olur.

        
    88
    2012-04-23 19: 09: 09Z
    1. iddiaları kullanmak daha iyi, yani Contract.notNull (abc, "abc boş olmamalı, xyz sırasında yüklenemedi mi?"); - bu if (abc! = null) {if new RuntimeException ...}
      'dan daha kompakt bir yoldur.
      2012-10-18 03: 35: 31Z

    Google koleksiyonları çerçevesi, sıfır kontrolü sağlamak için iyi ve zarif bir yol sunar.

    Bir kütüphane sınıfında buna benzer bir yöntem vardır:

     
    static <T> T checkNotNull(T e) {
       if (e == null) {
          throw new NullPointerException();
       }
       return e;
    }
    

    Ve kullanımı (import static ile):

     
    ...
    void foo(int a, Person p) {
       if (checkNotNull(p).getAge() > a) {
          ...
       }
       else {
          ...
       }
    }
    ...
    

    Veya örneğinizde:

     
    checkNotNull(someobject).doCalc();
    
        
    74
    2015-09-19 16: 05: 47Z
    1. mmm, fark nedir? p.getAge () aynı NPE'yi daha az ek yük ve daha net bir yığın iziyle birlikte atar. Neyi özlüyorum?
      2009-05-18 23: 26: 20Z
    2. Örneğinize bir IllegalArgumentException ("e == null") atmak, programcıya yönelik bir istisna olduğunu açıkça gösterdiğinden (yeterli bilgi ile birlikte) daha iyidir Aslında bakımcının sorunu tanımlamasına izin vermek için). NullPointerExceptions, JVM için ayrılmalıdır, çünkü daha sonra bunun istenmediğini açıkça gösterir (ve genellikle tanımlanması zor bir yerde olur)
      2009-05-26 11: 56: 17Z
    3. Bu şimdi Google Guava'nın bir parçası.
      2011-02-13 20: 55: 52Z
    4. Bana aşırı mühendislik yapmak gibi kokuyor. Sadece JVM'nin bir NPE atmasına izin verin ve kodunuzu bu çöplükle karıştırmayın.
      2012-04-23 19: 11: 10Z
    5. Beğendim ve çoğu yöntemi ve kurucuyu argümanlar üzerinde açık denetimlerle açıyorum; bir hata varsa, ilk birkaç satırdaki yöntemler her zaman başarısız olur ve rahatsız edici referansı getThing().getItsThing().getOtherThing().wowEncapsulationIsBroken().setLol("hi"); gibi bir şey bulamadan biliyorum.
      2012-11-22 06: 26: 03Z

    Bazen, simetrik bir işlemi tanımlayan parametrelerinde çalışan yöntemlere sahipsiniz:

     
    a.f(b); <-> b.f(a);
    

    B'nin asla boş olamayacağını biliyorsanız, onu değiştirirsiniz. Eşittir için en kullanışlıdır: foo.equals("bar"); yerine "bar".equals(foo);'u daha iyi yapın.

        
    73
    2015-12-15 19: 02: 51Z
    1. Ama sonra equals'un (herhangi bir yöntem olabilir) null değerinin doğru işleyeceğini varsaymanız gerekir. Aslında bütün bunlar, sorumluluğu başkasına (ya da başka bir yönteme) aktarmaktır.
      2013-06-13 20: 01: 58Z
    2. @ Supericy Temel olarak evet, ancak equals (veya herhangi bir yöntem) yine de null'u kontrol etmek zorundadır. Veya açıkça öyle olmadığını belirtin.
      2013-07-30 07: 26: 30Z

    Null Object Pattern yerine - ki bunun kullanımları vardır - null nesnesinin bir hata olduğu durumları düşünebilirsiniz.

    İstisna atıldığında, yığın izini inceleyin ve böcek üzerinde çalışın.

        
    71
    2008-11-07 08: 50: 24Z
    1. Sorun, NullPointerException'ın WHICH değişkeninin null olduğunu göstermediği ve genellikle "." - satırdaki işlemlerin olabileceği anlamına gelmediğinden, bağlamı kaybedersiniz. "İf (foo == null) yeni RuntimeException (" foo == null ")" atmak "kullanıldığında, açıkça NE’nin yanlış olduğunu belirtmenize izin verir ve yığın izlemenizi düzeltmesi gerekenlere çok daha fazla değer verir.
      2009-10-31 09: 02: 17Z
    2. Andersen ile - Java'nın istisna sistemini, üzerinde çalışmakta olan bir değişkenin adını dahil edebilmeyi çok isterdim, böylece NullPointerExceptions yalnızca istisna satırını göstermeyecek oluştuğunda, değişken ismi de ortaya çıktı. Bu unffccated yazılımda sadece iyi çalışması gerekir.
      2011-01-18 12: 53: 01Z
    3. Henüz çalışmasını sağlayamadım, ancak this tam olarak bu sorunu çözmeyi amaçlamaktadır.
      2011-09-08 23: 15: 27Z
    4. Sorun nedir? NPE'yi yeterli içeriğin mevcut olduğu uygun bir seviyede yakalayın, içerik bilgisini boşaltın ve istisnayı yeniden gözden geçirin ... Java ile çok kolay.
      2013-03-07 01: 37: 44Z
    5. Yöntem çağrısı zincirlemesine karşı vaaz veren bir profesörüm vardı. Teorisi, 2 yöntemden daha uzun olan çağrı zincirlerine karşı dikkatli olmanız gerektiği idi. Bunun zor bir kural olup olmadığını bilmiyorum, ancak NPE yığın izleri ile ilgili sorunların çoğunu kesinlikle ortadan kaldırıyor.
      2013-04-16 17: 12: 10Z

    Java 7, java.util.Objects yöntemi bulunan yeni bir requireNonNull() yardımcı sınıfına sahiptir. Tek yaptığı şey, argümanı null olursa NullPointerException'u atmaktır, ancak kodu biraz temizler. Örnek:

     
    Objects.requireNonNull(someObject);
    someObject.doCalc();
    

    Yöntem, bir atamadan hemen önce kontrol etmek için en kullanışlıdır her kullanımda üç satır kod kaydedebileceği bir yapıcıda:

     
    Parent(Child child) {
       if (child == null) {
          throw new NullPointerException("child");
       }
       this.child = child;
    }
    

    olur

     
    Parent(Child child) {
       this.child = Objects.requireNonNull(child, "child");
    }
    
        
    68
    2017-05-23 12: 18: 33Z
    1. Aslında, örneğiniz kod bloat'ı oluşturur: NPE ikinci satıra atılacağı için ilk satır gereksizdir. ; -)
      2013-03-07 01: 21: 24Z
    2. Doğru. İkinci satır doCalc(someObject) olsaydı daha iyi bir örnek olurdu.
      2013-03-07 05: 23: 03Z
    3. Bağlıdır. DoCalc () 'nın yazarıysanız, kontrolü bu yöntemin gövdesine (mümkünse) koymanızı öneririm. Ve sonra büyük olasılıkla someObject.someMethod () 'ı arayacaksınız, burada tekrar null kontrolü yapmaya gerek kalmayacak. : -)
      2013-03-07 07: 07: 18Z
    4. Pekala, doCalc()’un yazarı değilseniz ve null verildiğinde hemen NPE atmazsa, null değerini kontrol etmeniz ve NPE’yi kendiniz atmanız gerekir. . Objects.requireNonNull() bunun için var.
      2013-03-09 06: 43: 51Z
    5. Sadece kod bloat değil. Yan etkilere neden olan veya zaman /mekan kullanan bir yöntemle önden yarıya kadar kontrol etmek daha iyidir.
      2013-09-26 11: 33: 26Z

    Null 'sorun' değildir. Bir complete modelleme araç setinin ayrılmaz bir parçasıdır. Yazılım, dünyanın karmaşıklığını modellemeyi amaçlamaktadır ve boş yükünü taşımaktadır. Null, Java ve benzerlerinde 'Veri yok' veya 'Bilinmiyor' ifadesini gösterir. Bu nedenle, bu amaçlar için boş değerlerin kullanılması uygundur. 'Boş nesne' modelini tercih etmiyorum; Sanırım ' kim koruyacak? velilerin sorunu.
    Bana kız arkadaşımın adının ne olduğunu sorarsan, sana kız arkadaşım olmadığını söylerim. Java dilinde null döndürürüm. Bunun bir alternatifi, çözülemeyen (veya olmak istemeyen) bazı problemleri ortaya koymak için anlamlı bir istisna atmak ve kullanıcıya veri erişim hatasını yeniden denemek veya bildirmek için yığında daha yüksek bir yere devretmek olabilir.

    1. 'Bilinmeyen bir soru' için 'bilinmeyen cevap verin'. (Bunun işletme açısından doğru olduğu yerlerde null güvenli olun) Kullanım, birden çok arayanı rahatlatmadan önce bir yöntemde null argümanlarını kontrol etme aramadan önce onları kontrol etmekten.

       
      public Photo getPhotoOfThePerson(Person person) {
          if (person == null)
              return null;
          // Grabbing some resources or intensive calculation
          // using person object anyhow.
      }
      

      Bir önceki fotoğraf kütüphanemde olmayan bir kız arkadaşın fotoğrafını çekmemek için normal mantık akışına yol açar.

       
      getPhotoOfThePerson(me.getGirlfriend())
      

      Yeni gelen Java API'sine (ileriye dönük) uyar

       
      getPhotoByName(me.getGirlfriend()?.getName())
      

      Bazı kişiler için DB’de depolanan fotoğrafı bulamamak oldukça “normal iş akışı” olsa da, diğer bazı durumlarda aşağıdaki gibi çiftler kullanırdım

       
      public static MyEnum parseMyEnum(String value); // throws IllegalArgumentException
      public static MyEnum parseMyEnumOrNull(String value);
      

      <alt> + <shift> + <j> (Eclipse'de javadoc) yazıp, genel API için üç ek sözcük yazmayın. Bu, dokümantasyonu okumamış olanlar hariç herkes için fazlasıyla yeterli olacaktır.

       
      /**
       * @return photo or null
       */
      

      veya

       
      /**
       * @return photo, never null
       */
      
    2. Bu oldukça teorik bir durumdur ve çoğu durumda java null güvenli API'yi tercih etmelisiniz (10 yıl sonra yayınlanacaksa), ancak NullPointerException Exception’un alt sınıfıdır. makul bir uygulamanın yakalamak isteyebileceği koşulları belirten Throwable formu ( javadoc )! İstisnaların ilk avantajını kullanmak ve hata işleme kodunu 'normal' koddan ayırmak için ( Java yaratıcılarına göre ) NullPointerException’u yakalamak benim için de uygun.

       
      public Photo getGirlfriendPhoto() {
          try {
              return appContext.getPhotoDataSource().getPhotoByName(me.getGirlfriend().getName());
          } catch (NullPointerException e) {
              return null;
          }
      }
      

      Sorular ortaya çıkabilir:

      S. Ya getPhotoDataSource() boş döndürürse?
      A. İş mantığına kalmış. Bir fotoğraf albümü bulamazsam size fotoğraf gösteremem. AppContext başlatılmadıysa ne olur? Bu yöntemin iş mantığı buna katlanıyor. Aynı mantık daha katı olmalıysa, bir istisna atmak iş mantığının bir parçasıdır ve boş için açık kontrol kullanılmalıdır (durum 3). Yeni Java Null-güvenli API, seçmeli olanı belirtmek için buraya daha iyi uyarve programlayıcı hataları durumunda başarısızlığa uğramak ne anlama gelmez?

      S. Gereksiz kod çalıştırılabilir ve gereksiz kaynaklar tutulabilir.
      C: Eğer getPhotoByName() bir veritabanı bağlantısı açmaya çalışırsa, PreparedStatement oluşturur ve kişi adını sonunda bir SQL parametresi olarak kullanırsa gerçekleşebilir. Bilinmeyen bir soru için yaklaşımı bilinmeyen bir cevap veriyor (vaka 1) burada çalışıyor. Kaynakları yakalamadan önce, yöntem parametreleri kontrol etmeli ve gerekirse 'bilinmeyen' sonucu döndürmelidir.

      S. Bu yaklaşım, deneme kapatma açılışından dolayı performans cezasına sahiptir.
      A. Yazılımın öncelikle anlaşılması ve değiştirilmesi kolay olmalıdır. Ancak bundan sonra, kişi performans hakkında düşünebilir ve yalnızca gerekirse! ve gerektiği yerde! ( kaynak ) ve diğerleri)).

      PS. Bu yaklaşım, ayrı hata işleme kodunun "normal" koddan ayrı olarak kullanılması ilkesi kadar makul olacaktır. Bir sonraki örneği ele alalım:

       
      public SomeValue calculateSomeValueUsingSophisticatedLogic(Predicate predicate) {
          try {
              Result1 result1 = performSomeCalculation(predicate);
              Result2 result2 = performSomeOtherCalculation(result1.getSomeProperty());
              Result3 result3 = performThirdCalculation(result2.getSomeProperty());
              Result4 result4 = performLastCalculation(result3.getSomeProperty());
              return result4.getSomeProperty();
          } catch (NullPointerException e) {
              return null;
          }
      }
      
      public SomeValue calculateSomeValueUsingSophisticatedLogic(Predicate predicate) {
          SomeValue result = null;
          if (predicate != null) {
              Result1 result1 = performSomeCalculation(predicate);
              if (result1 != null && result1.getSomeProperty() != null) {
                  Result2 result2 = performSomeOtherCalculation(result1.getSomeProperty());
                  if (result2 != null && result2.getSomeProperty() != null) {
                      Result3 result3 = performThirdCalculation(result2.getSomeProperty());
                      if (result3 != null && result3.getSomeProperty() != null) {
                          Result4 result4 = performLastCalculation(result3.getSomeProperty());
                          if (result4 != null) {
                              result = result4.getSomeProperty();
                          }
                      }
                  }
              }
          }
          return result;
      }
      

      PPS. Hızlı oy kullanmayanlar için (ve dökümanları okumak için çok hızlı değiller) hayatımda hiç bir zaman boş gösterici istisna (NPE) yakalamadığımı söylemek isterim. Ancak bu olasılık Java yaratıcıları tarafından kasten tasarlandı çünkü NPE Exception'un bir alt sınıfı. ThreadDeath, Error iken, aslında bir uygulama hatası olmadığı için değil, yalnızca yakalanması amaçlanmadığı için Java tarihinde bir emsalimiz var! Error'dan ThreadDeath'a ne kadar NPE uyuyor! Ancak öyle değil.

    3. Yalnızca iş mantığı ima ederse 'Veri yok' ifadesini kontrol edin.

       
      public void updatePersonPhoneNumber(Long personId, String phoneNumber) {
          if (personId == null)
              return;
          DataSource dataSource = appContext.getStuffDataSource();
          Person person = dataSource.getPersonById(personId);
          if (person != null) {
              person.setPhoneNumber(phoneNumber);
              dataSource.updatePerson(person);
          } else {
              Person = new Person(personId);
              person.setPhoneNumber(phoneNumber);
              dataSource.insertPerson(person);
          }
      }
      

      ve

       
      public void updatePersonPhoneNumber(Long personId, String phoneNumber) {
          if (personId == null)
              return;
          DataSource dataSource = appContext.getStuffDataSource();
          Person person = dataSource.getPersonById(personId);
          if (person == null)
              throw new SomeReasonableUserException("What are you thinking about ???");
          person.setPhoneNumber(phoneNumber);
          dataSource.updatePerson(person);
      }
      

      AppContext veya dataSource işlenmemiş çalışma zamanı başlatılmadıysa NullPointerException geçerli iş parçacığını öldürür ve Thread.defaultUncaughtExceptionHandler (sık kullandığınız kayıt cihazını veya diğer bildirim mekanizmalarını tanımlayıp kullanmanız için). Ayarlanmadıysa, ThreadGroup # uncaughtException , sistem hatalarına yığın izini yazdıracak. Bir kişi uygulama hatası günlüğünü izlemeli ve aslında uygulama hatası olan işlenmeyen istisnalar için Jira sorununu açmalıdır. Programcı, başlatma öğelerinde bir yerde bulunan hatayı düzeltmelidir.

    68
    2018-02-23 22: 03: 07Z
    1. NullPointerException'u yakalamak ve null'u döndürmek hata ayıklamak için korkunçtur. Zaten NPE ile son buluyorsun ve aslında neyin boş olduğunu bulmak gerçekten zor.
      2013-09-14 08: 44: 57Z
    2. İtibarım olsaydı, reddederdim. Sadece boş değil, tip sisteminde de bir delik. Bir Listeye Ağaç Atama, bir tür hatasıdır; çünkü ağaçlar List türündeki değerler değildir; aynı mantıkla, null atama bir tip hatası olmalıdır çünkü null, bir Object türünün değeri veya bu konuda herhangi bir faydalı tip değildir. Null'u icat eden adam bile onu "milyar dolarlık hata" olarak değerlendiriyor. "T VEYA hiçbir türün değeri olabilecek bir değer" kavramı kendi tipidir ve ("Belki T> veya İsteğe Bağlı> T>) şeklinde gösterilmelidir.
      2013-11-20 15: 57: 25Z
    3. "Belki < T > veya İsteğe Bağlı < T >" den itibaren Hala if (maybeNull.hasValue()) {...} gibi bir kod yazmanız gerekiyor. Öyleyse if (maybeNull != null)) {...} ile farkı nedir?
      2014-04-01 11: 06: 15Z
    4. "NullPointerException'ı yakalamak ve null döndürmek hata ayıklamak için korkunç. NPE ile daha sonra nihayetinde bitirdiniz ve aslında null olduğunu bulmak gerçekten zor". Tamamen katılıyorum! Bu gibi durumlarda bir düzine 'if' ifadesi yazmalı ya da iş mantığı yerinde veri içeriyorsa NPE atmalı ya da yeni Java'dan boş güvenli operatörü kullanmalısınız. Fakat tam olarak hangi adımın neyi boşa vereceği umrumda değil. Örneğin, kullanıcı için bazı değerleri hesaplamayı beklediğinizde ekranda göstermeden hemen önce hesaplamakata eksik olabilir.
      2014-04-01 11: 32: 50Z
    5. @ MykhayloAdamovych: Maybe<T> veya Optional<T>’un yararı, T’un boş olabileceği durumda değil, asla boş olmaması gerektiği durumda. Açıkça "bu değer olabilir - dikkatli kullanın" anlamına gelen bir türünüz varsa ve böyle bir türü tutarlı bir şekilde kullanır ve geri verirseniz, o zaman kodunuzda düz eski T'u gördüğünüzde, Bunun asla boş olmadığını varsayabilirsin. (Elbette, derleyici tarafından uygulanabiliyorsa bu çok daha faydalı olacaktır.)
      2014-11-07 19: 55: 35Z

    Sonuç olarak, bu sorunu tamamen çözmenin tek yolu farklı bir programlama dili kullanmaktır:

    • Objective-C'de, nil'da bir yöntemi çağırmakla eşdeğerde yapabilirsiniz ve kesinlikle hiçbir şey olmaz. Bu, boş denetimlerin çoğunu gereksiz kılar, ancak hataların teşhisini çok zorlaştırabilir.
    • Java türevi bir dil olan Nice 'de, tüm türlerin iki sürümü vardır : potansiyel olarak boş bir sürüm ve boş değil bir sürüm. Yalnızca boş olmayan türlerde yöntemleri çağırabilirsiniz. Potansiyel olarak null tipler null değerinin açık kontrolü ile null olmayan tiplere dönüştürülebilir. Bu, boş denetimlerin nerede gerekli olduğunu ve nerede olmadıklarını bilmeyi çok kolaylaştırır.
    50
    2015-09-19 16: 09: 15Z
    1. Woah ... En doğru cevap ve aleyhte oy verildi, adalet nerede? Java'da null her zaman geçerli bir değerdir. Her şeyin özü bir nesnedir - Null bir Herşeydir (elbette burada ilkelleri görmezden geliyoruz ama siz anlıyorsunuz). Şahsen, Nice'in uyguladığı yaklaşımı tercih ediyorum, ancak bunu yapabiliriz, bu yöntemlerin geçersiz sayılabilecek türlerde çağrılması ve NPE'lerin kontrol edilen istisnalara teşvik edilmesi. Bu, mevcut tüm kodu kırabilecek olsa da, bir derleyici anahtarı ile yapılmalıdır :(
      2010-08-16 06: 36: 15Z
    2. Nice'e aşina değilim, ancak Kotlin de aynı fikri uygular, dilin tip sistemine null ve null olmayan tipler oluşturur. Optionals veya null Object deseninden çok daha özlü.
      2018-09-17 19: 29: 03Z

    Java’da gerçekten sık sık "sorun" var.

    İlk olarak, bu konudaki düşüncelerim:

    NULL geçildiğinde NULL'ın geçerli bir değer olmadığı bir şeyi "yemenin" kötü olduğunu düşünüyorum. Eğer bir tür hatayla yöntemi terk etmiyorsanız, bu yönteminizde doğru olmayan hiçbir şeyin yanlış olmadığı anlamına gelir. O zaman muhtemelen bu durumda null değerini döndürürsünüz ve alma yönteminde yine null değerini kontrol edersiniz ve asla bitmez ve "if! = Null", vb. İle sona erersiniz.

    Dolayısıyla, IMHO, null, daha fazla yürütmeyi engelleyen kritik bir hata olmalıdır (yani, null geçerli bir değer değildir).

    Bu sorunu çözme yöntemim şudur:

    İlk önce bu sözleşmeyi takip ediyorum:

    1. Tüm genel yöntemler /API her zaman null değerindeki argümanlarını kontrol eder
    2. Tüm özel yöntemler, denetlenen yöntemler olduğundan null değerini denetlemez (yukarıda ele alınmadığı durumlarda nullpointer istisnasıyla ölmesine izin verin)
    3. Null değerini denetlemeyen yalnızca diğer yöntemler yardımcı program yöntemleridir. Bunlar halka açıktır, ancak bir nedenden ötürü çağırırsanız, hangi parametreleri geçirdiğinizi bilirsiniz. Bu, su ısıtıcısındaki suyu su sağlamadan kaynatmaya çalışmak gibi bir şey ...

    Sonunda, kodda, genel yöntemin ilk satırı şöyle devam eder:

     
    ValidationUtils.getNullValidator().addParam(plans, "plans").addParam(persons, "persons").validate();
    

    addParam () işlevinin kendini döndürdüğünü ve denetlenecek daha fazla parametre ekleyebildiğinizi unutmayın.

    Parametrelerden biri boşsa, yöntem validate() denetlenen ValidationException yöntemini atar (denetlenen veya işaretlenmeyen bir tasarım /lezzet sorunu ise, ancak ValidationException'um denetlenir).

     
    void validate() throws ValidationException;
    

    Örneğin, "planlar" boşsa, mesaj aşağıdaki metni içerecektir:

    " Geçersiz bağımsız değişken değeri null karşılaşılıyord [[plan] "parametresi için

    Gördüğünüz gibi, addParam () yöntemindeki (string) ikinci değer kullanıcı mesajı için gereklidir, çünkü iletilen değişken adını, yansıma bile olsa (kolayca bu yazıya tabi değil) kolayca tespit edemezsiniz. .).

    Ve evet, biliyoruz ki, bu çizginin ötesinde artık boş bir değerle karşılaşmayacağız, bu yüzden bu nesneler üzerinde güvenli bir şekilde yöntemleri çağırıyoruz.

    Bu şekilde, kod temiz, bakımı kolay ve okunabilirdir.

        
    35
    2015-09-19 19: 00: 35Z
    1. Kesinlikle. Sadece hatayı atan ve çöken uygulamalar daha yüksek kalitededir çünkü çalışmadıklarında şüphe yoktur. Hataları en iyi şekilde yutan uygulamalar, incelikle bozulur, ancak genellikle fark edilmesi zor ve düzelmeyen şekillerde çalışmaz. Ve sorun fark edildiğinde hata ayıklamak daha zordur.
      2011-11-14 05: 06: 57Z

    Bu soruyu sormak, hata işleme stratejileriyle ilgilenebileceğinize işaret ediyor. Takımınızın mimarı hataların nasıl çalışılacağına karar vermelidir. Bunu yapmanın birkaç yolu vardır:

    1. İstisnalar'ın dalgalanmasına izin verin - onları 'ana döngüde' veya başka bir yönetim rutinde yakalayın.

      • hata durumlarını kontrol edin ve bunları uygun şekilde ele alın

    Aspect Oriented Programming’e de bir göz atın, bayt kodunuza if( o == null ) handleNull()’u eklemek için temiz yolları var.

        
    33
    2008-11-07 09: 27: 17Z

    assert'u kullanmaya ek olarak aşağıdakileri kullanabilirsiniz:

     
    if (someobject == null) {
        // Handle null here then move on.
    }
    

    Bu, şunlardan biraz daha iyidir:

     
    if (someobject != null) {
        .....
        .....
    
    
    
        .....
    }
    
        
    33
    2015-09-19 17: 14: 39Z
    1. Mh, neden bu? Lütfen herhangi bir savunma hissetmeyin, sadece Java hakkında daha fazla bilgi edinmek istiyorum :)
      2010-08-17 05: 54: 02Z
    2. @ Mudu Genel bir kural olarak, bir "negatif" ifadesinden ziyade, bir if ifadesindeki ifadeyi daha "pozitif" bir ifade olarak tercih ederim. Öyleyse if (!something) { x(); } else { y(); }'u görürsem, onu yeniden if (something) { y(); } else { x(); } olarak değiştirmeye meyilli olurdum (biri != null'un daha olumlu bir seçenek olduğunu iddia edebilir ...). Fakat daha da önemlisi, kodun önemli kısmı {} s içine sarılmamıştır ve yöntemin çoğu için bir seviye daha az girinti vardır. Bunun fastcodejava'nın mantığı olup olmadığını bilmiyorum ama bu benim olacaktı.
      2011-06-22 00: 05: 02Z
    3. Bu benim de yapmaya meyilli olduğum şey .. Kodu benim görüşüme göre temiz tutuyor.
      2015-12-15 21: 44: 57Z

    Sadece boş kullanmayın. İzin verme.

    Sınıflarımda, çoğu alan ve yerel değişkenler boş olmayan varsayılan değerlere sahiptir ve kodun her yerine zorla uygulandığından emin olmak için her yerde sözleşme ifadeleri ekler (her zaman açık iddialar) NPE olarak gelmesine izin vermek ve ardından satır numarasını, vb. çözmek zorunda kalmadan).

    Bu uygulamayı bir kez benimsediğimde, sorunların kendi başlarına hallettiğini fark ettim. Gelişim sürecinde daha önce kaza ile olayları yakalar ve zayıf bir noktaya sahip olduğunuzu fark edersiniz .. ve daha da önemlisi .. farklı modüllerin kaygılarını kapsamaya yardımcı olur, farklı modüller birbirlerini 'güvenebilir' ve daha fazla önemsiz bırakmaz. if = null else yapıya sahip kod!

    Bu, savunma amaçlı bir programlamadır ve uzun vadede daha temiz kodlarla sonuçlanır. Verileri daima temizleyin, ör. burada katı standartlar uygulayarak veo sorunları gider.

     
    class C {
        private final MyType mustBeSet;
        public C(MyType mything) {
           mustBeSet=Contract.notNull(mything);
        }
       private String name = "<unknown>";
       public void setName(String s) {
          name = Contract.notNull(s);
       }
    }
    
    
    class Contract {
        public static <T> T notNull(T t) { if (t == null) { throw new ContractException("argument must be non-null"); return t; }
    }
    

    Sözleşmeler, üretimde bile her zaman yapılan mini birim testleri gibidir ve işler başarısız olduğunda, nedense, rastgele bir NPE yerine neden olduğunu anlamak zorunda olduğunuzu biliyorsunuz.

        
    31
    2015-09-19 19: 42: 38Z
    1. bu neden indirildi? Tecrübelerime göre, bu diğer yaklaşımlardan çok daha üstün, neden olmasın bilmek isterdim
      2012-10-31 21: 31: 17Z
    2. Katılıyorum, bu yaklaşım her yerde kod denetimlerini heceleyerek düzeltmek yerine boş değerlerle ilgili sorunları önler.
      2013-07-27 10: 48: 42Z
    3. Bu yaklaşımla ilgili sorun, ad hiç ayarlanmadığında, ayarlanmış bir değer gibi davranan "< unknown >" değerine sahip olmasıdır. Şimdi, adın hiçbir zaman ayarlanıp ayarlanmadığını (bilinmeyen) kontrol etmem gerektiğini varsayalım, "< unknown >" özel değeriyle ilgili bir dize karşılaştırması yapmalıyım.
      2013-12-17 07: 02: 29Z
    4. Gerçek iyi nokta Steve. Sık sık yaptığım şey bu değerin sabit olması, örn. public static final Dize UNSET = "__ unset" ... özel Dize alan = UNSET ... sonra özel boolean isSet () {return UNSET.equals (field); }
      2015-01-26 19: 45: 50Z
    5. IMHO, Bu, İsteğe Bağlı (Sözleşme) seçeneğini kendiniz uygulayan bir Boş Nesne Örüntüsü uygulamasıdır. Kalıcılık sınıfı dersinde nasıl davranır? Bu durumda uygulanabilir görmüyorum.
      2017-12-09 19: 56: 01Z

    Google’ın çok yararlı bir çekirdek kütüphanesi olan Guava’da boşluğu önlemek için hoş ve faydalı bir API bulunur. KullanımıAndAvoidingNullExplained" rel="noreferrer"> KullanımıAndAvoidingNullExplained çok yararlı buluyorum.

    Viki'de açıklandığı gibi:

      

    Optional<T>, NULL olabilecek bir T referansını bir ile değiştirmenin bir yoludur.   boş olmayan değer. İsteğe bağlı, boş olmayan bir T referansı içerebilir   (bu durumda referansın "mevcut" olduğunu söyleriz) veya içerebilir   hiçbir şey (bu durumda referansın "yok" olduğunu söyleriz). Asla   "null içer" dedi.

    Kullanım:

     
    Optional<Integer> possible = Optional.of(5);
    possible.isPresent(); // returns true
    possible.get(); // returns 5
    
        
    29
    2014-08-07 21: 03: 14Z
    1. @ CodyGuldner Doğru, Cody. Daha fazla içerik vermek için bağlantıdan alakalı bir teklif verdim.
      2014-08-07 21: 05: 08Z

    Bu, her Java geliştiricisi için çok yaygın bir sorundur. Bu yüzden, Java 8’de, bu sorunları karmaşık kod olmadan ele almak için resmi destek var.

    Java 8, java.util.Optional<T>'u tanıttı. Boş olmayan bir değere sahip olan ya da içermeyen bir kaptır. Java 8, bazı durumlarda değeri boş olabilecek bir nesneyi ele almanın daha güvenli bir yolunu sağlamıştır. Haskell ve Scala .

    Özet olarak, İsteğe Bağlı sınıf, bir değerin mevcut olduğu veya bulunmadığı durumlarla açıkça ilgilenmek için yöntemler içerir. Ancak, boş referanslara kıyasla avantajı, İsteğe Bağlı &T; sınıf, değerin olmadığı durumlarda durum hakkında düşünmeye zorlar. Sonuç olarak, istenmeyen boş gösterici istisnalarını önleyebilirsiniz.

    Yukarıdaki örnekte, evde mevcut olan birden fazla cihaza bir tutamaç veren bir ev servisi fabrikası bulunmaktadır. Ancak bu hizmetler mevcut /işlevsel olabilir veya olmayabilir; olabilir demekNullPointerException ile sonuçlanır. Herhangi bir hizmeti kullanmadan önce boş if koşulu eklemek yerine, İsteğe Bağlı < Servis > 'e sarın.

    SEÇENEĞE WRAPPING < T >

    Fabrikadan bir hizmete referans almak için bir yöntem düşünelim. Servis referansını iade etmek yerine, İsteğe Bağlı ile kaydırın. API kullanıcısının, iade edilen hizmetin kullanılabilir durumda olabileceğini veya kullanılamayacağını veya kullanılamayacağını bilmesini sağlar.  

    public Optional<Service> getRefrigertorControl() {
          Service s = new  RefrigeratorService();
           //...
          return Optional.ofNullable(s);
       }
    

    Gördüğünüz gibi Optional.ofNullable() referansı almak için kolay bir yol sunar. İsteğe bağlı olarak başvuru almanın başka yolları da var, ya Optional.empty() & Optional.of(). Biri null değerini döndürmek yerine boş bir nesneyi döndürmek için, diğeri de sırasıyla silinemez bir nesneyi kaydırmak için.

    ÇOK NULL KONTROLÜ KAÇMAK İÇİN NASIL TAM YARDIMCI OLUR?

    Bir referans nesnesini tamamladıktan sonra, İsteğe Bağlı, NPE olmadan tamamlanmış bir referansta yöntemleri çağırmak için birçok yararlı yöntem sunar.

     
    Optional ref = homeServices.getRefrigertorControl();
    ref.ifPresent(HomeServices::switchItOn);
    

    Optional.ifPresent, boş bir değer değilse, verilen Tüketiciyi referansla çağırır. Aksi takdirde, hiçbir şey yapmaz.

     
    @FunctionalInterface
    public interface Consumer<T>
    

    Tek bir giriş bağımsız değişkenini kabul eden ve sonuç döndürmeyen bir işlemi temsil eder. Diğer birçok işlevsel arabirimin aksine, Tüketici'nin yan etkiler ile çalışması beklenir. Çok temiz ve anlaşılması kolaydır. Yukarıdaki kod örneğinde, İsteğe bağlı tutma referansı boş değilse HomeService.switchOn(Service) çağrılır.

    Üçlü operatörü boş durumu kontrol etmek için çok sık kullanıyoruz ve alternatif bir değer veya varsayılan değer döndürüyoruz. İsteğe bağlı, aynı koşulu null kontrol etmeden ele almanın başka bir yolunu sunar. Optional.orElse (defaultObj), Optional öğesinin boş değeri varsa, defaultObj değerini döndürür. Bunu örnek kodumuzda kullanalım:

     
    public static Optional<HomeServices> get() {
        service = Optional.of(service.orElse(new HomeServices()));
        return service;
    }
    

    Şimdi HomeServices.get () aynı şeyi yapar, ancak daha iyi bir şekilde. Hizmetin zaten başlatılmamış olup olmadığını kontrol eder. Öyleyse, aynısını döndür veya yeni bir Yeni servis oluştur. İsteğe bağlı < T > .orElse (T), varsayılan bir değer döndürmeye yardımcı olur.

    Son olarak, burada NPE’niz ve boş check-free kodumuz var:

     
    import java.util.Optional;
    public class HomeServices {
        private static final int NOW = 0;
        private static Optional<HomeServices> service;
    
    public static Optional<HomeServices> get() {
        service = Optional.of(service.orElse(new HomeServices()));
        return service;
    }
    
    public Optional<Service> getRefrigertorControl() {
        Service s = new  RefrigeratorService();
        //...
        return Optional.ofNullable(s);
    }
    
    public static void main(String[] args) {
        /* Get Home Services handle */
        Optional<HomeServices> homeServices = HomeServices.get();
        if(homeServices != null) {
            Optional<Service> refrigertorControl = homeServices.get().getRefrigertorControl();
            refrigertorControl.ifPresent(HomeServices::switchItOn);
        }
    }
    
    public static void switchItOn(Service s){
             //...
        }
    }
    

    Yazının tamamı NPE ve Null onaysız kod… Gerçekten mi? .

        
    22
    2015-09-19 20: 39: 30Z

    Nat Pryce'in makalelerini seviyorum. İşte linkler:

    Makalelerde ilginç bulduğum bir Java Belki Türü için Git deposuna bir bağlantı da var, ancak tek başıma bu içeriği azaltabileceğini sanmıyorum. kod bloğu denetleniyor. İnternette biraz araştırma yaptıktan sonra, ! = Null kod kısıtlamasının esasen dikkatli bir tasarımla azaltılabileceğini düşünüyorum.

        
    21
    2016-05-12 02: 49: 30Z
    1. Michael Feathers, bahsettiğiniz gibi yaklaşımlar hakkında kısa ve ilgi çekici bir metin yazdı: manuelp.newsblur.com/site/424
      2013-07-12 20: 59: 39Z

    NullObjectPattern'u denedim ama benim için her zaman gitmek için en iyi yol değil. Bazen bir "eylem yok" uygun değilken vardır.

    NullPointerException, Çalışma Zamanı istisnasıdır , geliştiricilerin hatası olduğu anlamına gelir ve yeterince tecrübesiyle size hatanın tam olarak nerede olduğunu söyler.

    Şimdi cevaba:

    Tüm niteliklerinizi ve erişiminizi mümkün olduğu kadar gizli tutmaya çalışın veya bunları müşterilere maruz bırakmaktan kaçının. Elbette kurucuda argüman değerlerine sahip olabilirsiniz, ancak kapsamı azaltarak müşteri sınıfının geçersiz bir değer geçmesine izin vermezsiniz. Değerleri değiştirmeniz gerekirse, her zaman yeni bir object oluşturabilirsiniz. Yapıcıdaki değerleri yalnızca bir kez kontrol edersiniz ve yöntemlerin geri kalanında, değerlerin boş olmadığından neredeyse emin olabilirsiniz.

    Tabii ki,deneyim, bu öneriyi anlamak ve uygulamak için daha iyi bir yoldur.

    Bayt!

        
    19
    2013-09-30 22: 06: 24Z

    Muhtemelen Java 8 veya daha yenisi için en iyi alternatif, Optional sınıfı.

     
    Optional stringToUse = Optional.of("optional is there");
    stringToUse.ifPresent(System.out::println);
    

    Bu, özellikle olası boş değerlerin uzun zincirleri için kullanışlıdır. Örnek:

     
    Optional<Integer> i = Optional.ofNullable(wsObject.getFoo())
        .map(f -> f.getBar())
        .map(b -> b.getBaz())
        .map(b -> b.getInt());
    

    Null değerinde istisna atma örneği:

     
    Optional optionalCarNull = Optional.ofNullable(someNull);
    optionalCarNull.orElseThrow(IllegalStateException::new);
    

    Java 7, Objects.requireNonNull , boş olmayan bir şeyin kontrol edilmesi gerektiğinde kullanışlı olabilecek bir yöntemdir. Örnek:

     
    String lowerVal = Objects.requireNonNull(someVar, "input cannot be null or empty").toLowerCase();
    
        
    16
    2016-09-29 07: 35: 54Z

    Daha genel olarak cevap verebilir miyim?

    Yöntemler beklenmeyen şekilde parametreleri aldığında genellikle bu sorunla karşılaşırız (kötü yöntem çağrısı programcının hatasıdır). Örneğin: bir nesne elde etmeyi umuyorsunuz, bunun yerine boş. En az bir karakter içeren bir String almayı bekliyorsunuz, bunun yerine boş bir String alıyorsunuz ...

    Öyleyse arasında hiçbir fark yoktur:

     
    if(object == null){
       //you called my method badly!
    

    }

    veya

     
    if(str.length() == 0){
       //you called my method badly again!
    }
    

    Her ikisi de başka işlevler yapmadan önce geçerli parametreler aldığımızdan emin olmak istiyor.

    Diğer bazı cevaplarda belirtildiği gibi, yukarıdaki sorunlardan kaçınmak için Sözleşmeye göre tasarla desenini takip edebilirsiniz. Lütfen http://en.wikipedia.org/wiki/Design_by_contract adresine bakın.

    Bu kalıbı java'da uygulamak için javax.annotation.NotNull gibi çekirdek java ek açıklamalarını kullanabilir ya da Hibernate Validator gibi daha karmaşık kütüphaneler kullanabilirsiniz.

    Sadece bir örnek:

     
    getCustomerAccounts(@NotEmpty String customerId,@Size(min = 1) String accountType)
    

    Artık giriş parametrelerini denetlemenize gerek kalmadan yönteminizin temel işlevini güvenli bir şekilde geliştirebilirsiniz, yöntemlerinizi beklenmeyen parametrelerden korurlar.

    Bir adım daha ileri gidebilir ve başvurunuzda yalnızca geçerli pojolar oluşturulabildiğinden emin olabilirsiniz. (hazırda bekleme doğrulayıcı sitesinden örnekleme)

     
    public class Car {
    
       @NotNull
       private String manufacturer;
    
       @NotNull
       @Size(min = 2, max = 14)
       private String licensePlate;
    
       @Min(2)
       private int seatCount;
    
       // ...
    }
    
        
    15
    2014-04-24 14: 48: 05Z
    1. javax, tanımı gereği, değil "çekirdek Java" dır.
      2015-10-30 04: 02: 25Z

    Her durumda boş nesneleri kullanmayı öneren cevapları kesinlikle göz ardı ediyorum. Bu kalıp sözleşmeyi kırabilir ve sorunları çözmek yerine daha derin ve daha derin sorunları gömebilir, uygun olmayan bir şekilde kullanılmasının gelecekteki bakım gerektiren bir başka boyler kod kodu yığını oluşturacağından bahsetmez.

    Gerçekte, bir yöntemden döndürülen bir şey boş olabilir ve çağrı kodunun karar vermesi gerekiyorsa, devleti sağlayan daha erken bir çağrı yapılmalıdır.

    Ayrıca, boş nesne modelinin, dikkatsiz kullanıldığında hafızada aç olacağını unutmayın. Bunun için - bir NullObject örneği sahipler arasında paylaşılmalı ve bunların her biri için uygun olmayan bir örnek olmamalıdır.

    Ayrıca, türün skaler olmayan bir ilkel tür gösterimi - matematiksel varlıklar gibi, ilkel bir tür gösterimi olduğu durumlarda bu kalıbı önermem: vektörler, matrisler, karmaşık sayılar ve POD (Eski Eski Veriler) nesneleri. Java yerleşik türleri biçiminde tutmak için. İkinci durumda, rasgele sonuçlarla getter yöntemlerini çağırmanız gerekir. Örneğin, NullPerson.getName () yöntemi ne döndürmelidir?

    Saçma sonuçlardan kaçınmak için bu tür davaları göz önünde bulundurmaya değer.

        
    15
    2016-02-04 11: 24: 57Z
    1. "hasBackground ()" içeren çözümün tek dezavantajı vardır - iş parçacığı için güvenli değildir. Biri yerine iki yöntem çağırmanız gerekirse, tüm diziyi çok iş parçacıklı ortamda eşitlemeniz gerekir.
      2016-02-03 12: 26: 12Z
    2. @ pkalinow Yalnızca bu çözümün bir sakıncası olduğunu belirtmek için tartışmalı bir örnek yaptınız. Kodun çok iş parçacıklı uygulamada çalıştırılması amaçlanmadıysa sakınca yoktur. Kodunuzun% 90'ını güvenli bir şekilde kullanmayacağınızı söyleyebilirim. Burada kodun bu yönü hakkında konuşmuyoruz, tasarım deseni hakkında konuşuyoruz. Ve çok iş parçacığı kendi başına bir konudur.
      2016-02-03 15: 29: 59Z
    3. Elbette tek bir konu uygulamasında sorun değil. Bu yorumu verdim çünkü bazen bu bir problem.
      2016-02-04 10: 34: 10Z
    4. @ pkalinow Bu konuyu daha yakından incelerseniz, Null Object tasarım modelinin okuyuculuk sorunlarını çözmeyeceğini öğreneceksiniz. Yani konu dışı. Ve dürüst olmak gerekirse, bu kalıbın güzel bir şekilde sığabileceği yerler buldum, bu yüzden asıl cevabım aslında biraz yanlış.
      2016-02-04 10: 57: 44Z
    1. Değişkenleri asla null olarak başlatmayın.
    2. (1) mümkün değilse, tüm koleksiyonları ve dizileri boş koleksiyonlara /dizilere hazırlayın.

    Bunu kendi kodunuzda yaparak kaçınabilirsiniz! = boş kontroller.

    Çoğu zaman boş denetimler, koleksiyonlar veya dizilerdeki döngüleri korur gibi görünür, bu nedenle boş bıraktıktan sonra boş denetimlere gerek kalmaz.

     
    // Bad
    ArrayList<String> lemmings;
    String[] names;
    
    void checkLemmings() {
        if (lemmings != null) for(lemming: lemmings) {
            // do something
        }
    }
    
    
    
    // Good
    ArrayList<String> lemmings = new ArrayList<String>();
    String[] names = {};
    
    void checkLemmings() {
        for(lemming: lemmings) {
            // do something
        }
    }
    

    Bunda küçük bir ek yük var, ancak daha temiz kod ve daha az NullPointerExceptions için buna değer.

        
    14
    2013-10-02 13: 50: 54Z
    1. 2013-07-01 07: 45: 34Z
    2. + 1 Buna katılıyorum. Başlatılan nesnelerin yarısını asla geri döndürmemelisiniz. Jaxb ile ilgili kod ve fasulye kodu bunun için kayıtsızdır. Kötü bir uygulamadır. Tüm koleksiyonlar başlatılmalı ve tüm nesneler (ideal olarak) boş referans olmadan bulunmalıdır. İçinde koleksiyonu olan bir nesneyi düşünün. Nesnenin boş olmadığını, koleksiyonun boş olmadığını ve koleksiyonun boş nesneler içermediğini kontrol etmek mantıksız ve aptaldır.
      2013-09-23 14: 52: 42Z

    Bu, geliştiricilerin çoğu için en yaygın görülen hatadır.

    Bununla başa çıkmanın pek çok yolu var.

    Yaklaşım 1:

     
    org.apache.commons.lang.Validate //using apache framework
    

    notNull (Nesne nesnesi, Dize mesajı)

    Yaklaşım 2:

     
    if(someObject!=null){ // simply checking against null
    }
    

    Yaklaşım 3:

     
    @isNull @Nullable  // using annotation based validation
    

    Yaklaşım 4:

     
    // by writing static method and calling it across whereever we needed to check the validation
    
    static <T> T isNull(someObject e){  
       if(e == null){
          throw new NullPointerException();
       }
       return e;
    }
    
        
    14
    2015-03-24 17: 13: 41Z
    1. Reklam. 4. Çok kullanışlı değildir - bir işaretçinin boş olup olmadığını kontrol ettiğinizde, muhtemelen üzerine bir metot çağırmak istersiniz. Null üzerinde bir yöntem çağırmak size aynı davranışı verir - NullPointerException.
      2016-02-03 12: 18: 50Z
     
    public static <T> T ifNull(T toCheck, T ifNull) {
        if (toCheck == null) {
               return ifNull;
        }
        return toCheck;
    }
    
        
    11
    2015-09-19 17: 17: 55Z
    1. Bu yöntemin nesi yanlış, bence @tltester boş olsa bile null olursa varsayılan bir değer vermek istiyor.
      2011-08-17 05: 42: 06Z
    2. Apache commons-lang: ObjectUtils.defaultIfNull()'da böyle bir yöntem var. Bir tane daha genel var: ObjectUtils.firstNonNull(), aşağılayıcı bir strateji uygulamak için kullanılabilecek: firstNonNull(bestChoice, secondBest, thirdBest, fallBack);
      2015-04-16 08: 04: 31Z
kaynak yerleştirildi İşte
Diğer sorular
11
HTML'de H1-H6 font boyutları
diye sordu 9 yıl önce
63
Avoiding! = Null ifadeleri
diye sordu 1 yıl önce