So implementieren Sie ein leeres Urteil in Java

NullObject Mode

Zahlreiche Nullurteile im Projekt hatten einen sehr schlechten Einfluss auf die Codequalität und -sauberkeit. Wir nennen es die „Nullurteilskatastrophe“.

Wie geht man also mit diesem Phänomen um? Sie haben vielleicht schon vom NullObject-Modus gehört, aber das ist heute nicht unsere Waffe, aber wir müssen den NullObject-Modus trotzdem einführen.

Was ist der NullObject-Modus?

In der objektorientierten Computerprogrammierung ist ein Nullobjekt ein Objekt ohne referenzierten Wert oder mit definiertem neutralem („Null“)-Verhalten. Das Nullobjekt-Entwurfsmuster beschreibt die Verwendung eines solchen Objekte und ihr Verhalten (oder deren Fehlen).

Die obige Analyse stammt aus Wikipedia.

Das NullObject-Muster wurde erstmals in der Reihe „Programming Pattern Language“ veröffentlicht. Im Allgemeinen müssen Sie in objektorientierten Sprachen vor dem Aufrufen von Objekten eine Nullprüfung durchführen, um festzustellen, ob diese Objekte null sind, da die erforderlichen Methoden nicht für Nullreferenzen aufgerufen werden können.

Der Beispielcode lautet wie folgt (der Name kommt aus dem Internet, haha, wie faul bist du):

Nullable ist die relevante Operationsschnittstelle des verwendeten leeren Objekts um festzustellen, ob das Objekt leer ist, denn wenn das Objekt im Nullobjektmodus leer ist, wird es in ein Objekt gepackt und zu einem Nullobjekt. Dieses Objekt implementiert leere Implementierungen aller Methoden des ursprünglichen Objekts ...

public interface Nullable {      boolean isNull(); }

Diese Schnittstelle definiert das Verhalten des Geschäftsobjekts.

 <br>

public interface DependencyBase extends Nullable {      void Operation();  }

Dies ist die eigentliche Klasse des Objekts, die die Geschäftsverhaltensschnittstelle DependencyBase und die Nullobjektoperationsschnittstelle Nullable implementiert.

public class Dependency implements DependencyBase, Nullable {      @Override     public void Operation() {         System.out.print("Test!");     }      @Override     public boolean isNull() {         return false;     }  }

Dies ist ein leeres Objekt, eine leere Implementierung des Verhaltens des ursprünglichen Objekts.

public class NullObject implements DependencyBase{      @Override     public void Operation() {         // do nothing     }      @Override     public boolean isNull() {         return true;     }  }

Bei Verwendung können Sie das leere Objekt über die Factory-Call-Methode aufrufen oder das Objekt über andere Methoden wie Reflection aufrufen (normalerweise dauert es ein paar Millisekunden). Näheres hier zur Erzählung.

public class Factory {      public static DependencyBase get(Nullable dependencyBase){         if (dependencyBase == null){             return new NullObject();         }         return new Dependency();     }  }

Dies ist ein Anwendungsbeispiel. In diesem Modus müssen wir die Nulloperation des Objekts nicht mehr ausführen, sondern können das Objekt direkt verwenden, ohne uns um NPE (NullPointerException) kümmern zu müssen.

public class Client {      public void test(DependencyBase dependencyBase){         Factory.get(dependencyBase).Operation();     }  }

.NR Null Object

NR Null Object ist ein Tool, das für Android Studio, IntelliJ IDEA, PhpStorm, WebStorm, PyCharm, RubyMine, AppCode, CLion, GoLand, DataGrip geeignet ist Warten auf das Intellij-Plug-in von IDEA. Es kann schnell und einfach die für seinen leeren Objektmodus erforderlichen Komponenten basierend auf vorhandenen Objekten generieren. Zu seinen Funktionen gehören die folgenden:

1. Analysieren Sie die Methoden, die die ausgewählte Klasse deklarieren kann als Schnittstelle ;

2. Abstrahieren Sie die öffentliche Schnittstelle;

3. Erstellen Sie ein leeres Objekt und implementieren Sie die Öffentlichkeit automatisch Schnittstelle;#🎜🎜 #

4. Einige Funktionen als nullbar deklarieren;

5. Anhängbare Funktionen können erneut generiert werden; #🎜🎜 ## 🎜🎜#
   Konvention zur automatischen Benennung von Funktionen

6. Schauen wir uns ein Anwendungsbeispiel an:

#🎜 🎜#

Wie wäre es damit? Es scheint sehr schnell und bequem zu sein. Sie müssen nur das Menü in der E-Mail öffnen, „Generieren“ auswählen und „NR Null-Objekt“ auswählen, um automatisch entsprechende leere Objektkomponenten zu generieren.

Wie bekomme ich dieses Plug-in?

Installationsmethode

Kann direkt über das Plugins-Repository in den Einstellungen von IDEA installiert werden.

Einstellungen auswählen → Plugins → Repositorys durchsuchen

Suche nach „NR Null“. Um eine Fuzzy-Abfrage durchzuführen, klicken Sie auf „Oject“ oder „Null Object“, klicken Sie rechts auf „Installieren“ und starten Sie IDEA neu.

Optional

Eine andere Möglichkeit besteht darin, die optionalen Funktionen in Java8 zu verwenden, um eine elegante leere Beurteilung durchzuführen Die Einleitung lautet wie folgt:

Ein Containerobjekt, das einen Wert ungleich Null enthalten kann oder nicht. Wenn ein Wert vorhanden ist, gibt isPresent() true zurück und get() Gibt den Wert zurück.

Ein Containerobjekt, das Nicht-Null-Werte enthalten kann oder auch nicht. Wenn der Wert vorhanden ist, gibt isPresent() true zurück und get() gibt den Wert zurück.

Lassen Sie mich Ihnen ohne weitere Umschweife ein Beispiel geben.

Es gibt den folgenden Code, der die Info-Informationen in Test2 abrufen muss, aber der Parameter ist Test4. Die auf jeder Ebene erhaltenen Objekte sind möglicherweise leer Code sieht so aus: Genau so.

public String testSimple(Test4 test) {        if (test == null) {            return "";        }        if (test.getTest3() == null) {            return "";        }        if (test.getTest3().getTest2() == null) {            return "";        }        if (test.getTest3().getTest2().getInfo() == null) {            return "";        }        return test.getTest3().getTest2().getInfo();    }

Aber nach der Verwendung von Optional ist das Ganze anders.

public String testOptional(Test test) {         return Optional.ofNullable(test).flatMap(Test::getTest3)                 .flatMap(Test3::getTest2)                 .map(Test2::getInfo)                 .orElse("");     }

1. Optional.ofNullable(test), wenn der Test leer ist, gibt er ein leeres Singleton-Objekt zurück, wenn er nicht leer ist, gibt er ein optionales Verpackungsobjekt zurück, einen optionalen Wrap-Test ;

public static <t> Optional<t> ofNullable(T value) {         return value == null ? empty() : of(value);     }</t></t>

  

public<u> Optional<u> flatMap(Function super T, Optional<u>> mapper) {         Objects.requireNonNull(mapper);         if (!isPresent())             return empty();         else {             return Objects.requireNonNull(mapper.apply(value));         }     }</u></u></u>

但是使用Optional后，整个就都不一样了。    

public<u> Optional<u> map(Function super T, ? extends U> mapper) {        Objects.requireNonNull(mapper);        if (!isPresent())            return empty();        else {            return Optional.ofNullable(mapper.apply(value));        }    }</u></u>

1、Optional.ofNullable(test)，如果test为空，则返回一个单例空Optional对象，如果非空则返回一个Optional包装对象，Optional将test包装；    

public T orElse(T other) {     return value != null ? value : other; }

2、flatMap(Test::getTest3)判断test是否为空，如果为空，继续返回第一步中的单例Optional对象，否则调用Test的getTest3方法；    2. flatMap(Test::getTest3) ermittelt, ob test leer ist, im ersten Schritt mit der Rückgabe des optionalen Singleton-Objekts fortfahren. andernfalls rufen Sie die getTest3-Methode von Test auf;

public<u> Optional<u> flatMap(Function super T, Optional<u>> mapper) {         Objects.requireNonNull(mapper);         if (!isPresent())             return empty();         else {             return Objects.requireNonNull(mapper.apply(value));         }     }</u></u></u>

3、flatMap(Test3::getTest2)同上调用Test3的getTest2方法；

4、map(Test2::getInfo)同flatMap类似，但是flatMap要求Test3::getTest2返回值为Optional类型，而map不需要，flatMap不会多层包装，map返回会再次包装Optional；  

public<u> Optional<u> map(Function super T, ? extends U> mapper) {        Objects.requireNonNull(mapper);        if (!isPresent())            return empty();        else {            return Optional.ofNullable(mapper.apply(value));        }    }</u></u>

5、orElse("");获得map中的value，不为空则直接返回value，为空则返回传入的参数作为默认值。

public T orElse(T other) {     return value != null ? value : other; }

怎么样，使用Optional后我们的代码是不是瞬间变得非常整洁，或许看到这段代码你会有很多疑问，针对复杂的一长串判空，Optional有它的优势，但是对于简单的判空使用Optional也会增加代码的阅读成本、编码量以及团队新成员的学习成本。毕竟Optional在现在还并没有像RxJava那样流行，它还拥有一定的局限性。

如果直接使用Java8中的Optional，需要保证安卓API级别在24及以上。

你也可以直接引入Google的Guava。（啥是Guava？来自官方的提示）

Guava  is a set of core libraries that includes new collection types (such as  multimap and multiset), immutable collections, a graph library,  functional types, an in-memory cache, and APIs/utilities for  concurrency, I/O, hashing, primitives, reflection, string processing,  and much more!

引用方式，就像这样：    

dependencies {       compile 'com.google.guava:guava:27.0-jre'       // or, for Android:       api 'com.google.guava:guava:27.0-android'     }

不过IDEA默认会显示黄色，提示让你将Guava表达式迁移到Java Api上。

当然，你也可以通过在Preferences搜索"Guava"来Kill掉这个Yellow的提示。

使用Optional具有如下优点：

1. 将防御式编程代码完美包装

2. 链式调用

3. 有效避免程序代码中的空指针

但是也同样具有一些缺点：

1. 流行性不是非常理想，团队新成员需要学习成本

2. 安卓中需要引入Guava，需要团队每个人处理IDEA默认提示，或者忍受黄色提示

当然，Kotlin以具有优秀的空安全性为一大特色，并可以与Java很好的混合使用，like this:    

test1?.test2?.test3?.test4

Das obige ist der detaillierte Inhalt vonSo implementieren Sie ein leeres Urteil in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!