homedukeOOP mit Java: Vererbung oder Benutzung Prof. Dr. Uwe Schmidt FH Wedel
Software-technische Aspekte
Kopieren von Verweisen und ObjektenInhaltsverzeichnisDynamische Datenstrukturen und Containerklassen

Vererbung oder Benutzung

weiter
weiter

Implementierung eigener Klassen durch Vererbung

Beispiel
Implementierung eines Stack mit einer Liste mit Hilfe von Vererbung
weiter
List
die Beispiel-Klasse für Listen.
 
Jede Klassenbibliothek für ADTs enthält solche Klassen, das JDK zum Beispiel die Klasse Vector im Paket java.util
 
public
class List {
 
  // ... Datenfelder
 
  // Konstruktoren
 
  public
  List() { /*...*/ }
 
  public
  List(Object e) { /*...*/ }
 
  //--------------------
  // Selektoren, Attribute und Praedikate
 
  public
  boolean isEmpty() { /*...*/ }
 
  public
  Object hd() { /*...*/ }
 
  public
  Object get(int i) { /*...*/ }
 
  public
  int length() { /*...*/ }
 
  //--------------------
  // zustandsmodifizierende Methoden
 
  public
  void tl() { /*...*/ }
 
  public
  void append(Object e) { /*...*/ }
 
  public
  void prepend(Object e) { /*...*/ }
 
  public
  void append(List l2) { /*...*/ }
}
weiter
merke
diese vorgefertigten oder gekauften Klassen bieten meistens eine breite Schnittstelle mit vielen Methoden an:
allgemeine Einsetzbarkeit
weiter
StackInheritsList
die eigene Klasse für einen Keller
 
public
class StackInheritsList
  extends List
{
  // keine eigenen Datenfelder
 
  public StackInheritsList() {
    super();            // redundant
  }
 
  //--------------------
  // isEmpty wird geerbt
  // alle anderen werden
  // auf List Operationen zurueckgefuehrt
 
  public
  Object top() {
    return
      hd();
  }
 
  public
  void pop() {
    tl();
  }
 
  public
  void push(Object e) {
    prepend(e);
  }
}
weiter
merke
Vererbung ist bequem, nur die noch nicht vorhandenen Methoden müssen implementiert werden
weiter
merke
Vererbung verhindert das Verstecken von Information:
alle öffentlichen Methoden aus der beerbten Klasse stehen einem Kunden zur Verfügung
weiter
weiter

Implementierung eigener Klassen durch Benutzung

Beispiel
die Ausgangsklasse bleibt
weiter
StackUsesList
die eigene Klasse für einen Keller
 
public
class StackUsesList // keine Vererbung
{
  // ein Datenfeld
 
  private
  List s;
 
  public StackUsesList() {
    s = new List();
  }
 
  //--------------------
  // isEmpty wird nicht geerbt
 
  // alle Methoden delegieren
  // ihre Arbeit an das List Objekt s
 
  public
  boolean isEmpty() {
    return
      s.isEmpty();
  }
 
  public
  Object top() {
    return
      s.hd();
  }
 
  public
  void pop() {
    s.tl();
  }
 
  public
  void push(Object e) {
    s.prepend(e);
  }
}
weiter
merke
Benutzung erzwingt information hiding:
nur die eigenen Methoden sind zulässig.
weiter
merke
Benutzung erfordert die Implementierung aller Methoden:
Mehraufwand
weiter
merke
bei Benutzung wird die Arbeit delegiert:
Effizienzverlust
weiter
merke
Benutzung führt zu schmalen Schnittstellen, nur die für die eigene Aufgabe benötigten Methoden werden entwickelt:
Verständlichkeit
weiter
merke
bei der Verwendung von fremden Klassenbibliotheken kann es sinnvoll sein, diese ausschließlich in eigenen Basisklassen zu verwenden. So kann die Abhängigkeit zu fremden Klassen an wenigen Stellen konzentriert werden:
Die fremden Klassenbibliotheken werden austauschbar.
weiter
SeitenanfangSoftware-technische Aspekte
Kopieren von Verweisen und ObjektenInhaltsverzeichnisDynamische Datenstrukturen und Containerklassen
Letzte Änderung: 14.02.2012
© Prof. Dr. Uwe Schmidt
Prof. Dr. Uwe Schmidt FH Wedel