Vermeiden! = Null-Anweisungen

Diese für mich klingt wie ein einigermaßen verbreitetes problem, das junior-intermediate-Entwickler dazu neigen zu Gesicht, an einem gewissen Punkt: Sie sind entweder nicht wissen, oder Vertrauen Sie nicht auf die Verträge, die Sie beteiligt sind und defensiv overcheck für null-Werte. Darüber hinaus, wenn Sie Ihren eigenen code schreiben, Sie verlassen sich auf die RÜCKFÜHRUNG von null, um anzuzeigen, etwas, so dass der Anrufer-check für null-Werte.

Setzen einen anderen Weg, es gibt zwei Fälle, in denen null-Prüfung kommt:

1. Wo null ist eine gültige Antwort in Bezug auf den Vertrag; und

2. Wo es nicht eine gültige Antwort.

(2) ist einfach. Entweder assert Aussagen (assertions) oder erlauben Fehler (zum Beispiel, NullPointerException). Behauptungen sind eine sehr wenig genutzte Java-Funktion, die Hinzugefügt wurde, die in 1.4. Die syntax ist:

assert <condition>

oder

assert <condition> : <object>

wo <condition> ist ein boolescher Ausdruck, und der <object> ist ein Objekt, dessen toString() Methode die Ausgabe wird in die error.

Einer assert - Anweisung löst eine Error ( AssertionError ), wenn die Bedingung nicht wahr ist. Standardmäßig wird, ignoriert Java-assertions. Sie können Behauptungen durch übergeben der option -ea auf der JVM. Sie können aktivieren und deaktivieren von assertions für einzelne Klassen und Pakete. Dies bedeutet, dass Sie überprüfen kann, code mit den Behauptungen, die während der Entwicklung und Erprobung, und deaktivieren Sie Sie in einer Produktionsumgebung, obwohl meine Tests gezeigt hat weiter keine Auswirkungen auf die Leistung von Behauptungen.

Nicht mit Behauptungen, die in diesem Fall OK ist, weil der code einfach nur fail, das ist, was passieren wird, wenn Sie Behauptungen. Der einzige Unterschied ist, dass mit Behauptungen, es könnte früher geschehen, in die eine weitere sinnvolle Art und Weise und möglicherweise mit zusätzlichen Informationen, die Ihnen helfen können, um herauszufinden, warum es passiert ist, wenn du nicht erwartet hast.

(1) ist ein wenig härter. Wenn Sie keine Kontrolle über den code, den Sie hier aufrufen dann sind Sie stecken. Wenn der Wert null ist eine gültige Antwort, die Sie haben zu prüfen.

Wenn es der code, dass Sie die Kontrolle, allerdings (und das ist oft der Fall), dann ist es eine andere Geschichte. Vermeiden Sie die Verwendung von null-Werten als eine Antwort. Mit Methoden, die Rückkehr der Sammlungen ist es ganz einfach: Rückkehr leer Sammlungen (oder arrays) anstelle von null-Werten so ziemlich die ganze Zeit.

Mit nicht-Sammlungen könnte es schwieriger werden. Betrachten Sie dies als ein Beispiel: wenn Sie über diese Schnittstellen:

public interface Action {
  void doSomething();
}

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

wo Parser nimmt raw user input und findet etwas zu tun, vielleicht wenn Sie Umsetzung ein command line interface für etwas. Nun könnte man den Vertrag machen, dass es null zurück, wenn keine geeigneten Maßnahmen. Führt, dass die null-überprüfen Sie reden.

Ist eine alternative Lösung niemals null zurück, und stattdessen die Null-Objekt-pattern:

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

Vergleichen:

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

zu

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

ist eine viel bessere design, da es führt zu kürzeren code.

Sagte, vielleicht ist es völlig angemessen für die findAction () - Methode löst eine Ausnahme mit einer bedeutungsvollen Fehlermeldung-vor allem in diesem Fall, wo Sie sich auf user-input. Es wäre viel besser für die findAction Methode eine Exception werfen, als für die aufrufende Methode zu sprengen, mit einem einfachen NullPointerException ohne Erklärung.

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

Oder wenn Sie denken, dass der try/catch Mechanismus ist so hässlich, anstatt Nichts Tun Sie Ihre Standard-Aktion sollte feedback für die Benutzer.

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

InformationsquelleAutor der Antwort

Wenn null-Werte sind nicht erlaubt

Wenn Ihr Methode wird aufgerufen, extern, beginnen Sie mit etwas wie dieses:

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

Dann in den rest der Methode, Sie wissen, dass object ist nicht null.

Wenn es eine interne Methode (nicht Teil einer API), die einfach nur dokumentieren, dass es nicht null sein darf, und das ist es.

Beispiel:

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

Jedoch, wenn Ihre Methode einfach übergibt den Wert an, und die nächste Methode geht es bei der etc. es könnte problematisch. In diesem Fall möchten Sie vielleicht zu prüfen, das argument wie oben.

Wenn der Wert null ist erlaubt

Diese wirklich hängt. Wenn Sie finden, dass ich oft etwas wie das hier tun:

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

Also ich Zweig, und tun, zwei völlig verschiedene Dinge. Es gibt keine hässlichen code-snippet, weil ich wirklich brauchen, um zu tun, zwei verschiedene Dinge, je nach Daten. Zum Beispiel sollte ich die Arbeit am Eingang, oder sollte ich berechnen, ein guter Standard-Wert?

Es ist eigentlich selten für mich zu verwenden die Redewendung "if (object != null && ...".

Kann es einfacher sein, geben Sie Beispiele, wenn Sie Beispiele, wo Sie in der Regel verwenden die Redewendung.

InformationsquelleAutor der Antwort

Wenn Undefinierte Werte sind nicht zulässig:

Könnten Sie konfigurieren Ihre IDE, um Sie zu warnen, über mögliche null-Dereferenzierung. E. g. in Eclipse finden Sie Einstellungen - > Java - > Compiler > Fehler/Warnungen/Null Analyse.

Wenn Undefinierte Werte sind zulässig:

Wenn Sie wollen, definieren Sie eine neue API, wo Undefinierte Werte sinnvollverwenden Sie die Option Muster (vielleicht bekannt aus funktionalen Sprachen). Es hat die folgenden Vorteile:

• Es ist ausdrücklich in der API, ob ein Eingang oder Ausgang vorhanden ist oder nicht.
• Der compiler erzwingt die Behandlung der "Undefinierte" der Fall.
• Option ist eine Monadeso gibt es keine Notwendigkeit für die ausführliche null überprüfen, nutzen Sie einfach anzeigen/foreach/getOrElse oder eine ähnliche combinator sicher verwenden Sie den Wert (Beispiel).

Java 8 hat eine eingebaute Optional Klasse (empfohlen); für die früheren Versionen gibt es alternativen Bibliothek, zum Beispiel Guave's Optional oder FunctionalJava's - Option. Aber wie viele funktionelle Stil-Muster, mit der Option in Java (auch 8) Ergebnisse in geraumer boilerplate, das Sie reduzieren können, mit einem weniger ausführlichen JVM-Sprache z.B. Scala oder Xtend.

Wenn man mit einer API, die möglicherweise return nullSie können nicht viel in Java. Xtend und Groovy haben die Elvis-operator ?: und die null-safe-dereference operator ?.aber beachten Sie, dass dies gibt null zurück, wenn ein null-Verweis ist, so ist es nur "verzögert" der richtige Umgang mit der null.

InformationsquelleAutor der Antwort

Mit Java 8 kommt die neue java.util.Optional Klasse, löst wohl einige das problem. Man kann zumindest sagen, dass es verbessert die Lesbarkeit des Codes, und im Fall von öffentlichen APIs der API-Vertrag klarer an die client-Entwickler.

Arbeiten Sie so:

Ein optionales Objekt für einen gegebenen Typ (Fruit) erstellt, wie Sie den Rückgabetyp einer Methode. Es kann leer sein oder Sie enthalten eine Fruit Objekt:

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

Schauen Sie sich jetzt diesen code, wo wir suchen, eine Liste von Fruit (fruits) für einen bestimmten Obst-Instanz:

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

Können Sie die map() operator zum durchführen einer Berechnung auf--oder extrahieren Sie einen Wert aus--ein optionales Objekt. orElse() können Sie ein fallback für fehlende Werte.

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

Natürlich, die Prüfung auf null/leer-Wert ist immer noch notwendig, aber zumindest der Entwickler ist sich bewusst, dass der Wert kann leer sein und das Risiko des Vergessens zu prüfen, ist begrenzt.

In eine API von Grund auf neu gebaut mit Optional wenn ein Rückgabewert kann leer sein, und die Rückgabe einer einfachen Objekt nur, wenn es nicht null (convention), der client-code aufgeben null prüft auf einfache Objekt Rückgabewerte...

Natürlich Optional könnte auch verwendet werden, als eine Methode, argument, vielleicht ein besserer Weg, um optionale Argumente anzugeben, als 5 oder 10 überladen von Methoden in einigen Fällen.

Optional bietet weitere praktische Methoden, wie orElsedass die Verwendung von einen Standard-Wert, und ifPresent funktioniert mit lambda-Ausdrücke.

Ich lade Sie ein, diesen Artikel zu Lesen (meine wichtigste Quelle für das schreiben dieser Antwort), in dem die NullPointerException (und im Allgemeinen null-Zeiger) ebenso problematisch wie die (Teil -) Lösung gebracht, indem Optional sind gut erklärt: Java Optionale Objekte.

InformationsquelleAutor der Antwort

• Wenn Sie erwägen, ein Objekt sollte nicht null sein (oder es ist ein bug) verwenden Sie assert.
• Wenn Ihre Methode nicht akzeptieren, null, params sagen, dass es in der javadoc und verwenden Sie eine assert.

Haben Sie zu prüfen, Objekt != null nur, wenn Sie wollen, um den Fall behandeln, wo das Objekt kann null sein...

Es ist ein Vorschlag, um neue Annotationen in Java7 zu helfen, mit null /notnull params:
http://tech.puredanger.com/java7/#jsr308

InformationsquelleAutor der Antwort

Manchmal, Sie haben Methoden, die auf seine Parameter definieren, dass ein symmetrischer Betrieb:

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

Wenn Sie wissen, b kann nie null sein, Sie können nur tauschen. Es ist besonders nützlich für gleich:
Statt foo.equals("bar"); besser machen "bar".equals(foo);.

InformationsquelleAutor der Antwort

Eher als Null-Objekt-Pattern -- das hat auch seinen nutzen -- Sie sollten erwägen, Situationen, in denen das null-Objekt ist ein bug.

Wenn die Ausnahme ausgelöst wird, prüfen Sie die Stapel-Ablaufverfolgung, und arbeiten Sie durch den bug.

InformationsquelleAutor der Antwort

Null ist nicht ein "problem". Es ist ein integraler Teil eines komplett Modellierung-Werkzeug-set. Software soll-Modell die Komplexität der Welt und null trägt seine Last. Null bedeutet 'Keine Daten' oder 'Unbekannt' in Java und dergleichen. So ist es angebracht, die null-Werte für diese Zwecke. Ich glaube nicht, lieber die 'Null-Objekt' Muster; ich denke, es erheben sich die 'wer wird Wache
die Wächter' problem.

Wenn Sie mich Fragen, was ist der name meiner Freundin werde ich sagen, ich hätte keine Freundin. In der Java-Sprache werde ich wieder null.
Wäre eine alternative zu werfen sinnvolle Ausnahme an einige problem, die können nicht (oder wollen nicht) gelöst und delegieren Sie irgendwo im Stapel höher zu wiederholen oder Bericht Daten zugreifen Fehlermeldung an den Benutzer ausgegeben.

1. Für eine 'unknown' 'unknown answer". (Null-sicher ist, wo das ist richtig, aus unternehmerischer Sicht) Prüfen Argumente auf null, sobald innerhalb einer Methode vor der Benutzung entlastet mehrere Anrufer prüfen Sie vor einem Anruf.

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

   Vorherigen führt zu normalen logic flow zu bekommen, kein Foto von einer nicht vorhandenen Freundin aus meiner Foto-Bibliothek.

   getPhotoOfThePerson(me.getGirlfriend())

   Ist und es passt mit den neuen kommenden Java-API (freu)

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

   Es ist zwar eher "normal business flow" nicht zu finden Foto, gespeichert in der DB für einige Personen, die ich verwendet, um zu verwenden Paare wie unten für einige andere Fälle

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

   - Und nicht ungern-Typ <alt> + <shift> + <j> (generieren von javadoc in Eclipse) und schreiben Sie drei weitere Worte, die für Sie die öffentliche API. Dies wird mehr als genug für alle, aber diejenigen, die keine Dokumentation Lesen.

   /**
    * @return photo or null
    */

   oder

   /**
    * @return photo, never null
    */

2. Diesem eher theoretischen Fall, und in den meisten Fällen sollte man lieber java null-sichere API (falls es freigegeben wird in weiteren 10 Jahren), aber NullPointerException ist Unterklasse einer Exception. So ist es eine form der Throwable zeigt, dass Bedingungen, die eine angemessene Anwendung zu fangen (javadoc)! Die meisten Vorteile von Ausnahmen und separaten error-handling-code von "normalen" code (laut Schöpfer von Java) es ist angebracht, als für mich, zu fangen NullPointerException.

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

   Fragen, die entstehen könnten:

   Q. Was ist, wenn getPhotoDataSource() null zurück?
   
   A. Es ist bis zu business-Logik. Wenn ich es nicht finde ein Fotoalbum zeige ich Euch keine Fotos. Was ist, wenn appContext ist nicht initialisiert? Diese Methode ist die business logic stellt mit diesem. Wenn die gleiche Logik sollte strenger sein, dann werfen Sie eine Ausnahme, es ist Teil der business-Logik und explizite überprüfung auf null verwendet werden soll (Fall 3). Die neue Java-Null-sichere API passt hier besser angeben selektiv, was bedeutet-und was bedeutet nicht initialisiert werden werden fail-fast-im Falle der Programmierer Fehler.

   F. Redundanten code könnte ausgeführt werden und unnötig Ressourcen könnten ergriffen werden.
   
   A. Es stattfinden könnte, wenn getPhotoByName() würde versuchen, eine Datenbankverbindung zu öffnen, erstellen PreparedStatement und mit der person, die als Namen einen SQL-parameter. Der Ansatz für eine unbekannte Frage gibt eine unbekannte Antwort (Fall 1) hier funktioniert. Vor grabbing Ressourcen sollte die Methode überprüfen, Parameter und return 'unbekannt' Ergebnis, wenn nötig.

   F. Dieser Ansatz hat eine Leistungseinbuße aufgrund des try-Verschluss öffnen.
   
   A. Software sollte einfach zu verstehen und ändern zunächst. Erst danach könnte man über die Leistung, und nur, wenn nötig! und, wo nötig! (Quelle), und viele andere).

   PS. Dieser Ansatz wird als sinnvoll zu verwenden, da die separaten error-handling-code von "normalen" code grundsätzlich zumutbar ist, die Nutzung in irgendeinem Ort. Betrachten Sie das nächste Beispiel:

   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. Für diejenigen, die schnell zu downvote (und nicht so schnell zur Dokumentation Lesen) möchte ich sagen, dass ich nie erwischt einen null-Zeiger-Ausnahme (NPE) in meinem Leben. Aber diese Möglichkeit war absichtlich von den Java-Machern, weil NPE ist eine Unterklasse von Exception. Wir haben ein Beispiel in Java-Geschichte, wenn ThreadDeath ist ein Error nicht, weil es tatsächlich einen Fehler in einer Anwendung, aber nur weil es nicht beabsichtigt war, gefangen zu werden! Wie viel NPE passt ein Error als ThreadDeath! Ist es aber nicht.

3. Check für 'Keine Daten' nur, wenn die business-Logik impliziert.

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

   und

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

   Wenn appContext oder Datenquelle nicht initialisiert unbehandelte runtime NullPointerException töten, aktuellen thread und verarbeitet wird Thread.defaultUncaughtExceptionHandler (für Sie zu definieren, und verwenden Sie Ihre Lieblings-logger oder andere Benachrichtigung mechanizm). Wenn nicht gesetzt, ThreadGroup#uncaughtException drucken stacktrace auf system-err. Man sollte monitor application error log und öffnen Sie Jira-issue für jede nicht behandelte Ausnahme die in der Tat ist Anwendungsfehler. Programmierer sollten fix bug irgendwo in der Initialisierung Zeug.

InformationsquelleAutor der Antwort

Gemeinsames "problem" in Java in der Tat.

Erste, meine Gedanken dazu:

Ich denke, dass es schlecht ist, zu "Essen" etwas, wenn NULL übergeben wurde, wo NULL ist kein Gültiger Wert. Wenn Sie nicht beenden die Methode mit irgendeiner Art von Fehler es bedeutet dann, dass nichts schief ging in deiner Methode, die ist nicht wahr. Dann haben Sie wahrscheinlich null zurückgeben, in diesem Fall, und in der Empfänger-Methode, die Sie wieder auf null prüfen, und es endet nie, und Sie am Ende mit "if != null", etc..

So, IMHO, muss null sein, einen kritischen Fehler, der verhindert, dass weitere Ausführung (das ist, wo die null ist kein Gültiger Wert).

Die Art, wie ich dieses problem lösen kann, ist dies:

Ersten, Folge ich dieser Konvention:

1. Alle öffentlichen Methoden /API prüfen Sie stets Ihre Argumente für die null -
2. Alle private-Methoden nicht auf null prüfen, da Sie kontrolliert werden Methoden (nur sterben lassen mit nullpointer Ausnahme in Fall war es nicht behandelt oben)
3. Die nur andere Methoden, die nicht auf null prüfen sind utility-Methoden. Sie sind öffentlich, aber wenn Sie nennen Sie aus irgendeinem Grund, Sie wissen, welche Parameter Sie übergeben. Das ist wie der Versuch, Wasser zu Kochen, in den Kessel ohne Wasser...

Werden und schließlich in den code der ersten Zeile von der öffentlichen Methode geht so:

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

Beachten Sie, dass addParam() gibt selbst zu, so dass Sie hinzufügen können, mehr Parameter zu überprüfen.

Methode validate() werfen wird geprüft ValidationException wenn einer der Parameter null ist (aktiviert oder deaktiviert ist eher eine design - /Geschmacks-Frage, aber meine ValidationException aktiviert ist).

void validate() throws ValidationException;

Die Meldung enthält den folgenden text, wenn, zum Beispiel, "plant" ist null:

"Illegal argument den Wert null tritt für parameter [Pläne]"

Wie Sie sehen können, den zweiten Wert in die addParam () - Methode (string) wird benötigt für die Benutzer-Nachricht, weil Sie können leicht erkennen, die übergebene variable name, auch mit der Reflexion (nicht Gegenstand dieser post sowieso...).

Und ja, wir wissen, dass jenseits dieser Linie werden wir nicht mehr begegnen, wird ein null-Wert, so dass wir nur sicher aufrufen von Methoden auf diese Objekte.

Diese Weise, den code sauber, leicht wartbar und lesbar.

InformationsquelleAutor der Antwort

Neben der Verwendung assert können Sie die folgenden verwenden:

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

Dies ist leicht besser als:

if (someobject != null) {
    .....
    .....



    .....
}

InformationsquelleAutor der Antwort

Guave, ein sehr nützliches core-Bibliothek von Google, hat eine schöne und nützliche API zu vermeiden, die null-Werte. Ich finde UsingAndAvoidingNullExplained sehr hilfreich.

Wie in der wiki:

Optional<T> ist ein Weg, zu ersetzen, eine null-T reference mit einem
nicht-null-Wert. Optional kann entweder ein nicht-null-T reference
(in welchem Falle wir sagen, dass die Referenz "anwesend"), oder es kann enthalten
nichts (in welchem Falle wir sagen, dass der Verweis "nicht vorhanden"). Es ist nie
sagte zu "null enthalten."

Verwendung:

Optional<Integer> possible = Optional.of(5);
possible.isPresent(); //returns true
possible.get(); //returns 5

InformationsquelleAutor der Antwort

Ich mag die Artikel von Nat Pryce. Hier sind die links:

• Die Vermeidung von Null-Werten mit Polymorphen Versand
• Die Vermeidung von Null-Werten mit "Tell, Don 'T Ask" - Stil

In dem Artikel ist auch ein link auf ein Git-repository für Java Vielleicht Geben die ich interessant finde, aber ich glaube nicht, dass es allein reduziert werden kann, die
überprüfen von code aufblähen. Nach einigen Recherchen im Internet, ich denke,! = null code aufblasen könnte verringert werden, vor allem durch die sorgfältige Gestaltung.

InformationsquelleAutor der Antwort

Wahrscheinlich die beste alternative für Java 8 oder höher ist die Verwendung der Optional Klasse.

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

Dies ist besonders praktisch für lange Ketten von möglichen null-Werten. Beispiel:

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

Beispiel, wie throw Ausnahme auf null:

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

Java 7 eingeführt, die - Objekten.requireNonNull Methode praktisch sein kann, wenn etwas überprüft werden soll, für nicht-nullness. Beispiel:

String lowerVal = Objects.requireNonNull(someVar, "input cannot be null or empty").toLowerCase();

InformationsquelleAutor der Antwort

Ich sehr ignorieren Antworten, die nahelegen, dass mit den null-Objekten in jeder situation. Dieses Muster kann den Vertrag zu brechen und bury Probleme tiefer und tiefer, anstatt Sie zu lösen, nicht zu erwähnen, dass unsachgemäß verwendet wird, erstellen Sie eine weitere Stapel von boilerplate-code, die verlangen, dass zukünftige Wartung.

In der Realität, wenn etwas von einer Methode zurückgegebenen null sein kann, und der aufrufende code hat, um Entscheidung zu treffen, auf, dass, sollte es einen früheren Aufruf sorgt dafür, dass der Staat.

Beachten Sie auch, dass die null-Objekt-pattern-Speicher-hungrig, wenn verwendet, ohne Pflege. Für diese - die Instanz einer NullObject sollte geteilt werden zwischen den Eigentümern, und nicht eine unigue-Instanz für jede dieser stellen.

Ich würde auch nicht empfehlen, mit diesem Muster, wo der Typ ist dazu gedacht, eine primitive Darstellung - wie mathematische Entitäten, die nicht-Skalare: Vektoren, Matrizen, komplexe zahlen und POD(Plain Old Data) Objekte, die dazu gedacht sind, halten Staat in form von Java-built-in-Typen. Im letzteren Fall würden Sie am Ende ruft getter-Methoden mit beliebigen Ergebnissen. Zum Beispiel, was sollte ein NullPerson.getName () - Methode zurückgeben?

Ist es eine überlegung Wert solche Fälle, um zu vermeiden, absurde Ergebnisse.

InformationsquelleAutor der Antwort

Dies ist der häufigste Fehler für die meisten Entwickler.

Wir haben die Anzahl der Möglichkeiten, dies zu behandeln.

Ansatz 1:

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

notNull(Object Object, String message)

Ansatz 2:

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

Ansatz 3:

@isNull @Nullable  //using annotation based validation

Ansatz 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;
}

InformationsquelleAutor der Antwort