Der Nachfolger des letzten Elementes der Liste soll nicht mehr den Wert null erhalten, sondern auf ein Abschluss-Objekt zeigen. Das wird uns etwas später die Möglichkeit geben, auf elegante Art und Weise ohne den fehlerträchtigen Wert null auszukommen. Sehen wir uns eine beispielhafte Liste mit vier Elementen im Objektdiagramm an:

Damit das Attribut nachfolger sowohl auf ein Knoten-Objekt als auch auf ein Abschluss-Objekt zeigen kann, muss sein Datentyp eine Oberklasse von Knoten und Abschluss sein. Wir nennen diese Klasse Listenelement und implementieren sie als abstrakte Klasse. Alle Methoden der Klasse Listenelement sind abstrakt, d.h. sie werden dort nur deklariert, aber nicht mit Anweisungen gefüllt. Das geschieht erst in den Klassen Knoten und Abschluss – und zwar auf unterschiedliche Weise!

Die Klasse Inhalt soll beispielhaft einfach nur Text speichern können:

public class Inhalt {
 
   private String text;
 
   public Inhalt(String text) {
      this.text = text;
   }
 
   public void ausgabe() {
      println(text);
   }
}

Die Klasse Listenelement besitzt drei abstrakte Methoden (d.h. Methoden, die erst in Unterklassen definiert werden):

abstract class Listenelement {
   public abstract Inhalt getInhalt();                         // gibt den Inhalt zurück (null im Falle des Abschlusses)
   public abstract Listenelement getNachfolger();              // gibt das nachfolgende Element zurück (null im Falle des Abschlusses)
   public abstract Listenelement hintenAnfügen(Inhalt inhalt); // fügt den Inhalt am Ende der Liste an. 
 
   // Bemerkung:
   // Bei Knoten-Objekten gibt die Methode hintenAnfügen das Objekt selbst wieder zurück.
   // Bei Abschluss-Objekten gibt die Methode das neue eingefügte Knoten-Objekt zurück.
}

Die Klasse Liste speichert eine Referenz "erster" auf das erste Element der Liste. Ihre Methoden machen regen Gebrauch von den Methoden dieses Objekts.

class Liste {
 
   private Listenelement erster;    // Zeigt auf das erste Listenelement
 
   public Liste() {
      erster = new Abschluss();     // Die leere Liste besteht nur aus einem Abschluss-Objekt
   }
 
   public Inhalt erstenEntnehmen() { 
      Listenelement alterErster = erster;
      erster = erster.getNachfolger();
      return alterErster.getInhalt();
   }
 
   public void hintenAnfügen(Inhalt inhalt) {
      // Genau dann, wenn erster ein Abschluss-Objekt ist, wird die
      // folgende Anweisung den Wert von erster ändern.
      erster = erster.hintenAnfügen(inhalt);
   }
}

Ein Objekt der Klasse Knoten speichert eine Referenz auf ein Inhalt-Objekt sowie eine Referenz auf das nachfolgende Knoten-Objekt (bzw. ein Abschluss-Objekt, wenn der Knoten das letzte Element der Liste ist).

class Knoten extends Listenelement {
   private Inhalt inhalt;
   private Listenelement nachfolger;
 
   public Listenelement getNachfolger() {
      return nachfolger;
   }
 
   public Knoten(Inhalt inhalt, Knoten nachfolger) {
      this.inhalt = inhalt;
      this.nachfolger = nachfolger;
   }
 
   public Knoten(Inhalt inhalt, Listenelement l) {
      this.inhalt = inhalt;
      nachfolger = l;
   }
 
   public Inhalt getInhalt() {
      return inhalt;
   }
 
   public Listenelement hintenAnfügen(Inhalt inhalt) {
      nachfolger = nachfolger.hintenAnfügen(inhalt);     // "Soll sich doch das Nachfolger-Objekt darum kümmern!" :-)
      return this;
   }
 
}

Das Abschluss-Objekt der Liste hat keinen Inhalt. Seine Hauptaufgabe besteht darin, sich in der Methode hintenAnfügen um die Erzeugung und das Einflicken eines neuen Knoten-Objekts in die Liste zu kümmern.

class Abschluss extends Listenelement {
   public Inhalt getInhalt() {
      return null;
   }
 
   public Listenelement getNachfolger() {
      return this;
   }
 
   public Listenelement hintenAnfügen(Inhalt inhalt) {
      Knoten k = new Knoten(inhalt, this);        // erzeugt einen neuen Knoten, dessen nachfolger-Objekt dieses Abschluss-Objekt ist
      return k;                                   // gibt eine Referenz auf den neuen Knoten an das aufrufende Objekt zurück
  	}
}

Hier einige Aufgaben zur Listenimplementierung mit Kompositum!

Die Kernidee des Entwurfsmusters "Kompositum" besteht darin, dass in einer zusammengesetzten Datenstruktur die "innen liegenden" Objekte (Fachbegriff: Kompositum, im obigen Beispiel: Knoten) und die "außen liegenden" Objekte (Fachbegriff: Blatt, im obigem Beispiel: Abschluss) Unterklassen einer abstrakten Klasse (Fachbegriff: Komponente, im obigen Beispiel: Listenelement) sind. In dieser abstrakten Klasse werden alle Methoden deklariert, die zum Verändern der Datenstruktur und zum Zugriff auf einzelne Elemente benötigt werden. Dadurch können die Kompositum-Objekte und die Blatt-Objekte im Hauptprogramm "gleich behandelt" werden.

Eine Möglichkeit zur anschaulichen Anwendung des Kompositums auf eine vertraute Struktur bietet das Dateisystem, das auf einem Laufwerk (Festplatte, USB-Stick, …) zu finden ist: Wie gewohnt kann ein Laufwerk hier Dateien und Ordner enthalten, ein Ordner wiederum (Unter-)Ordner und Dateien (die keine weiteren Objekte enthalten). Gemeinsame Methoden könnten z.B. der Ermittlung der Größe von Dateien und Ordnern dienen. Die Klasse Laufwerk steht außerhalb des Entwurfsmusters Kompositum.

Gegenüber einer Implementierung mit Knoten-Objekten aber ohne Abschluss-Objekt ergeben sich folgende Vorteile/Nachteile:

Vorteile:

• Gleichbehandlung der unterschiedlichen Listenbestandteile möglich
• Keine Überprüfung auf null-Werte mehr
• Stärkere Strukturierung

Nachteile:

• Programmieraufwand ist höher
• Mehr beteiligte Klassen
• deutlich schlechtere Performance