Nullanmerkungen verwenden

NullPointerException ist eine der häufigsten Ursachen für das Fehlschlagen von Java-Programmen. In den einfachsten Fällen kann der Compiler Sie direkt warnen, wenn er Code feststellt, der wie folgt aussieht:

    Object o = null;
    String s = o.toString();

Bei Verzweigungen und Schleifen und der Auslösung von Ausnahmebedingungen wird eine relativ komplexe Ablaufanalyse erforderlich, damit ermittelt werden kann, ob einer Variablen, deren Verweis aufgehoben wird, ein Null- oder Nicht-Nullwert für bestimmte oder alle Pfade innerhalb des Programms zugeordnet wurde.

Aufgrund der inhärenten Komplexität sollten Sie die Ablaufanalyse in kleinen Blöcken durchführen. Die Analyse einer Methode nach der anderen kann mit einer guten Leistung des Tools ausgeführt werden, wohingegen eine Analyse des gesamten Systems vom Eclipse-Java-Compiler nicht bewältigt werden kann. Der Vorteil ist, dass die Analyse schnell ist und schrittweise so ausgeführt werden kann, dass der Compiler Sie direkt während der Eingabe über auftretende Probleme warnen kann. Der Nachteil besteht darin, dass die Analyse nicht feststellen kann, welche Werte (Null- oder Nicht-Nullwerte) zwischen den Methoden (als Parameter und Rückgabewerte) ausgetauscht werden.

Interprozedurale Nullanalyse

Bei dieser Analyse werden Nullanmerkungen verwendet. Wenn Sie einen Methodenparameter als @NonNull angeben, können Sie dem Compiler mitteilen, dass Sie keinen Nullwert an dieser Position verwenden möchten.

    String capitalize(@NonNull String in) {
        return in.toUpperCase();                // no null check required
    }
    void caller(String s) {
        if (s != null)
            System.out.println(capitalize(s));  // preceding null check is required
    }

In Bezug auf Design by Contract hat dies zwei Seiten:

  1. Es ist die Verantwortlichkeit des aufrufenden Moduls, dass niemals ein Nullwert übergeben wird. Diese Zielsetzung wird sichergestellt, indem eine explizite Nullüberprüfung durchgeführt wird.
  2. Das Implementierungselement der Methode capitalize hat die Garantie, dass das Argument in nicht den Wert null annimmt und dass deshalb der Verweis ohne eine Nullüberprüfung aufgehoben werden kann.

Für Methodenrückgabewerte ist die Situation symmetrisch:

    @NonNull String getString(String maybeString) {
        if (maybeString != null)
            return maybeString;                         // the above null check is required
        else
            return "<n/a>";
    }
    void caller(String s) {
        System.out.println(getString(s).toUpperCase()); // no null check required
    }
  1. Nun muss das Implementierungselement sicherstellen, dass niemals der Wert null zurückgegeben wird.
  2. Umgekehrt hat das aufrufende Modul nun die Garantie, dass das Aufheben des Verweises für das Methodenergebnis ohne eine Überprüfung OK ist.

Verfügbare Anmerkungen

Der Eclipse-Java-Compiler kann so konfiguriert werden, dass drei unterschiedliche Anmerkungstypen für die erweiterte Nullanalyse (standardmäßig inaktiviert) verwendet werden:

Die Anmerkungen @NonNull und @Nullable werden an den folgenden Positionen unterstützt:

@NonNullByDefault wird unterstützt für die folgenden Elemente:

Beachten Sie, dass sogar die eigentlichen qualifizierten Namen dieser Anmerkungen konfigurierbar sind, dass jedoch standardmäßig die oben angegebenen Namen (aus dem Paket org.eclipse.jdt.annotation) verwendet werden.

Setup des Buildpfads

Eine JAR-Datei mit standardmäßigen Nullanmerkungen wird mit Eclipse in eclipse/plugins/org.eclipse.jdt.annotation_*.jar geliefert. Diese JAR-Datei muss sich beim Kompilieren im Buildpfad befinden, dies ist jedoch während der Laufzeit nicht erforderlich. (Aus diesem Grund müssen Sie die Komponente nicht an die Benutzer Ihres kompilierten Codes senden.)

Es gibt zwei Schnellkorrekturen für nicht aufgelöste Verweise auf @NonNull, @Nullable oder @NonNullByDefault, mit denen die JAR-Datei zum Buildpfad hinzugefügt wird:

Interpretation von Nullanmerkungen

Es sollte klar sein, dass Nullanmerkungen weitere Informationen zu Ihrem Java-Programm hinzufügen können (das dann vom Compiler verwendet werden kann, um bessere Warnungen auszugeben). Allerdings muss geklärt werden, welche Inhalte diese Anmerkungen haben sollen. Unter pragmatischen Gesichtspunkten gibt es mindestens drei Ebenen von Informationen, die mit Nullanmerkungen ausgedrückt werden sollen:

  1. Sporadische Hinweise für den Leser (Benutzer oder Compiler).
  2. Design by Contract: API-Spezifikation für einzelne oder für alle Methoden.
  3. Vollständige Spezifikation mit erweitertem Typsystem.

Für (1) können Sie ohne weitere Vorbereitung mit der Verwendung von Nullanmerkungen beginnen und müssen auch die folgenden Informationen nicht lesen. Allerdings sollten Sie in diesem Fall nicht mehr als kurze Hinweise in sporadischen Abständen erwarten. Zu den anderen Ebenen sind weiterführende Erläuterungen erforderlich.

Design by Contract: API-Spezifikation

Auf den ersten Blick bedeutet die Verwendung von Nullanmerkungen für API-Spezifikationen in Hinblick auf Design by Contract (DbC) lediglich, dass die Signaturen aller API-Methoden vollständig mit Anmerkungen versehen sein sollten. Mit Ausnahme der primitiven Typen wie int sollten alle Parameter und jeder Rückgabetyp einer Methode entweder als @NonNull oder @Nullable markiert werden. Da dies bedeuten würde, dass sehr viele Nullanmerkungen eingefügt werden müssen, sollten Sie wissen, dass in einem gut strukturierten Code (insbesondere bei API-Methoden) @NonNull deutlich häufiger vorkommt als @Nullable. Deswegen kann die Anzahl der Anmerkungen reduziert werden, indem @NonNull als Standardeinstellung (default) deklariert wird und auf Paketebene eine Anmerkung @NonNullByDefault verwendet wird.

Beachten Sie den beträchtlichen Unterschied zwischen @Nullable und dem Übergehen einer Nullanmerkung: Diese Anmerkung gibt explizit an, dass null OK ist und erwartet werden muss. Im Gegensatz dazu bedeutet keine Anmerkung, dass keine Klarheit über den Zweck besteht. Hierbei handelt es sich um die früher häufige Situation, in der beide Komponenten (aufrufendes und aufgerufenes Modul) den Code auf Nullwerte überprüft haben. In bestimmten Fällen wurde von den Komponenten fälschlicherweise davon ausgegangen, dass die jeweils andere Komponente die Überprüfung durchführt. Dadurch kann es zu Ausnahmebedingungen vom Typ NullPointerExceptions kommen. Ohne eine Anmerkung kann der Compiler keine speziellen Empfehlungen geben, mit einer Anmerkung vom Typ @Nullable wird jedoch jede nicht überprüfte Verweisaufhebung mit einer Markierung versehen.

Mit diesen grundlegenden Informationen können Sie direkt alle Parameteranmerkungen bestimmten Vorbedingungen zuordnen und die zurückgegebenen Anmerkungen als Nachbedingungen der Methode interpretieren.

Vergabe von untergeordneten Typen und Überschreibungen

In der objektorientierten Programmierung muss das Design by Contract-Konzept auf eine weitere Dimension angewendet werden: Die Vergabe von untergeordneten Typen (sog. Sub-typing) und die Überschreibung (im Folgenden wird der Begriff "Überschreibung" im Sinne der Anmerkung @Override in Java 6 verwendet: Methoden, die eine andere Methode ausgehend von einem übergeordneten Typ überschreiben oder implementieren). Ein Client, der eine Methode wie die folgende aufruft:

    @NonNull String checkedString(@Nullable String in)

sollte davon ausgehen können, dass alle Implementierungen dieser Methode den Vertrag erfüllen. Wenn die Methodendeklaration in einer Schnittstelle mit dem Namen I1 gefunden wird, dann müssen Sie ausschließen, dass eine Klasse mit dem Namen Cn, die I1 implementiert, eine inkompatible Implementierung bereitstellt. Insbesondere ist es nicht zulässig, wenn Cn versucht, diese Methode mit einer Implementierung zu überschreiben, die den Parameter als @NonNull deklariert. Wäre dies zulässig, dann könnte ein Clientmodul, das für I1 programmiert wird, null als zulässiges Argument übergeben, die Implementierung würde jedoch einen Nicht-Nullwert annehmen. Nicht überprüfte Verweisaufhebungen innerhalb der Methodenimplementierung wären in diesem Fall zulässig, würden aber während der Laufzeit zu Fehlern führen. Aus diesem Grund sind durch die Parameterspezifikation @Nullable alle Überschreibungen gezwungen, null als einen erwarteten, zulässigen Wert zuzulassen.

Umgekehrt werden durch eine Rückgabespezifikation vom Typ @NonNull alle Überschreibungen gezwungen sicherzustellen, dass null in keinem Fall zurückgegeben wird.

Aus diesem Grund muss der Compiler sicherstellen, dass keine Überschreibung eine Parameteranmerkung vom Typ @NonNull (oder eine Rückgabeanmerkung vom Typ @Nullable) hinzufügt, die im übergeordneten Typ nicht vorhanden war.

Interessanterweise sind die umgekehrten Neudefinitionen zulässig: Hinzufügen einer Parameteranmerkung vom Typ @Nullable oder einer Rückgabeanmerkung vom Typ @NonNull (diese können als "Verbesserungen" der Methode verstanden werden, da mehr Werte akzeptiert und spezifischere Rückgabewerte generiert werden).

Traditionelle übergeordnete Typen

Die zuvor erläuterten Hinweise verursachen eine Schwierigkeit, wenn der mit Anmerkungen versehene Code als untergeordneter Typ eines traditionellen (z. B. nicht mit Anmerkung versehenen) Typs geschrieben wird, der z. B. aus der Bibliothek eines Drittanbieters stammen und deswegen nicht geändert werden kann. Wenn Sie die Informationen im letzten Abschnitt sorgfältig lesen, dann werden Sie feststellen, dass nicht zugelassen werden kann, dass eine traditionelle Methode von einer Methode überschrieben wird, die mit einem Parameter @NonNull versehen ist (weil Clients, die den übergeordneten Typ verwenden, die Verpflichtung, die sich aus @NonNull ergibt, nicht erkennen).

In dieser Situation sind Sie gezwungen, Nullanmerkungen zu übergehen (es bestehen Pläne, das Hinzufügen von Anmerkungen zu Bibliotheken im Nachhinein in Zukunft zu unterstützen, es kann jedoch noch nicht zugesagt werden, ob und wann eine solche Funktion zur Verfügung stehen wird).

Nullness-Standardwert stornieren

Die Situation kann kompliziert werden, wenn ein untergeordneter Typ eines traditionellen Typs sich in einem Paket befindet, für das @NonNullByDefault angegeben wurde. In diesem Fall muss ein Typ mit einem übergeordneten Typ ohne Anmerkung alle Parameter in überschreibenden Methoden als @Nullable markieren: Selbst das Übergehen von Parameteranmerkungen ist nicht zulässig, weil dies als Parameter vom Typ @NonNull interpretiert werden würde, was an dieser Position nicht zulässig ist. Aus diesem Grund unterstützt der Eclipse-Java-Compiler das Stornieren eines Nullness-Standardwerts: Durch das Angeben der Anmerkung @NonNullByDefault(false) für eine Methode oder einen Typ wird für dieses Element ein anwendbarer Standardwert storniert und Parameter ohne Anmerkungen werden wieder als nicht angegeben interpretiert. Jetzt ist die Definition untergeordneter Typen wieder zulässig, ohne dass nicht erwünschte Anmerkungen vom Typ @Nullable hinzugefügt werden müssen:

class LegacyClass {
    String enhance (String in) { // clients are not forced to pass nonnull.
        return in.toUpperCase();
    }
}
 
@NonNullByDefault
class MyClass extends LegacyClass {
	
    // ... methods with @NonNull default ...
 
    @Override
    @NonNullByDefault(false)
    String enhance(String in) { // would not be valid if @NonNullByDefault were effective here
        return super.enhance(in);
    }
}

Vorteile von Design by Contract (DbC)

Die Verwendung von Nullanmerkungen im Design by Contract-Stil in der oben erläuterten Form unterstützt Sie dabei, die Qualität Ihres Java-Codes auf verschiedene Arten zu verbessern: Bei der Schnittstelle zwischen Methoden wird explizit angegeben, welche Parameter und Rückgabewerte einen Nullwert akzeptieren können und welche nicht. Dadurch werden Designentscheidungen erfasst, die von großer Relevanz für Entwickler sind, und zwar auf eine Weise, die auch vom Compiler überprüft werden kann.

Darüber hinaus kann auf der Basis dieser Schnittstellenspezifikation die prozedurinterne Ablaufanalyse die verfügbaren Informationen aufgreifen und erheblich genauere Fehlernachrichten und Warnungen ausgeben. Ohne Anmerkungen weisen alle Werte, die eine Methode durchlaufen, einen unbekannten Nullness-Status auf. Aus diesem Grund gibt die Nullanalyse keine Werte zu ihrer Verwendung aus. Mit Nullanmerkungen auf API-Ebene ist der Nullness-Status der meisten Werte bekannt und deutlich weniger NPEs werden vom Compiler nicht erkannt. Allerdings sollten Sie berücksichtigen, dass weiterhin Lücken bestehen, durch die nicht angegebene Werte in die Analyse einfließen und verhindern können, dass eine vollständige Aussage dazu, ob NPEs während der Laufzeit auftreten dürfen, gemacht werden kann.

Vollständige Spezifikation mit erweitertem Typsystem

Die Unterstützung für Nullanmerkungen wurde so konzipiert, dass Kompatibilität zu zukünftigen Erweiterungen besteht. Auf diese Weise kann der Compiler sicherstellen, dass ein zertifiziertes Programm während der Laufzeit nie eine Ausnahmebedingung vom Typ NullPointerException (mit den typischen Vorbehalten zu nicht überprüfbaren Teilen wie der Reflexion) ausgibt. Während keine Zusage in Bezug auf solche zukünftigen Erweiterungen gemacht werden kann, besteht die grundlegende Idee in unterschiedlichen Interpretationen der bereits vorhandenen Daten.

Durch die Interpretation von Nullanmerkungen als Teil des Typsystems wird die Anzahl der Typen in einem bestimmten Programm verdoppelt: Für jede angegebene Klasse Cn wird die Klasse selbst nicht mehr als zulässiger Typ betrachtet, sondern nur "@NonNull Cn" und "@Nullable Cn" werden als nützliche Typen eingestuft. Auf diese Weise ist im Idealfall für jeden Wert in einem Programm bekannt, ob er den Wert null aufweisen kann oder nicht (was vor der Aufhebung des Verweises überprüft werden muss). Wenn Sie die dritte Option (Typen ohne Anmerkungen) ausschließen, kann der Compiler jede nicht sichere Verwendung strikt markieren.

Für die aktuelle Implementierung gelten in Hinblick auf dieses Ziel zwei wichtige Einschränkungen:

Zum heutigen Zeitpunkt und ungeachtet der momentanen Einschränkungen hat die Vision vollständig definierter und vollkommen überprüfter Programme bereits Auswirkungen, die die aktuelle Analyse und auch die vom Compiler gemeldeten Fehler und Warnungen beeinflussen. Die Details werden dargestellt, indem die vom Compiler überprüften Regeln und die Nachrichten erläutert werden, die bei Verstößen gegen eine der Regeln ausgegeben werden.

Erläuterte Compilernachrichten

Auf der entsprechenden Benutzervorgabenseite werden die vom Compiler überprüften Regeln unter den folgenden Überschriften erläutert:

Verstoß gegen Nullspezifikation

Als Verstoß gegen eine Spezifikation werden Situationen bezeichnet, in denen eine Nullanmerkung eine Anforderung stellt, gegen die die aktuelle Implementierung verstößt. Die typische Situation ist auf die Angabe eines Wertes (lokal, Argument, Methodenrückgabe) wie @NonNull zurückzuführen, wenn die Implementierung eigentlich einen nullfähigen Wert bereitstellt. Hier wird ein Ausdruck als nullfähig betrachtet, wenn entweder statisch anerkannt ist, dass er mit dem Wert null ausgewertet wird, oder wenn er mit einer Anmerkung vom Typ @Nullable deklariert ist.

Zweitens enthält diese Gruppe auch die Regeln für die Methodenüberschreibung, die oben erläutert wurde. Hier definiert eine übergeordnete Methode eine Anforderung (z. B., dass null ein zulässiges Argument ist), während eine Überschreibung versucht, diese Anforderung (durch die Annahme, dass null kein zulässiges Argument ist) zu umgehen. Wie bereits erwähnt, stellt auch die Spezialisierung eines Arguments von nicht mit einer Anmerkung versehen zu @NonNull einen Spezifikationsverstoß dar, weil sie einen Vertrag einführt, der den Client (zur Nichtübergabe von null) verpflichten soll. Ein Client, der den übergeordneten Typ verwendet, kann diesen Vertrag jedoch nicht identifizierten, sodass er nicht erkennen kann, welche Aktion von ihm erwartet wird.

Die vollständige Liste der Situationen, die als Spezifikationsverstöße betrachtet werden, finden Sie hier. Es ist wichtig, dass Sie verstehen, dass Fehler in dieser Gruppe niemals ignoriert werden dürfen, weil andernfalls die gesamte Nullanalyse auf der Basis falscher Annahmen ausgeführt wird. Insbesondere dann, wenn der Compiler einen Wert mit der Anmerkung @NonNull erkennt, nimmt er an, dass der Wert null während der Laufzeit nicht vorkommt. Die Regel zu den Spezifikationsverstößen stellt sicher, dass diese Annahme korrekt ist. Aus diesem Grund ist dringend zu empfehlen, dass diese Art von Problemen als Fehler konfiguriert bleibt.

Konflikt zwischen Nullanmerkungen und Nullinferenz

Diese Gruppe von Regeln überwacht auch die Einhaltung der Nullspezifikationen. Allerdings handelt es sich im vorliegenden Fall um Werte, die nicht als @Nullable deklariert sind (auch nicht der Wert null selbst), sondern um Werte, bei denen die prozedurinterne Ablaufanalyse ableitet, dass null in bestimmten Ausführungspfaden auftreten kann.

Diese Situation ergibt sich aus der Tatsache, dass für lokale Variablen ohne Anmerkung der Compiler anhand der Ablaufanalyse ableitet, ob null möglich ist. Wenn diese Analyse korrekt ist und ein Problem festgestellt wird, dann hat dieses Problem die gleiche Wertigkeit wie direkte Verstöße gegen die Nullspezifikation. Aus diesem Grund wird ebenfalls dringend empfohlen, Probleme dieser Art weiterhin als Fehler konfiguriert zu lassen und die entsprechenden Nachrichten nicht zu ignorieren.

Wenn Sie eine separate Gruppe für diese Probleme erstellen, dann dient das den folgenden beiden Zwecken: Sie dokumentieren mithilfe der Ablaufanalyse, dass ein bestimmtes Problem aufgetreten ist, und Sie tragen der Tatsache Rechnung, dass diese Ablaufanalyse möglicherweise Fehler enthalten kann (weil in der Implementierung ein Fehler enthalten ist). Im Fall eines bestätigten Implementierungsfehlers kann es in Ausnahmefällen OK sein, eine Fehlernachricht dieser Art zu unterdrücken.

Aufgrund des Verhaltens bei der statischen Analyse kann die Ablaufanalyse möglicherweise nicht erkennen, dass eine bestimmte Kombination aus Ausführungspfaden und Werten nicht möglich ist. Betrachten Sie hierzu das Beispiel der Variablenkorrelation:

   String flatten(String[] inputs1, String[] inputs2) { 
        StringBuffer sb1 = null, sb2 = null;
        int len = Math.min(inputs1.length, inputs2.length);
        for (int i=0; i<len; i++) {
            if (sb1 == null) {
                sb1 = new StringBuffer();
                sb2 = new StringBuffer();
            }
            sb1.append(inputs1[i]);
            sb2.append(inputs2[i]); // warning here
        }
        if (sb1 != null) return sb1.append(sb2).toString();
        return "";
    }

Der Compiler meldet einen möglichen Nullzeigerzugriff beim Aufruf von sb2.append(..). Der Benutzer kann sehen, dass keine unmittelbare Gefahr besteht, weil sb1 und sb2 auf eine Weise korrelieren, bei der entweder beide Variablen null oder beide ungleich null sind. In der fraglichen Zeile ist bekannt, dass sb1 ungleich null ist, wodurch abgeleitet werden kann, dass auch sb2 ungleich null ist. Ohne näher zu untersuchen, warum solche Korrelationsanalysen vom Eclipse-Java-Compiler nicht ausgeführt werden können, sollten Sie bedenken, dass diese Analyse nicht die Leistungsfähigkeit eines vollständigen Theoremtests hat und deshalb bestimmte Probleme pessimistisch gemeldet werden, die bei einer leistungsfähigeren Analyse als falscher Alarm erkannt werden könnten.

Wenn Sie die Ablaufanalyse optimal nutzen wollen, dann sollten Sie den Compiler unterstützen, um die Erkennung Ihrer Schlüsse zu vereinfachen. Hierzu können Sie einfach if (sb1 == null) in zwei separate if-Elemente aufteilen, wobei eine für jede lokale Variable verwendet wird. Dies stellt einen geringen Aufwand für die Erreichung des Vorteils dar, dass der Compiler nun exakt erkennen kann, welche Vorgänge ablaufen und Ihren Code entsprechend überprüfen kann. Dieses Thema wird im Folgenden detaillierter erläutert.

Ungeprüfte Konvertierung von Typ ohne Anmerkung in den Typ @NonNull

Diese Problemgruppe basiert auf der folgenden Analogie: In einem Programm, das allgemeine Java 5-Elemente verwendet, kann es durch einen Aufruf für Bibliotheken vor Java 5 zu einer Offenlegung unformatierter Typen (z. B. generische Anwendungen, die keine konkreten Typargumente angeben können) kommen. Um solche Werte mit generischen Elementen in ein Programm einzubinden, kann der Compiler eine implizite Konvertierung hinzufügen, indem angenommen wird, dass Typargumente von der Clientkomponente des Codes auf die erwartete Weise angegeben wurden. Der Compiler gibt eine Warnung zur Verwendung einer solchen Konvertierung aus und setzt die Typüberprüfung fort, wobei davon ausgegangen wird, dass die Bibliothek korrekt reagiert. In derselben Weise kann ein Rückgabetyp ohne Anmerkung einer Bibliotheksmethode als "unformatiert" oder "traditionell" betrachtet werden. Es kann auch hier bei einer impliziten Konvertierung optimistisch davon ausgegangen werden, dass die erwartete Spezifikation zutrifft. Eine Warnung wird ausgegeben und die Analyse wird unter der Annahme fortgesetzt, dass die Bibliothek korrekt reagiert.

Theoretisch stellt die Notwendigkeit solcher impliziter Konvertierungen bereits einen Spezifikationsverstoß dar. Allerdings kann es sich in diesem Fall um den Code eines Drittanbieters handeln, der gegen die Spezifikation verstößt, die vom Code erwartet wird. Auch ist es möglich, dass festgestellt wurde, dass der Code des Drittanbieters den Vertrag erfüllt, aber nicht in der Lage ist, dies zu deklarieren (weil keine Nullanmerkungen verwendet werden). In solchen Situationen kann das Problem möglicherweise aus organisatorischen Gründen nicht behoben werden.

    @SuppressWarnings("null")
    @NonNull Foo foo = Library.getFoo(); // implicit conversion
    foo.bar(); 

Beim obigen Code-Snippet wird davon ausgegangen, dass Library.getFoo() das Element Foo ohne Angabe einer Nullanmerkung zurückgibt. Sie können den Rückgabewert in das mit Anmerkungen versehene Programm integrieren, indem eine Zuordnung zu einer lokalen Variablen vom Typ @NonNull durchgeführt wird, die eine Warnung zu der ungeprüften Konvertierung ausgibt. Durch das Hinzufügen eines entsprechenden Elements SuppressWarnings("null") zu dieser Deklaration wird das potenzielle Risiko anerkannt und die Verantwortung für die Überprüfung des ordnungsgemäßen Verhaltens der Bibliothek übernommen.

Tipps zur Verbesserung der Codeanalyse

Wenn die Ablaufanalyse nicht erkennen kann, dass ein Wert ungleich null ist, dann ist es immer am einfachsten, eine neue bereichsorientierte lokale Variable hinzuzufügen, die mit der Anmerkung @NonNull versehen ist. Wenn Sie sicher sind, dass der Wert, der dieser lokalen Variablen zugeordnet ist, während der Laufzeit niemals den Wert null annehmen kann, können Sie eine Helper-Methode wie folgt verwenden:

    static @NonNull <T> T assertNonNull(@Nullable T value, @Nullable String msg) {
        if (value == null) throw new AssertionError(msg);
        return value;
    }
    @NonNull MyType foo() {
        if (isInitialized()) {
            MyType couldBeNull = getObjectOrNull();
            @NonNull MyType theValue = assertNonNull(couldBeNull, 
                    "value should not be null because application " +
                    "is fully initialized at this point.");
            return theValue;
        }
        return new MyTypeImpl();
    }

Beachten Sie, dass durch Verwendung der Methode assertNonNull() im obigen Fall die Verantwortung dafür übernommen wird, dass diese Assertion während der Laufzeit immer eingehalten wird. Wenn dies nicht gewünscht wird, können lokale Variablen mit Anmerkung dennoch nützlich sein, um einzugrenzen, wo und warum die Analyse ein potenzielles Risiko erkennt, dass null an einer bestimmten Position auftreten kann.

Tipps zur Annahme von Nullanmerkungen

Bei der Freigabe von JDT Version 3.8.0 befindet sich die Erfassung von Empfehlungen für die Annahme von Nullanmerkungen immer noch in Arbeit. Aus diesem Grund werden diese Informationen momentan im Eclipse-Wiki verwaltet.