Vererbung gegen zusätzliche Eigenschaft mit Nullwert

Ist es für Klassen mit optionalen Feldern besser, Vererbung oder eine nullfähige Eigenschaft zu verwenden? Betrachten Sie dieses Beispiel:

class Book {
    private String name;
}
class BookWithColor extends Book {
    private String color;
}

oder

class Book {
    private String name;
    private String color; 
    //when this is null then it is "Book" otherwise "BookWithColor"
}

oder

class Book {
    private String name;
    private Optional<String> color;
    //when isPresent() is false it is "Book" otherwise "BookWithColor"
}

Der Code, der von diesen drei Optionen abhängt, wäre:

if (book instanceof BookWithColor) { ((BookWithColor)book).getColor(); }

oder

if (book.getColor() != null) { book.getColor(); }

oder

if (book.getColor().isPresent()) { book.getColor(); }

Der erste Ansatz erscheint mir natürlicher, ist aber möglicherweise weniger lesbar, da Casting erforderlich ist. Gibt es einen anderen Weg, um dieses Verhalten zu erreichen?

Das hängt von den Umständen ab. Das spezifische Beispiel ist unrealistisch, da BookWithColorin einem realen Programm keine Unterklasse aufgerufen werden würde .

Im Allgemeinen sollte eine Eigenschaft, die nur für bestimmte Unterklassen sinnvoll ist, nur in diesen Unterklassen vorhanden sein.

Zum Beispiel, wenn Bookhat PhysicalBookundDigialBook als Abkömmlinge, dann PhysicalBookkönnte eine hat weightEigenschaft und DigitalBookeine sizeInKbEigenschaft. Werde DigitalBookaber nicht haben weightund umgekehrt. Bookwird keine Eigenschaft haben, da eine Klasse nur Eigenschaften haben sollte, die von allen Nachkommen geteilt werden.

Ein besseres Beispiel sind Klassen aus echter Software. Die JSliderKomponente hat das Feld majorTickSpacing. Da nur ein Schieberegler "Häkchen" hat, ist dieses Feld nur für sinnvollJSlider und seine Nachkommen . Es wäre sehr verwirrend, wenn andere Geschwisterkomponenten wie JButtonein majorTickSpacingFeld hätten.

Ein wichtiger Punkt, der anscheinend nicht erwähnt wurde: In den meisten Sprachen können Instanzen einer Klasse nicht ändern, von welcher Klasse sie stammen. Wenn Sie also ein Buch ohne Farbe hatten und eine Farbe hinzufügen möchten, müssen Sie ein neues Objekt erstellen, wenn Sie verschiedene Klassen verwenden. Und dann müssten Sie wahrscheinlich alle Verweise auf das alte Objekt durch Verweise auf das neue Objekt ersetzen.

Wenn "Bücher ohne Farbe" und "Bücher mit Farbe" Instanzen derselben Klasse sind, ist das Hinzufügen der Farbe oder das Entfernen der Farbe weniger problematisch. (Wenn Ihre Benutzeroberfläche eine Liste mit "Büchern mit Farbe" und "Büchern ohne Farbe" anzeigt, müsste sich diese Benutzeroberfläche offensichtlich ändern, aber ich würde davon ausgehen, dass Sie dies sowieso tun müssen, ähnlich einer "Liste mit roten Büchern" books "und" list of green books ").

Stellen Sie sich eine JavaBean (wie Ihre Book) als Datensatz in einer Datenbank vor. Optionale Spalten sind, nullwenn sie keinen Wert haben, aber es ist völlig legal. Daher Ihre zweite Option:

class Book {
    private String name;
    private String color; // null when not applicable
}

Ist das vernünftigste. ¹

Seien Sie jedoch vorsichtig, wie Sie die OptionalKlasse verwenden. Zum Beispiel ist dies nicht Serializableder Fall, was normalerweise ein Merkmal einer JavaBean ist. Hier einige Tipps von Stephen Colebourne :

1. Deklarieren Sie keine Instanzvariable vom Typ Optional.
2. Verwenden null , um optionale Daten im privaten Bereich einer Klasse anzugeben.
3. Verwenden Sie Optionaldiese Option für Getter, die auf das optionale Feld zugreifen.
4. Verwende nicht Optional in Setzern oder Konstrukteuren verwenden.
5. Verwendung Optionalals Rückgabetyp für alle anderen Geschäftslogikmethoden mit optionalem Ergebnis.

Daher innerhalb Ihrer Klasse sollten Sie verwenden , nullum darzustellen , dass das Feld nicht vorhanden ist, aber wenn die color Blätter des Book(als Rückgabetyp) sollte es mit einem eingewickelt werden ,Optional .

return Optional.ofNullable(color); // inside the class

book.getColor().orElse("No color"); // outside the class

Dies sorgt für klares Design und besser lesbaren Code.

¹ Wenn Sie beabsichtigen , für eine BookWithColoreine ganze „Klasse“ der Bücher zu verkapseln , die haben Fähigkeiten spezialisiert auf andere Bücher, dann wäre es sinnvoll zu nutzen Erbschaft machen.

Sie sollten entweder eine Schnittstelle (keine Vererbung) oder eine Art Eigenschaftsmechanik (möglicherweise sogar etwas, das wie das Ressourcenbeschreibungsframework funktioniert) verwenden.

Also entweder

interface Colored {
  Color getColor();
}
class ColoredBook extends Book implements Colored {
  ...
}

oder

class PropertiesHolder {
  <T> extends Property<?>> Optional<T> getProperty( Class<T> propertyClass ) { ... }
  <V, T extends Property<V>> Optional<V> getPropertyValue( Class<T> propertyClass ) { ... }
}
interface Property<T> {
  String getName();
  T getValue();
}
class ColorProperty implements Property<Color> {
  public Color getValue() { ... }
  public String getName() { return "color"; }
}
class Book extends PropertiesHolder {
}

Klarstellung (bearbeiten):

Fügen Sie einfach optionale Felder in die Entitätsklasse ein

Vor allem mit dem Optional-Wrapper (edit: siehe 4castle -Antwort) halte ich dies (Hinzufügen von Feldern in der ursprünglichen Entität) für eine praktikable Möglichkeit, neue Eigenschaften in kleinem Maßstab hinzuzufügen. Das größte Problem bei diesem Ansatz ist, dass er möglicherweise gegen eine geringe Kopplung wirkt.

Stellen Sie sich vor, Ihre Buchklasse ist in einem speziellen Projekt für Ihr Domain-Modell definiert. Nun fügen Sie ein weiteres Projekt hinzu, das das Domänenmodell für eine spezielle Aufgabe verwendet. Diese Aufgabe erfordert eine zusätzliche Eigenschaft in der Buchklasse. Entweder haben Sie die Vererbung (siehe unten) oder Sie müssen das allgemeine Domänenmodell ändern, um die neue Aufgabe zu ermöglichen. In letzterem Fall kann es vorkommen, dass Sie eine Reihe von Projekten haben, die alle von ihren eigenen Eigenschaften abhängen, die der Buchklasse hinzugefügt wurden, während die Buchklasse selbst in gewisser Weise von diesen Projekten abhängt, da Sie die Buchklasse ohne die nicht verstehen können zusätzliche Projekte.

Warum ist die Vererbung problematisch, wenn es darum geht, zusätzliche Eigenschaften bereitzustellen?

Wenn ich Ihre Beispielklasse "Buch" sehe, denke ich an ein Domänenobjekt, das häufig viele optionale Felder und Untertypen enthält. Stellen Sie sich vor, Sie möchten eine Eigenschaft für Bücher hinzufügen, die eine CD enthalten. Es gibt jetzt vier Arten von Büchern: Bücher, Bücher mit Farbe, Bücher mit CD, Bücher mit Farbe und CD. Sie können diese Situation nicht mit Vererbung in Java beschreiben.

Mit Schnittstellen umgehen Sie dieses Problem. Sie können die Eigenschaften einer bestimmten Buchklasse einfach über Schnittstellen zusammenstellen. Durch Delegation und Komposition wird es einfach, genau die Klasse zu erhalten, die Sie möchten. Bei der Vererbung erhalten Sie normalerweise einige optionale Eigenschaften in der Klasse, die nur vorhanden sind, weil eine Geschwisterklasse sie benötigt.

Lesen Sie weiter, warum Vererbung oft eine problematische Idee ist:

Warum wird Vererbung von OOP-Befürwortern im Allgemeinen als eine schlechte Sache angesehen?

JavaWorld: Warum sich ausdehnt, ist böse

Das Problem beim Implementieren einer Reihe von Schnittstellen zum Erstellen einer Reihe von Eigenschaften

Wenn Sie Schnittstellen zur Erweiterung verwenden, ist alles in Ordnung, solange Sie nur einen kleinen Satz davon haben. Insbesondere wenn Ihr Objektmodell von anderen Entwicklern verwendet und erweitert wird, z. B. in Ihrem Unternehmen, wird die Anzahl der Schnittstellen zunehmen. Und schließlich erstellen Sie eine neue offizielle "Eigenschaftsschnittstelle", die eine Methode hinzufügt, die Ihre Kollegen bereits in ihrem Projekt für Kunde X für einen völlig unabhängigen Anwendungsfall verwendet haben - Ugh.

edit: Ein weiterer wichtiger Aspekt wird von gnasher729 erwähnt . Oft möchten Sie einem vorhandenen Objekt optionale Eigenschaften dynamisch hinzufügen. Mit Vererbung oder Schnittstellen müssten Sie das gesamte Objekt mit einer anderen Klasse neu erstellen, die alles andere als optional ist.

Wenn Sie Erweiterungen Ihres Objektmodells in einem solchen Ausmaß erwarten, sind Sie besser dran, wenn Sie explizit die Möglichkeit einer dynamischen Erweiterung modellieren . Ich schlage so etwas wie oben vor, wo jede "Erweiterung" (in diesem Fall Eigenschaft) eine eigene Klasse hat. Die Klasse fungiert als Namespace und Bezeichner für die Erweiterung. Wenn Sie die Paketnamenskonventionen entsprechend festlegen, werden auf diese Weise unendlich viele Erweiterungen ermöglicht, ohne dass der Namespace für Methoden in der ursprünglichen Entitätsklasse verschmutzt wird.

In der Spieleentwicklung stoßen Sie häufig auf Situationen, in denen Sie Verhalten und Daten in vielen Variationen zusammenstellen möchten. Aus diesem Grund wurde das Architekturmuster Entity-Component-System in Spielentwicklungskreisen sehr beliebt. Dies ist auch ein interessanter Ansatz, den Sie sich ansehen sollten, wenn Sie viele Erweiterungen für Ihr Objektmodell erwarten.

Wenn BookKlasse ohne Farbeigenschaft wie unten abgeleitet werden kann

class E_Book extends Book{
   private String type;
}

dann ist Vererbung sinnvoll.