Polymorphie Null Objekt

[ioannis_m]

Guten Abend,

aus dem Buch Patterns Kompakt, Karl Eilebrecht, s. 150:

In Java kann es nützlich sein, das Null-Objekt als anonyme innere Klasse eines Interfaces zu implementieren. Erstens stellen Sie damit sicher, dass es nur genau eine Instanz gibt, und zweitens kann niemand, außer dem Interface selbst, Instanzen des Null-Objekts erzeugen.

public interface NullObject {
    public void someMethod();

    public static final NullObject NULL = new NullObject()
    {
        public void someMethod()
        {
            // leer: tue nichts
        }
    };
}

Ich nehme an, der Client kann somit Null Abfragen sparen, nur ich verstehe nicht genau wie das funktionieren soll: Wie könnte der Client Code aussehen? Der ruft someMethod() auf einem Objekt, das noch nicht erzeugt wurde, weil aber das Interface schon geladen wurde, gibt es NULL schon, richtig? Wie landet dann NULL auf dem Client?

Danke & Gruß
ioannis

 

[mrBrown]

Die Prüfung auf null sparst du dir damit nicht gänzlich, du kannst sie aber in Teilen vermeiden, indem du NullObject.NULL nutzt, um zu signalisieren, dass da "nichts" ist.

Der Client muss das schon ganz explizit über NullObject.NULL bekomme, automatisch passiert da nichts, man würde es einfach da explizit nutzen, wo man sonst null (explizit oder implizit) nutzt.

(NullObject für das Interface ist btw ein echt schlecht gewählter Name )

 

[ioannis_m]

Vielen Dank für die Antwort, die ist aber für meinen Wissensstand ein wenig zu abstrakt.


Ich stelle mir vor, der Client hat eine Methode die das EchteObject als Parameter einnimmt. Weil es auch null sein kann, muss er eine Null Abfrage machen i.e. :

public void clientMethod (EchtesObject echtesObject)

    if (echtesObject != null) { … }

Jetzt die Null Mühe gemacht wurde, hätte ich mir vorgestellt, dass so etwas gehen würde:

public void clientMethod (i irgendeinIAuchNull)

    { … }

Du sagst jetzt, so einfach geht das nicht. Wie genau nutzt der Client das NullObject.Null und wie funktioniert das delegieren an das neue Interface? Was ist polymorfisch daran? Was bringt ihm das Ganze?



mfg

ioannis

 

[mrBrown]

Angenommen du hast das Interface von oben (nur statt NullObject einfach mal Irgendwas genannt.

public void clientMethod (Irgendwas irgendwas) {
    irgendwas.someMethod();
}

Wenn du dem Client null übergibst, würde die Exception fliegen.
Stattdessen kannst du dem dann Irgendwas.NULL übergeben - der Code macht dann nichts, wie gewünscht, es gibt keinen Fehler und du musst null nicht explizit behandeln.

Wenn der Client was tun soll, übergibst du dem eine richtige Implementierung des Interfaces, die auch etwas macht:

HelloWorld implements Irgendwas {
  @Override
  public void someMethod() {
    System.out.println("Hello World");
  }
}

Du sagst jetzt, so einfach geht das nicht

Du musst außerhalb der methode schon noch sicherstellen, dass du das Null-Object nutzt, eben da, wo du sonst null nutzen würdest.
Allerdings weißt du ja dann, dass kein null benutzt wird - du musst also nicht mehr auf null prüfen - helfen kann dir da zB der Compiler (mit zB Annotation-Prozessoren).

Wie genau nutzt der Client das NullObject.Null

Du als Nutzer des Interfaces kannst da, wo das Interface erwartet wird, jeweils Interface.Null übergeben, anstatt von null.

und wie funktioniert das delegieren an das neue Interface

Es gibt kein neues, sondern eben nur dieses Interface, was du sonst auch hättest.
delegiert an das Interface wird da aber nichts.

Was ist polymorfisch daran?

Es gibt verschiedene Implementationen des Interfaces -> Polymorphimus.

Was bringt ihm das Ganze

In den Methoden musst du null nicht direkt behandeln, da das Null-Objekt statt null benutzt wird.