OOP mit Java: Objektorientierte Programmierung

Bestehende Klassen können ohne physikalisches Kopieren erweitert werden.

Beispiel:

public
class ExtendedStack
  extends SimpleStack {
 
  // der Konstruktor
  // in diesem einfachen Fall ueberfluessig
 
  public
  ExtendedStack() {
      super();  // redundant
  }
 
  //--------------------
  // die zusaetzliche Funktion
 
  public
  int get() {
      int i = top();
      pop();
      return i;
  }
}

Modifikation

	Konstruktoren müssen normalerweise immer in Unterklassen neu implementiert werden, Ausnahme ist der default-Konstruktor.
	Der Beerbungsprozess kann beliebig oft wiederholt werden.

Bestehende Klassen können mit Vererbung und Redefinition von Methoden in ihrer Funktionalität verändert werden.

Beispiel:

public
class SaveStack
  extends SimpleStack {
 
  // die modifizierte top Methode
 
  public
  int top() {
    if ( ! preTop() ) 
      throw
        new RuntimeException("top with empty stack");
 
    return
      super.top();
  }
 
  //--------------------
  // die modifizierte pop Methode
 
  public
  Stack pop() {
    if ( ! prePop() ) 
      throw
        new RuntimeException("pop with empty stack");
 
    return
      super.pop();
  }
}

Erweiterung um Datenkomponenten

	Die überschriebenen Methoden können immer noch erreicht werden. Das Schlüsselwort super schaltet auf den Namensraum der Oberklasse um.

Bestehende Klassen können mit Vererbung um Datenkomponenten erweitert werden

Beispiel:

public
class Point {
 
  public
  int x;
 
  public
  int y;
 
  public
  Point() {
    this(0,0);
  }
 
  public
  Point(int x, int y) {
    this.x = x;
    this.y = y;
  }
}

Erweiterung:

public
class ColoredPoint
  extends Point {
 
  public
  int color;
 
  ColoredPoint() {
    super();            // redundant: default
    color = 0;
  }
 
  ColoredPoint(int x, int y, int color) {
    super(x,y);
    this.color = color;
  }
}

Sichtbarkeitsattribute

	Es können nur zusätzliche Datenfelder definiert werden. Eine Redefinition ist nicht möglich.
	Überdeckte Felder können immer noch über super erreicht werden.

private	Variablen und Methoden einer Klasse sind nur innerhalb der Klasse selbst sichtbar.

	diese Komponenten können verändert werden, ohne dass Unterklassen davon beeinflusst werden. Sicherheit, Modularität

	abgeleitete Klassen können die Information aus den private-Komponenten ihrer Basisklassen nicht zur Implementierung ihrer eigenen Operationen ausnutzen. Effizienzverlust möglich

protected	Variablen und Methoden einer Klasse sind innerhalb der Klasse selbst und in Unterklassen sichtbar. Außerdem sind diese Größen im zur Klasse gehörigen Paket sichtbar.

	Wenn diese Komponenten verändert werden, müssen möglicherweise abgeleitete Klassen und Klassen aus dem zugehörigen Paket modifiziert werden.

	Wartungsaufwand kann sich erhöhen

	Effizienz kann verbessert werden

Beispiel	class ProtectedSimpleStack extends Stack{ // die Datenfelder // fuer Unterklassen sichtbar protected int [] a; protected int i; ... }

effizientere get() Methode	public class ProtectedExtendedStack extends ProtectedSimpleStack { public int get() { return a[i--]; } }

default	friendly Variablen und Methoden einer Klasse sind in dem zur Klasse gehörigen Paket sichtbar.

	Wenn diese Komponenten verändert werden, müssen möglicherweise Klassen aus dem zugehörigen Paket modifiziert werden.

public	Variablen und Methoden einer Klasse sind überall sichtbar

	Sinnvoll nur für Methoden, Konstanten und Variablen, die nie verändert werden, sonst keine Zugriffskontrolle mehr für Variablen.

final	als Attribut für Klassen verhindert weiteres Beerben.

Beispiel	für eine Klasse, die nicht mehr beerbt werden kann:
	public final class ExtendedStack extends SimpleStack { ... }
	im JDK z.B. für `Integer` verwendet.

final	als Attribut für Methoden verhindert das Überschreiben von Methoden

Beispiel	für eine nicht weiter modifizierbare Methode
	class X { public final void foo() {} } class Y extends X { public void foo() {} }
Fehlermeldung	Final methods can't be overridden. Method void foo() is final in class X.
	im JDK z.B. für getClass() aus `Object` verwendet.

Objektorientierte Programmierung

Erweiterbarkeit

Modifikation

Erweiterung um Datenkomponenten

Sichtbarkeitsattribute