Objektorientierte Programmierung

Oft genannte Vorteile der OO-Programmierung:

• für Designer: der Entwurfsprozeß wird einfacher, klarer und handhabbarer.

• für Programmierer: klares Objektmodell, mächtige Programmierwerkzeuge, nützliche Bibliotheken.

• für Manager: Entwicklung und Wartung von Software wird schneller und billiger durch gesteigerte Produktivität.

Allerdings:

• OOP muß man lernen.

• Umso schwerer je tiefer die ,,prozeduralen Wurzeln`` sind.

• Gutes Design für Objekte ist nicht leicht.

Daher:

Moderne OO-Sprachen kommen mit

• Sprache
• Compiler
• Vollständige Entwicklungsumgebung
• Bibliotheken mit leicht wiederzuverwendenden Komponenten

So kann man tatsächlich mit OOP einfach und schnell zu guten Ergebnissen kommen.

Abstraktionen in Programmiersprachen

Die Komplexität der Probleme, die man lösen kann, hängt vom Grad der Abstraktion ab, den die verwendete Programmiersprache bietet:

Imperative Programmiersprachen

• Abstrahieren von der Assemblersprache
• Der Programmierer denkt eher in Begriffen der Maschine als in Begriffen des Problems.
• Zwischen Problem ( problem space) und Maschine ( solution space) muß eine Abbildung hergestellt werden.

Funktionale und logische Programmiersprachen

Man modelliert das zu lösende Problem.

• LISP: Alle Probleme sind letztendlich Listen.
• APL: Alle Probleme sind letztendlich mathematisch.
• PROLOG: Alle Probleme lassen sich durch Fakten und Regeln beschreiben.

Diese Ansätze sind gut für ihren jeweils typischen Anwendungsbereich. Außerhalb oft unpassend.

Objektorientierte Programmiersprachen

Der Programmierer beschäftigt sich mit Elementen aus der Problemstellung ( Objekten) und ihrer Darstellung im Lösungsraum. Die Anwendbarkeit ist nicht auf einen bestimmten Typ von Problemen beschränkt.

,,Reine`` objektorientierte Sprachen lassen sich wie folgt charakterisieren¹:

• Alles ist ein Objekt mit Eigenschaften und Verhalten.
• Ein Programm ist eine Menge von Objekten, die einander durch Botschaften mitteilen, was zu tun ist.
• Jedes Objekt hat sein eigenes Gedächtnis ( Zustand). Dieses Gedächtnis besteht aus anderen Objekten.
• Jedes Objekt hat einen Typ (,,ist eine Instanz einer Klasse``).
• Alle Objekte eines bestimmten Typs können die gleichen Botschaften empfangen.

Schnittstelle und Implementierung

Die Schnittstelle ( interface) eines Objektes legt fest, welche Botschaften ein Objekt verarbeiten kann.

In Java sieht dies wie folgt aus

    class Motor
    { public void on(){ ... }
      public void off(){ ... }
      public void faster(){ ... }
      public void slower(){ ... }
    }

So erzeugt man einen Motor und macht ihn an:

    Motor mo = new Motor();
    mo.on();

• mo ist ein Behälter für einen Motor.

• new Motor() erzeugt ein Objekt vom Typ Motor.

• = legt diesen Motor in den Behälter mo.

• mo.on() schickt die Botschaft on() an diesen Motor.

Die Schnittstelle stellt die Charakterisierung eines Objektes für die Öffentlichkeit dar. Versteckt sind (i.d.R.)

• Der Zustand des Objektes, gespeichert in Attributen.
• Die Implementierung der Botschaften.

Wenn die Schnittstelle sich nicht ändert, kann beides ausgetauscht werden, ohne die Anwendung zu tangieren.

Wiederverwendung

Wiederverwendung und Wiederverwendbarkeit von Klassen ist eines der Schlüssenkonzepte der objektorientierten Programmierung.

Zwei Formen:

• Komposition durch Elementobjekte
• Vererbung

Wiederverwendung durch Komposition

Einfachste Art der Wiederverwendung. Eine Klasse wird wiederverwendet, indem Objekte dieser Klasse als Elemente in anderen Klassen benutzt werden.

     class Auto 
     { Motor m;
       Rad r[];
       ...
     }

Wiederverwendung durch Vererbung

Vererbung schafft neue Klassen, die von ihrer Elternklasse alle Elemente und die Schnittstelle erben.

     class Diesel extends Motor 
     { ...
     }

Durch die Vererbung der Schnittstelle kann man an die Unterklasse die gleichen Botschaften schicken wie an die Oberklasse. Da der Typ eines Objekts definiert ist durch die Botschaften, die das Objekt versteht, folgt, daß Unter- und Oberklassenobjekte den gleichen Typ haben ( Typäquivalenz).

Einige Sprachen definieren eine ausgezeichnete Klasse, die Oberklasse aller Klassen ist. Diese Klasse ist die Wurzel der Klassenhierarchie.

Eiffel:

GENERAL

Java, Smalltalk:

Object

Vererbung allein bringt noch nichts, da Unter- und Oberklassen nicht nur die gleiche Schnittstelle sondern auch das gleiche Verhalten haben.

Zwei Möglichkeiten:

• die Unterklasse bietet weitere Methoden an:

  
  class Diesel extends Motor 
       { public void glüh() { ... }  
         // Nur für Diesel
       }
  

• die Unterklasse ändert das Verhalten einer existierenden Basisklassenmethode durch Überschreiben .

  
      class Diesel extends Motor 
           { public void on()   
             // überschreibt "on" aus "Motor"
             { glüh();
               super.on();
             }
           }
  

Je nachdem, ob die erbende Unterklasse nur Methoden überschreibt oder auch Methoden hinzufügt, haben wir zwei Ausprägungen der Beziehung:

Polymorphie

Vererbung führt bei einfacher Erbung ( single inheritance) zu baumförmigen Klassenhierarchien.

Die wichtigste Eigenschaft von Klassenhierarchien:

Polymorphie heißt Vielgestaltigkeit:

    Motor m = new Elektro();
    ....
    m = new Diesel();

Polymorphie bedeutet:

• Wir können Code schreiben, der von spezifischen Typ-Details abstrahiert.
• Wir können Klassenhierarchien erweitern, ohne Code der Oberklassen zu invalidieren.

Beispiel:

    void motor_check(Motor m)
    { m.on();
      // Motor-Diagnosen
      m.off();
    }
    ...
    Diesel d = new Diesel();
    Elektro e = new Elektro();
    motor_check(d);
    motor_check(e);

Die Formulierung von motor_check() ist typunabhängig:

Nicht

falls Benziner: tue dies;
falls Diesel: tue das;
falls Elektro: tue jenes;

Sondern

Du bist ein Motor. Du weißt selbst,
wie du auf on() reagieren mußt.

m.on() ist der Aufruf der on()-Methode, die für den jeweils gültigen Typ von m zuständig ist (z. B. on() aus Diesel).

Welcher Typ dies ist, steht erst zur Laufzeit des Programmes fest. Der Name on im Aufruf m.on() kann erst dynamisch an eine der verschiedenen on-Ausprägungen gebunden werden.

Lebensraum und Lebensdauer von Objekten

Wo leben Objekte?

Statischer Speicher und Keller:

• statisch allokiert
• schnell
• unflexibel (feste Größen)
• automatisches Aufräumen

Heap:

• dynamisch allokiert
• Aufwand für Allokation und Zugriff
• flexibel (Größe wird dynamisch festgelegt)

C++, Eiffel:

Freie Auswahl zwischen statischer und dynamischer Allokation

Java, Smalltalk, Delphi

Dynamischer Allokation.

Z.T. automatisches Aufräumen ( Garbage Collection)

Objektzugriff über Referenzen

C++

   Motor *mo = new Diesel();
   ...
   mo->on();

Referenzzugriff explizit

Java

   Motor mo = new Diesel();
   ...
   mo.on();

Referenzzugriff implizit

Referenzsemantik gilt für alle Typen (Objekte und Arrays)

außer für die Grundtypen ( int, char, ...).

Objektkopie

Objekte werden bei Referenzsemantik immer über Referenzen manipuliert.

Bei der Zuweisung

    a = b

wird also nur eine Referenz kopiert und kein Wert.

Kopie von Werten erreicht man mit

    Vector b = new Vector();
    c = b.clone();

c verweist auf ein Duplikat von b.

Voraussetzung: Vector implementiert die Methode clone().

Referenzübergabe

Objekte werden bei Referenzsemantik immer über Referenzen manipuliert.

Bei der Parameterübergabe

    swap(a,b);

werden also nur Objektreferenzen übergeben.

Vorsicht: Dies hat nichts mit Call-by-Reference zu tun, wo Adressen von Variablen übergeben werden.

Bei Referenzsemantik der Parameterübergabe funktioniert folgende swap-Funktion NICHT:

    public void swap(Object a, Object b)
    { Object tmp;
      tmp = a;
      a = b;
      b = tmp;
    }

da sie keine Effekte auf ihre aktuellen Parameter ausübt.

Container und Iteratoren

Container:

Objekt, das eine statisch unbestimmte Zahl anderer Objekte aufnehmen kann und dafür eine bestimmte Organisationsform verwendet.

Beispiel:

Schlangen, Bäume, Hash-Tabellen, u.v.a.

Container sind i.a. nicht Element der Sprache sondern Teil von Bibliotheken (C++: STL, Java: API, Delphi VCL)

Iterator:

Ein Iterator für einen Container ist ein Objekt, das dem Anwender den Inhalt des Containers sequentiell präsentiert.

Beispiel:

    Enumeration e = table.elements();
    while (e.hasMoreElements())
        doSomethingWith(e.nextElement());

Generische Typen

Generische Typen erlauben es, Typ-Definitionen mit Typen zu parametrisieren ( Parametrische Polymorphie).

So lassen sich z.B. Container für einen Typ von Inhalt spezialisieren:

C++

    template <class T>
    class Queue 
    { ...
    }
    ...
    Queue<Person> qp;

Java hat keine generischen Typen.

Abhilfe: Container des allgemeinsten Typs Object.

   Motor mo;   // ein Motor
   Queue q;    // eine Schlange von Objects
   q.enq(mo);  // mo in die Schlange

Nachteile:

• ,,wilde`` Typ-Mischung möglich
• Entnahme aus Container liefert Objekte vom Typ Object

Um entnommene Objekte verwenden zu können, brauchen wir Typanpassung entgegen der Typhierarchie ( Downcast)!

   mo = (Motor) q.deq();  // raus aus der Schlange

Gefahr:

Vielleicht ist q.deq() gar kein Motor!

Java liefert in diesem Fall eine Laufzeit-Exception. Die notwendige Prüfung kostet Laufzeit.