obiekt == null lub null == obiekt?

Słyszałem od kogoś, że null == objectjest to lepsze niż object == null sprawdzanie

np .:

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

Czy są jakieś powody, czy to kolejny mit? Dzięki za pomoc.

Jest to prawdopodobnie nawyk wyuczony od C, aby uniknąć tego rodzaju literówki (pojedyncza =zamiast podwójna ==):

if (object = null) {

Konwencja umieszczania stałej po lewej stronie ==nie jest tak naprawdę przydatna w Javie, ponieważ Java wymaga, aby wyrażenie w ifewaluacji miało booleanwartość, więc jeśli stała to a boolean, wystąpiłby błąd kompilacji w każdym przypadku argumenty. (a jeśli jest to wartość logiczna, i tak nie powinieneś jej używać ==...)

Jak powiedzieli inni, jest to nawyk, którego nauczył się od C, aby unikać literówek - chociaż nawet w C spodziewałbym się przyzwoitych kompilatorów na wystarczająco wysokich poziomach ostrzegawczych, aby dać ostrzeżenie. Jak mówi Chandru, porównywanie z null w Javie w ten sposób spowodowałoby problemy tylko wtedy, gdybyś używał zmiennej typu Boolean(której nie ma w przykładowym kodzie). Powiedziałbym, że to dość rzadka sytuacja i nie taka, dla której warto zmieniać sposób pisania kodu w innych miejscach. (Nie zawracałbym sobie głowy odwracaniem operandów nawet w tym przypadku; jeśli myślę wystarczająco jasno, aby rozważyć ich odwrócenie, jestem pewien, że mogę policzyć znaki równości).

Co nie zostało wspomniane jest, że wielu ludzi (ja na pewno w zestawie) znaleźć if (variable == constant)formularz, aby być bardziej czytelny - jest to bardziej naturalny sposób wyrażania siebie. Jest to powód, dla którego nie należy ślepo kopiować konwencji z C. Zawsze powinieneś kwestionować praktyki (tak jak to robisz tutaj :), zanim założysz, że to, co może być przydatne w jednym środowisku, jest przydatne w innym.

Nie ma to dużej wartości w Javie (1.5+), z wyjątkiem sytuacji, gdy typ obiektu to Boolean. W takim przypadku może to być nadal przydatne.

if (object = null)nie spowoduje błędu kompilacji w Javie 1.5+, jeśli obiekt jest, Booleanale wyrzuci NullPointerExceptionw czasie wykonywania.

W Javie nie ma dobrego powodu.

Kilka innych odpowiedzi twierdziło, że dzieje się tak, ponieważ możesz przypadkowo przypisać to zadanie zamiast równości. Ale w Javie musisz mieć wartość logiczną w if, więc to:

if (o = null)

nie będzie się kompilować.

W Javie może to mieć znaczenie tylko wtedy, gdy zmienna ma wartość logiczną:

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

Dotyczy to również ściśle:

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

co jest wygodne, jeśli nie chcesz zajmować się NPE:

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

Ta sztuczka miała zapobiec v = nullrodzajom literówek.

Ale Java dopuszcza tylko wyrażenia boolowskie jako if()warunki, więc sztuczka nie ma większego sensu, kompilator i tak znajdzie te literówki.

Jest to jednak nadal cenna sztuczka dla kodu C / C ++.

Z tego samego powodu robisz to w C; przypisanie jest wyrażeniem, więc umieszczasz literał po lewej stronie, aby nie można go było nadpisać, jeśli przypadkowo użyjesz =zamiast ==.

To jest dla osób, które wolą mieć stałą po lewej stronie. W większości przypadków posiadanie stałej po lewej stronie uniemożliwi zgłoszenie wyjątku NullPointerException (lub innego sprawdzania wartości null). Na przykład metoda String równa się również sprawdza wartość null. Posiadanie stałej po lewej stronie uniemożliwi wypisanie dodatkowego czeku. Który w inny sposób jest również wykonywany później. Posiadanie wartości null po lewej stronie jest po prostu spójne.

lubić:

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

Jest to warunek Yody piszący w inny sposób

W java

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

stan jody

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

Porównaj z następującym kodem:

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

Wyjście (po wielu wykonaniach):

null != pingResult
325737
pingResult != null
47027

Dlatego pingResult != nulljest zwycięzcą.

Ze względu na swoją przemienność jedyna różnica między object == nulla null == object( wersja Yoda ) ma charakter poznawczy : w jaki sposób kod jest czytany i trawiony przez czytelnika. Nie znam jednak ostatecznej odpowiedzi, ale wiem, że osobiście wolę porównywać badany obiekt z czymś innym niż porównywać coś innego z obiektem, który sprawdzam , jeśli to ma jakiś sens. Zacznij od tematu, a następnie wartości, z którą chcesz go porównać.

W niektórych innych językach ten styl porównywania jest bardziej przydatny.

Aby jednak ogólnie ustrzec się przed brakującym znakiem „=”, myślę, że pisanie null == objectjest błędnym działaniem programowania obronnego . Lepszym sposobem obejścia tego konkretnego kodu jest zagwarantowanie zachowania za pomocą testu junit. Pamiętaj, możliwy błąd polegający na pominięciu „=” nie jest zależny od argumentów wejściowych metody - nie jesteś zależny od właściwego użycia tego API przez inne osoby - więc test junit jest idealny, aby się przed tym zabezpieczyć. W każdym razie będziesz chciał napisać testy junit, aby zweryfikować zachowanie; brakujący „=” naturalnie mieści się w zakresie.