nesne == null veya null == nesne?

Kontrol null == objectetmekten daha iyi birinden duydumobject == null

Örneğin :

void m1(Object obj ) {
   if(null == obj)  // Is this better than object == null ? Why ?
       return ;
   // Else blah blah
}

Herhangi bir sebep var mı yoksa bu başka bir efsane mi? Yardım için teşekkürler.

Bu, bu tür bir yazım hatasından kaçınmak için muhtemelen C'den öğrenilen bir alışkanlıktır (çift =yerine tek ==):

if (object = null) {

Sabiti'nin sol tarafına koyma kuralı ==Java'da pek kullanışlı değildir çünkü Java, ifadenin ifbir booleandeğer olarak değerlendirilmesini gerektirir , bu nedenle sabit a değilse, booleanher iki şekilde de bir derleme hatası alırsınız. argümanlar. (ve eğer bir boole ise, ==yine de kullanmamalısınız ...)

Diğerlerinin de söylediği gibi, yazım hatalarını önlemek C'den öğrenilen bir alışkanlıktır - ancak C'de bile, yeterince yüksek uyarı seviyelerine sahip iyi derleyicilerden bir uyarı vermelerini beklerdim. Chandru'nun dediği gibi, Java'da null ile bu şekilde karşılaştırma, yalnızca bir değişken türü Boolean(örnek kodda olmadığınız) kullanıyorsanız sorunlara neden olur . Bunun oldukça nadir bir durum olduğunu söyleyebilirim ve her yerde kod yazma şeklinizi değiştirmeye değecek bir durum değil. (Bu durumda bile işlenenleri tersine çevirme zahmetine girmem; eğer onları ters çevirmeyi düşünecek kadar net düşünüyorsam, eminim eşittir işaretlerini sayabilirim.)

Ne henüz söz edilmiştir birçok kişi (ben kesinlikle dahil) bulmandır if (variable == constant)o kendini ifade daha doğal bir yoldur - daha okunabilir olması için formu. Bu bir nedendir değil (her zaman soru uygulamaları gerektiğini burada ne aradığını :) tek bir ortamda yararlı olabilir Ne olduğunu varsayarak önceki gibi başka yararlıdır körü körüne C. Sizden bir kongre kopyalamak için.

Bu, nesnenin türünün olduğu durumlar dışında Java'da (1.5+) çok değerli değildir Boolean. Bu durumda, bu yine de kullanışlı olabilir.

if (object = null)nesne ise Java 1.5+ sürümünde derleme hatasına neden Booleanolmaz , ancak NullPointerExceptionçalışma zamanında bir hata verir .

Java'da iyi bir neden yok.

Diğer birkaç cevap, bunun, eşitlik yerine yanlışlıkla onu atama yapabileceğiniz için olduğunu iddia etti. Ancak Java'da, if'de boolean olması gerekir, bu yüzden bu:

if (o = null)

derlenmeyecek.

Bunun Java'da önemli olabileceği tek durum, değişkenin boole olmasıdır:

int m1(boolean x)
{
    if (x = true)  // oops, assignment instead of equality

Bu aynı zamanda aşağıdakilerle de yakından ilgilidir:

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

NPE'lerle uğraşmak istemiyorsanız kullanışlıdır:

if (bar!=null && bar.equals("foo")) {

Bu numara bir v = nulltür yazım hatalarını önlemiş olmalı .

Ancak Java, if()koşul olarak yalnızca boole ifadelerine izin verir, bu yüzden hile pek bir anlam ifade etmez, derleyici yine de bu yazım hatalarını bulacaktır.

Yine de C / C ++ kodu için hala değerli bir numaradır.

Aynı sebepten dolayı C'de yaparsınız; atama bir ifadedir, bu nedenle harfi harfine sola koyarsınız, böylece yanlışlıkla =yerine kullanırsanız üzerine yazamazsınız ==.

Bu, sol tarafta sabit olmasını tercih eden insanlar içindir. Çoğu durumda, sabitin sol tarafta olması NullPointerException'ın atılmasını (veya başka bir nullcheck olmasını) engeller. Örneğin, String yöntemi şuna eşittir ayrıca bir null denetimi yapar. Sabit değerin solda olması, ek çek yazmanızı engeller. Hangisi, başka bir şekilde daha sonra da yapılır. Soldaki boş değere sahip olmak sadece tutarlıdır.

sevmek:

 String b = null;
 "constant".equals(b);  // result to false
 b.equals("constant");  // NullPointerException
 b != null && b.equals("constant");  // result to false

Yoda koşulunun farklı bir şekilde yazılmasıdır

Java'da

String myString = null;
if (myString.equals("foobar")) { /* ... */ } //Will give u null pointer

yoda durumu

String myString = null;
if ("foobar".equals(myString)) { /* ... */ } // will be false 

Aşağıdaki kodla karşılaştırın:

    String pingResult = "asd";
    long s = System.nanoTime ( );
    if ( null != pingResult )
    {
        System.out.println ( "null != pingResult" );
    }
    long e = System.nanoTime ( );
    System.out.println ( e - s );

    long s1 = System.nanoTime ( );
    if ( pingResult != null )
    {
        System.out.println ( "pingResult != null" );
    }
    long e1 = System.nanoTime ( );
    System.out.println ( e1 - s1 );

Çıktı (Birden fazla yürütmeden sonra):

null != pingResult
325737
pingResult != null
47027

Bu nedenle, pingResult != nullkazanır.

Değişme özelliği nedeniyle, object == nullve null == object( Yoda versiyonu ) arasındaki tek fark bilişsel niteliktedir : kodun okuyucu tarafından nasıl okunduğu ve sindirildiği. Yine de kesin cevabı bilmiyorum, ama kişisel olarak incelediğim nesneyi başka bir şeyle karşılaştırmayı tercih ettiğimi biliyorum , eğer mantıklıysa, incelediğim nesneyle başka bir şeyi karşılaştırmak yerine . Konuyla başlayın, ardından onu karşılaştırılacak değerle başlayın.

Diğer bazı dillerde bu karşılaştırma stili daha kullanışlıdır.

Genel olarak eksik bir "=" işaretine karşı korunmak için, yazmanın null == objectyanlış bir savunma programlama eylemi olduğunu düşünüyorum . Bu özel kodun etrafından dolaşmanın daha iyi yolu, davranışı bir junit testi ile garanti etmektir. Unutmayın, olası bir "=" hatası, yöntemin girdi argümanlarına bağlı değildir - bu API'nin başkaları tarafından doğru kullanımına bağlı değilsiniz - bu nedenle, bunun yerine bir junit testi, buna karşı korunmak için mükemmeldir. Her neyse, davranışı doğrulamak için junit testleri yazmak isteyeceksiniz; eksik bir "=" doğal olarak kapsam dahilindedir.