Objektorientiertes Design und Programmierung

Marcel Lüthi
Departement Mathematik und Informatik

Objektorientierte Programmiersprachen

Objektorientierte Design

“Pertaining to a technique or a programming language that supports objects, classes, and inheritance.”

ISO/IEC 2382-15

“OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things.”

A. Kay

Entsprechend den Sprachen wird auch das Softwaredesign objektorientiert gedacht. Nur, was ist denn eigentlich objekt-orientiert? Dier erste Definition ist eine etwas technische ISO definition. Die Definition sagt einfach, dass man Objketorientiert arbietet, wenn man eine Technik einsetzt, die Objekte, Klassen und Vererbung unterstützt. Eine etwas nützlichere Definition wird von Alan Kay, einem der Väter der Objektorientierung gebeben. Es sagt, dass es bei der Objektorientierte Programmierung vor allem um die Kommunikation zwischen Objekten geht. Objekte sollen nur via Nachrichten kommunizieren, und ihren Zustand nur lokal, also intern, halten und nicht nach aussen preisgeben. Das entspricht wieder dem Information hiding. Ausserdem, soll erst so spät we möglich entschieden werden, welches Objekt den genau eine Anfrage bearbeitet. Wir kommen später nochmals genauer auf diese Definition zurück.

Design und Programmiersprache

Wichtig beim OO Design sind Prinzipien (Information Hiding, Modularisierung, late binding), nicht die Programmiersprache.

OO Sprachen helfen Design direkt abzubilden
Nicht OO Sprachen verlangen Mehraufwand / Disziplin

Gutes Beispiel für OO Design in C: GTK+

Als erstes wollen wir aber feststellen, dass Objektorientierung nicht unbedingt an eine Programmiersprache gebunden sein muss. Das wichtige sind auch hier die Konzepte wie Information Hiding, Modularisierung oder eben diese Late binding. Objektorientierte Programmiersprache helfen uns, diese Konzepte umzusetzen. Mit etwas Mehraufwand und Disziplin kann ich jedoch in jeder Programmiersprache Objektorientiert programmieren. Ein Gutes Beispiel hierfür ist GTK+. Dieses Windowing Toolkit ist in C geschrieben. Es ist aber komplett nach Objektorientierten Prinzipien designed. Das macht auch sinn, da die stärke von Objektorientierung genau das Modularisieren und Kapseln von Objektzuständen ist. Und genau solche hat man bei der GUI Entwicklung sehr viel.

Terminologie

Klasse implementiert Abstrakten Datentyp
Daten heissen Attribute
Konstruktor kreiert neue Instanzen
Operationen heissen Methoden
Instanzvariablen sind Referenzen auf Objekte
Laufzeitstruktur die Menge der Objekte zur Laufzeit

Jedes Objekt ist zur Laufzeit eindeutig identifiziert

Bevor wir uns näher mit Objektorientiertem Design beschäftigen, müssen wir zuerst etwas Terminologie klären. Das wichtigste Konzept ist eine Klasse. Im Prinzip ist eine Klasse einfach eine Implementation eines Abstrakten Datentyps. Die Funktion, um neue Objekte, also Instanzen der Klasse zu generieren, wird Konstruktor genannt. In der OO Terminologie werden die Daten eines Objekts als Attribute bezeichnet und die Operationen die auf diesen DAten arbeiten nennt man Methoden. Um überhaupt mit einem Objekt arbeiten zu können muss ich eine Referenz auf ein Objekt haben. Eine Variable die eine solche Referenz speichert wird Instanzvariable genannt. Als Laufzeitstruktur bezeichnen wir die Menge aller Objekte, die zur Laufzeit existieren. Jedes Objekt in dieser Laufzeitstruktur hat eine eigene ID, kann also eindeutig identifiziert werden.

Schnittstellen

Nutzung der Funktionalität eines Objekts nur über wohldefinierte Schnittstellen.

Mehrere Objekte können gleiche Schnittstelle anbieten
Ein Objekt kann mehrere Schnittstellen anbieten

Beispiel aus Java:

 
                    public class ArrayList<E> extends AbstractList<E>
                            implements List<E>, 
                            RandomAccess

Wie wir bei den allgemeinen Prinzipien zum Modul design gesehen haben, sollen Module ihre Dienste immer via Schnittstellen anbieten. Diesem Prinzip wird auch in der OO Programmierung gefolgt. Die Beziehung hier ist aber nicht eins zu eins. Eine Schnittstelle kann von mehreren Objekten angeboten werden. Auch kann dasselbe Objekt mehrere Schnittstellen anbieten. Zum beispiel gibt es in Java die Klasse ArrayList. Diese Klasse kann von einem Client sowohl als Liste verwendet werdne, oder aber auch als Sequenz mit wahlfreiem Zugriff auf die Elemente, je nachdem welche Schnittstelle verwendet wird. Die Implementation ist jedoch immer dieselbe. Es ist natürlich auch möglich, das eine Schnittstelle von verschiedenen Objekten Implementiert ist. So gibt es in Java nicht nur die Klasse ArrayList die das List interface implementiert, sondern auch die Klasse Linked List.

Dynamische Bindung und Polymorphismus

Polymorphismus: Variablen können zur Laufzeit an verschiedene (verwandte) Typen gebunden werden
Dynamische Bindung (late binding): Zur Laufzeit wird Methode entsprechend dem Objekttyp verwendet.

Beispiel: Polymorphismus

 
                        interface Foo {
                            public void bar();
                        }
                        class FooImpl1 implements Foo { 
                            public void bar() { System.out.println("in FooImpl1"); }
                        }
                        class FooImpl2 implements Foo { 
                            public void bar() { System.out.println("in FooImpl2"); }
                        }
                        void doSomethingWithFoo(Foo foo) {
                            foo.bar();
                        }
                                                 
                        if (condition) 
                            doSomethingWithFoo(new FooImpl1()) 
                        else 
                            doSomethingWithFoo(new FooImpl2())

Unterschiedliche Ausgabe je nachdem ob foo an FooImpl1 oder FooImpl2 gebunden wird.

Wir wollen das an einem Beispiel illustrieren. In diesem Beispiel haben wir eine Schnittstelle Foo, die verlangt, dass die Methode bar implementiert wird. Dazu haben wir zwei Klassen, FooImpl1 und FooImpl2, welche diese Schnittstelle implementieren. Zusätzlich haben wir auch noch eine Methode doSomethingWithFoo, die ein Objekt vom Typ Foo als Argument nimmt, ohne jedoch zu sagen ob es FooImpl1 oder FooImpl2 sein soll. Late binding macht es möglich, dass in der Methode erst zur Laufzeit entschieden wird, ob die bar Methode vom Objekt FooImpl2, oder FooImpl1 genutzt wird, je nachdem, welches Objekt übergeben wird.

Objektorientierung als "Messaging"

Objekte verwalten Zustand der Daten (Attribute)
Nehmen Nachrichten/Requests entgegen (Methoden)
Senden Antwort zurück und/oder verändern Zustand

Gabriel VanHelsing, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=7560534

Methodenaufruf = senden einer Nachricht

Eine hilfreiche sicht auf die Objektorientierung ist, dass wir uns die Objekte als Inseln vorstellen mit der wir nur via Nachrichten kommunizieren können. Alle Daten vom Objekt verlassen nie diese Insel. Wenn wir nun eine Dienstleistung von dem Objekt in Anspruch nehmen wollen, können wir eine Nachricht senden. Dieses Senden der Nachricht entspricht einem Methodenaufruf. Daraufhin passiert etwas mit dem Objekt, es führt zum Beispiel eine Berechnung durch, oder verändert seinen internen Zustand (also die DAten). Das Objekt sendet als Antwort wieder ein Nachricht an das Aufrufende Objekt zurück. Die Daten bleiben dabei aber immer auf der Insel und werden nur lokal verändert. Das ist konsequentes Information hiding .

Beispiel: Methodenaufruf als Nachricht


                    class BankAccount { 
                      private FxConverter fx = new FxConverter();
                      private double balanceCHF;

                      void depositEur(double amount) { 
                        double asCHF = b.convertEurToCHF(amount))
                          this.updateBalance(balanceCHF + asCHF)
                      }
                      void updateBalance(double newBalance) {
                        balanceInCHF = newBalance;
                      }
                    }
                        
                    // somewhere in currentObject                         
                    someAccount.depositEUR(500);

OO Design - Zusammenfassung

Aufteilen eines Systems in Module
- Objekte verwalten Daten
- Zugriff nur via Methoden
Interpretation: Kommunikation via messaging
Late binding: Es wird erst zur Laufzeit entschieden welches Objekt Nachricht erhält/bearbeitet