object == null atau null == object?

Saya mendengar dari seseorang yang null == objectlebih baik daripada object == null cek

misal:

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

Apakah ada alasan atau ini mitos lain? Terimakasih atas bantuannya.

Ini mungkin kebiasaan yang dipelajari dari C, untuk menghindari kesalahan ketik semacam ini (tunggal =bukan ganda ==):

if (object = null) {

Konvensi meletakkan konstanta di sisi kiri ==tidak benar-benar berguna di Java karena Java mengharuskan ekspresi tersebut ifdievaluasi ke suatu booleannilai, jadi kecuali jika konstanta adalah a boolean, Anda akan mendapatkan kesalahan kompilasi dengan cara apa pun Anda meletakkan argumen. (dan jika itu boolean, Anda tidak boleh menggunakannya ==...)

Seperti yang dikatakan orang lain, itu adalah kebiasaan yang dipelajari dari C untuk menghindari kesalahan ketik - meskipun bahkan di C saya mengharapkan kompiler yang layak pada tingkat peringatan yang cukup tinggi untuk memberikan peringatan. Seperti yang dikatakan Chandru, membandingkan dengan null di Java dengan cara ini hanya akan menimbulkan masalah jika Anda menggunakan variabel tipe Boolean(yang tidak ada dalam kode sampel). Saya akan mengatakan itu adalah situasi yang sangat langka, dan bukan situasi yang perlu diubah cara Anda menulis kode di tempat lain. (Saya tidak akan repot-repot membalik operan bahkan dalam kasus ini; jika saya berpikir cukup jernih untuk mempertimbangkan membalikkannya, saya yakin saya bisa menghitung tanda sama dengan.)

Apa yang belum disebutkan adalah bahwa banyak orang (termasuk saya sendiri) menganggap if (variable == constant)formulir lebih mudah dibaca - ini cara yang lebih alami untuk mengekspresikan diri. Ini adalah alasan untuk tidak secara membabi buta menyalin konvensi dari C. Anda harus selalu mempertanyakan praktik (seperti yang Anda lakukan di sini :) sebelum mengasumsikan bahwa apa yang mungkin berguna di satu lingkungan berguna di lingkungan lain.

Ini tidak banyak nilainya di Java (1.5+) kecuali jika tipe objeknya adalah Boolean. Dalam hal ini, ini masih bisa berguna.

if (object = null)tidak akan menyebabkan kegagalan kompilasi di Java 1.5+ jika objek adalah Booleantetapi akan menampilkannya NullPointerExceptionsaat runtime.

Di Jawa tidak ada alasan yang bagus.

Beberapa jawaban lain menyatakan bahwa itu karena Anda dapat secara tidak sengaja menjadikannya tugas alih-alih persamaan. Tapi di Java, Anda harus memiliki boolean di if, jadi ini:

if (o = null)

tidak akan dikompilasi.

Satu-satunya saat ini bisa menjadi masalah di Java adalah jika variabelnya adalah boolean:

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

Ini juga terkait erat dengan:

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

yang nyaman jika Anda tidak ingin berurusan dengan NPE:

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

Trik ini dimaksudkan untuk mencegah salah v = nullketik.

Tetapi Java hanya mengizinkan ekspresi boolean sebagai if()kondisi sehingga trik tidak masuk akal, compiler akan tetap menemukan kesalahan ketik tersebut.

Ini masih trik yang berharga untuk kode C / C ++.

Untuk alasan yang sama Anda melakukannya di C; assignment adalah ekspresi, jadi Anda meletakkan literal di sebelah kiri sehingga Anda tidak dapat menimpanya jika Anda tidak sengaja menggunakannya, =bukan ==.

Itu untuk orang yang lebih suka memiliki konstanta di sisi kiri. Dalam kebanyakan kasus, memiliki konstanta di sisi kiri akan mencegah NullPointerException dilempar (atau memiliki nullcheck lain). Misalnya metode String sama dengan melakukan pemeriksaan nol. Memiliki konstanta di sebelah kiri, akan mencegah Anda menulis cek tambahan. Yang mana, cara lain juga dilakukan nanti. Memiliki nilai nol di sebelah kiri hanya menjadi konsisten.

Suka:

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

Ini adalah kondisi Yoda yang menulis dengan cara yang berbeda

Di java

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

kondisi yoda

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

Bandingkan dengan kode berikut:

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

Output (Setelah beberapa eksekusi):

null != pingResult
325737
pingResult != null
47027

Oleh karena itu, pingResult != nulladalah pemenangnya.

Karena sifat komutatifnya , satu-satunya perbedaan antara object == nulldan null == object( versi Yoda ) adalah pada sifat kognitif : bagaimana kode dibaca dan dicerna oleh pembaca. Saya tidak tahu jawaban pasti, tapi saya tahu saya secara pribadi lebih suka membandingkan objek yang saya periksa dengan sesuatu yang lain, daripada membandingkan sesuatu yang lain dengan objek yang saya periksa , jika itu masuk akal. Mulailah dengan subjeknya, lalu nilai untuk membandingkannya.

Dalam beberapa bahasa lain gaya perbandingan ini lebih berguna.

Untuk melindungi dari tanda "=" yang hilang secara umum, menurut saya menulis null == objectadalah tindakan pemrograman defensif yang salah arah . Cara yang lebih baik untuk mengatasi kode khusus ini adalah dengan menjamin perilakunya dengan uji junit. Ingat, kemungkinan kesalahan kehilangan "=" tidak bergantung pada argumen input metode - Anda tidak bergantung pada penggunaan yang benar dari API ini oleh orang lain - jadi pengujian junit sempurna untuk melindungi dari itu. Bagaimanapun Anda akan ingin menulis tes junit untuk memverifikasi perilaku; "=" yang hilang secara alami berada dalam cakupan.