Objekt == null oder null == Objekt?

Ich habe von jemandem null == objectgehört, der besser ist als zu object == null überprüfen

z.B :

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

Gibt es Gründe oder ist dies ein anderer Mythos? Danke für die Hilfe.

Dies ist wahrscheinlich eine Gewohnheit, die von C gelernt wurde, um diese Art von Tippfehler zu vermeiden (einfach =statt doppelt ==):

if (object = null) {

Die Konvention, die Konstante auf die linke Seite von zu setzen, ==ist in Java nicht wirklich nützlich, da Java erfordert, dass der Ausdruck in einer ifAuswertung einen booleanWert ergibt. Wenn die Konstante also nicht a ist boolean, wird in beiden Fällen ein Kompilierungsfehler angezeigt Argumente. (und wenn es ein Boolescher Wert ist, sollten Sie ihn ==sowieso nicht verwenden ...)

Wie andere gesagt haben, ist es eine Gewohnheit von C, Tippfehler zu vermeiden - obwohl ich selbst in C anständige Compiler mit ausreichend hohen Warnstufen erwarten würde, um eine Warnung zu geben. Wie Chandru sagt, würde ein Vergleich mit null auf Java auf diese Weise nur dann Probleme verursachen, wenn Sie eine Variable vom Typ verwenden Boolean(die nicht im Beispielcode enthalten ist). Ich würde sagen, das ist eine ziemlich seltene Situation und keine, für die es sich lohnt, die Art und Weise zu ändern, wie Sie überall Code schreiben. (Ich würde mich auch in diesem Fall nicht darum kümmern, die Operanden umzukehren. Wenn ich klar genug denke, um sie umzukehren, kann ich sicher die Gleichheitszeichen zählen.)

Was nicht erwähnt wurde, ist, dass viele Leute (ich selbst sicherlich eingeschlossen) das if (variable == constant)Formular besser lesbar finden - es ist eine natürlichere Art, sich auszudrücken. Dies ist ein Grund , eine Konvention nicht blind aus C zu kopieren. Sie sollten Praktiken immer in Frage stellen (wie Sie es hier tun :), bevor Sie davon ausgehen, dass das, was in einer Umgebung nützlich sein kann, in einer anderen nützlich ist.

Dies ist in Java (1.5+) nur dann von großem Wert, wenn der Objekttyp ist Boolean. In diesem Fall kann dies immer noch nützlich sein.

if (object = null)verursacht in Java 1.5+ keinen Kompilierungsfehler, wenn das Objekt ein ist Boolean, würde aber NullPointerExceptionzur Laufzeit ein auslösen .

In Java gibt es keinen guten Grund.

Ein paar andere Antworten haben behauptet, dass es daran liegt, dass Sie versehentlich eine Zuordnung anstelle von Gleichheit vornehmen können. Aber in Java muss ein Boolescher Wert in einem if enthalten sein.

if (o = null)

wird nicht kompiliert.

In Java kann dies nur dann von Bedeutung sein, wenn die Variable boolesch ist:

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

Dies hängt auch eng zusammen mit:

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

Das ist praktisch, wenn Sie sich nicht mit NPEs befassen möchten:

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

Dieser Trick soll verhindern v = null Tippfehler verhindern.

Java erlaubt aber nur boolesche Ausdrücke als if() Bedingungen, so dass ein Trick nicht viel Sinn macht. Der Compiler findet diese Tippfehler trotzdem.

Es ist jedoch immer noch ein wertvoller Trick für C / C ++ - Code.

Aus dem gleichen Grund machst du es in C; Zuweisung ist ein Ausdruck, daher setzen Sie das Literal links, damit Sie es nicht überschreiben können, wenn Sie es versehentlich =anstelle von verwenden ==.

Das ist für Leute, die es vorziehen, die Konstante auf der linken Seite zu haben. In den meisten Fällen verhindert die Konstante auf der linken Seite, dass die NullPointerException ausgelöst wird (oder dass ein anderer Nullcheck ausgeführt wird). Zum Beispiel führt die String-Methode gleich auch eine Nullprüfung durch. Wenn Sie die Konstante links haben, können Sie den zusätzlichen Scheck nicht ausstellen. Was auf andere Weise auch später durchgeführt wird. Der Nullwert links ist nur konsistent.

mögen:

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

Es ist eine Yoda-Bedingung, die auf unterschiedliche Weise schreibt

In Java

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

Yoda Zustand

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

Vergleichen Sie mit folgendem Code:

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

Ausgabe (nach mehreren Ausführungen):

null != pingResult
325737
pingResult != null
47027

Daher pingResult != nullist der Gewinner.

Aufgrund seiner kommutativen Eigenschaft ist der einzige Unterschied zwischen object == nullund null == object(der Yoda-Version ) kognitiver Natur : wie der Code vom Leser gelesen und verdaut wird. Ich kenne die endgültige Antwort zwar nicht, aber ich weiß, dass ich es persönlich vorziehe , das Objekt, das ich inspiziere, mit etwas anderem zu vergleichen, anstatt etwas anderes mit dem Objekt zu vergleichen, das ich inspiziere , wenn dies Sinn macht. Beginnen Sie mit dem Thema und dann mit dem Wert, mit dem Sie es vergleichen möchten.

In einigen anderen Sprachen ist dieser Vergleichsstil nützlicher.

Um sich vor einem fehlenden "=" - Zeichen im Allgemeinen zu schützen, halte ich das Schreiben null == objectfür einen fehlgeleiteten Akt der defensiven Programmierung . Der bessere Weg, um diesen bestimmten Code zu umgehen, besteht darin, das Verhalten mit einem Junit-Test zu garantieren. Denken Sie daran, dass der mögliche Fehler, ein "=" zu verpassen, nicht von den Eingabeargumenten der Methode abhängt - Sie sind nicht von der richtigen Verwendung dieser API durch andere Personen abhängig -, sodass ein Junit-Test perfekt ist, um sich stattdessen davor zu schützen. Auf jeden Fall sollten Sie Junit-Tests schreiben, um das Verhalten zu überprüfen. Ein fehlendes "=" fällt natürlich in den Geltungsbereich.