Grundkonzepte Objektorientierter Programmierung

Grundkonzepte Objektorientierter Programmierung Beispiele in Java, Oberon-2, Python und Delphi Projektarbeit im Studiengang Lehramt Informatik Sommersemester 2006 Friedrich-Schiller-Universität Jena erstellt von Nicole Himmerlich 2006

Inhaltsverzeichnis 1 Konzepte und Begrie der Objektorientierung 1 2 Beispiel: Konto 3 2.1 Aggregierung und enge Kopplung......................... 3 2.2 Datenkapselung................................... 7 2.3 Konstruktor..................................... 10 2.4 Klassen- und instanzspezische Komponenten.................. 13 2.5 Manipulierbarkeit.................................. 17 2.6 Vererbung...................................... 19 2.7 Reimplementierung................................. 25 2.8 Polymorphismus.................................. 28 2.9 Überladen...................................... 30 3 Beispiel: Mediendatenbank 33 4 Beispiel: geometrische Figuren 46 A Python-Quellcode 58 A.1 Beispiel: Konto................................... 58 A.2 Beispiel: Mediendatenbank............................. 63 A.3 Beispiel: geometrische Figuren........................... 65 B Delphi-Quellcode 67 B.1 Beispiel: Konto................................... 67 B.2 Beispiel: Mediendatenbank............................. 79 B.3 Beispiel: geometrische Figuren........................... 82

1 Konzepte und Begrie der Objektorientierung Die Prädicate der Erscheinung können dem Objecte selbst beigelegt werden, in Verhältniÿ auf unseren Sinn, z.b. der Rose die rothe Farbe, oder der Geruch; [...] 1 Immanuel Kant Wie wir uns räumliche Gegenstände überhaupt nicht auÿerhalb der Zeit denken können, so können wir uns keinen Gegenstand auÿerhalb der Möglichkeiten seiner Verbindung mit anderen denken. 2 Ludwig Wittgenstein Die obigen Zitate zeigen, dass objektorientiertes Denken keine Erndung der Informatik ist, vielmehr gehen wir alle täglich mit Objekten um. [Somit ist Objektorientierung] für uns Menschen eine natürliche Betrachtungsweise. Wir wissen, dass Objekte Eigenschaften und ein Verhalten besitzen und aus anderen Objekten zusammengesetzt sein können. Wir betrachten von einem Objekt nur gerade soviel, wie uns im Moment interessiert und fassen gleichartige Objekte in Gruppen zusammen. 3 Die Informatik hat diese Betrachtungsweise aufgegrien und zu einem Programmierparadigma entwickelt. Der Begri Objekt umfasst Gegenstände, Personen, Sachverhalte oder Ereignisse. Jedes einzelne Objekt lässt sich durch drei Aspekte charakterisieren: es besitzt einen eindeutigen Zustand, ein wohldeniertes Verhalten und eine Identität. Der Zustand eines Objektes repräsentiert alle seine relevanten Eigenschaften und ist durch eine Menge von Attributen und deren Werte bestimmt. Durch sie wird die Struktur der Objekte vereinbart. Die Attributmenge eines Objektes ändert sich normalerweise nicht, die konkreten Werte sind jedoch veränderlich. Das Verhalten wird in der objektorientierten Programmierung durch eine Menge von Methoden beschrieben. Sie bestimmen die Art und Weise, in der ein Objekt in Abhängigkeit von seinem Zustand, auf Einwirkungen reagiert und können Attributwerte manipulieren. Die Identität eines Objektes ist diejenige Eigenschaft, die es von allen anderen Objekten unterscheidet. Sie stellt sicher, dass alle Objekte unterscheidbar sind, auch wenn sie zufällig identische Attributwerte besitzen. Dabei muss gerade in der Softwareenticklung zwischen dem Namen eines Objektes und seiner Identität dierenziert werden, da der Name der Adressierung dient und ein einzelnes Objekt über verschiedene Namen angesprochen werden kann. Objekte können nach bestimmten Kriterien gruppiert werden. Statt jedes Objekt einzeln zu beschreiben, werden gemeinsame Merkmale in Klassen zusammengefasst. Eine Klasse ist somit eine abstrakte Beschreibung der Struktur und des Verhaltens von gleichartigen Objekten. Ein konkretes Objekt wird dann auch als Instanz einer Klasse bezeichnet. 1 Quelle?? 2 Quelle?? 3 Lüscher/Straubinger 1996 [LS96, S.4]. 1

Zu den Grundprinzipien der objektorientierten Programmierung gehören noch weitere Konzepte: ˆ Aggregierung ˆ Kopplung ˆ Kapselung und Information Hiding ˆ Konstruktoren und Destruktoren ˆ Instanz- und klassenspezische Komponenten ˆ Vererbung ˆ Mehrfachvererbung ˆ Reimplementierung ˆ Polymorphismus ˆ Dynamisches Binden ˆ Abstrakte Klassen ˆ Generische Klassen ˆ Assoziation ˆ Aggregation ˆ Komposition Einige dieser Konzepte werden im Folgenden anhand einfacher Beispiele näher erläutert. Auf eine ausführliche Darstellung der anderen Prinzipien wird verzichtet. Sie sind hier nur erwähnt, um die Vielfalt objektorientierter Programmierung zu verdeutlichen. 2

2 Beispiel: Konto Zur näheren Erläuterung zentraler Eigenschaften objektorientierter Programmierung soll zunächst ein Bankkonto schrittweise modelliert werden. Jedes Bankkonto besitzt üblicherweise eine eindeutige Kontonummer und einen aktuellen Kontostand. Natürlich sind noch weitere Kennzeichen - z.b. Kontoinhaber - denkbar. Sie werden jedoch zunächst vernachlässigt, damit die Quelltexte überschaubar bleiben. Typische Aktionen, die auf einem Konto ausgeführt werden, sind das Ein- bzw. Auszahlen von Geldbeträgen und das Drucken eines Kontoauszugs. 2.1 Aggregierung und enge Kopplung In der prozeduralen Programmierung werden zunächst die für die Beschreibung der Daten notwendigen Datenstrukturen geschaen und danach werden die Funktionen entwickelt, mit deren Hilfe die Inhalte der vorhandenen Datenstrukturen ausgegeben bzw. manipuliert werden können. Obwohl sich die Funktionen auf die Datenstrukturen beziehen, können Daten und Funktionen nicht als eine Einheit betrachtet werden. Insbesondere wenn mehrere Datenstrukturen deklariert werden müssen, ist die Zuordnung der Funktionen nicht sofort ersichtlich. In der objektorientierten Programmierung werden zusammengehörige Attribute (Daten) und Methoden (Funktionen) zu einer manipulierbaren Gröÿe - einer Klasse - zusammengefasst. Sie bilden sozusagen ein Aggregat 4, dessen Komponenten aufeinander Bezug nehmen können. In unserem Beispiel werden alle notwendigen Attribute und Methoden für ein Bankkonto in der Klasse Konto zusammengefasst, so dass sich das in Abb. 1 gezeigte Modell ergibt. Die Methoden einzahlen(betrag) und auszahlen(betrag) verändern den Kontostand eines Bankkontos, d.h. sie müssen auf das Attribut saldo zugreifen und dessen Wert verändern. Die Methode auszug() bezieht sich sogar auf die beiden Attribute der Klasse, da sie kontonummer und saldo ausgibt. Daran zeigt sich die enge Kopplung zwischen Attributen und Methoden. Abbildung 1: Klasse Konto 4 In der Literatur wird häug der Begri Kapselung verwendet. Um Verwechselungen mit dem Begri Datenkapselung - im Sinne des Information Hiding - zu vermeiden, wird hier der Begri Aggregierung (ein Aggregat bilden) benutzt. 3

Java In Java wird ein Klasse über das Schlüsselwort class deniert. Alle Variablen, Funktionen bzw. Prozeduren, die innerhalb der geschweiften Klammern deniert werden, gehören damit zur Klasse und bilden deren Attribute und Methoden. Innerhalb einer Klasse können Attribute und Methoden direkt über ihren Namen angesprochen werden. Eine Quelldatei sollte nur eine Klassendenition enthalten und den gleichen Namen wie die Klasse tragen. //Datei: Konto1/Konto.java //Beispiel : Aggregierung und Kopplung // > Aggregierung class Konto{ // Attribute int kontonummer; double saldo; // Methoden void einzahlen(double betrag){ saldo = saldo + betrag; // > Kopplung void auszahlen(double betrag){ saldo = saldo betrag; // >Kopplung void auszug(){ System.out.println("Kontonummer: "+kontonummer+" Saldo: "+saldo+" Euro"); Java ist eine rein objektorientierte Sprache, so dass jedes Programm eine Klasse deniert. Deshalb wird das Testprogramm für die Klasse Konto in eine Klasse KontoTest eingebettet, die nur die Methode main enthält. Um von der Klasse Konto ein Objekt bzw. eine Instanz zu erzeugen, wird eine Variable vom Typ Konto deklariert. Der Operator new legt, mit Hilfe der vom Compiler erzeugten Methode Konto(), ein neues Konto-Objekt an, das anschlieÿend der Variablen meinkonto zugewiesen wird. Dabei gilt: Variablen, deren Typ eine Klasse ist, enthalten nicht das eigentliche Objekt, sondern nur einen Adressverweis auf dessen Speicherplatz. Insbesondere bedeutet dies, dass in meinkonto nur die Speicheradresse des Objektes abgelegt ist (siehe Abb. 2). Für den Zugri auf Attribute oder Methoden eines Objektes wird eine Punktnotation verwendet. Attribute können mittels Referenz.Attribut gelesen und deren Werte verändert werden. Methoden werden durch Referenz.Methode() aufgerufen. Abbildung 2: Objektreferenz 4

// Datei: Konto1/KontoTest.java // Beispiel : Aggregierung und Kopplung public class KontoTest{ public static void main(string[] args){ Konto meinkonto; // Variable vom Typ Konto meinkonto = new Konto(); // new erzeugt Instanz der Klasse Konto meinkonto.kontonummer = 4531088; // Zugri auf Attribute meinkonto.saldo = 200.00; System.out.println("Kontonummer: "+meinkonto.kontonummer +" Saldo: "+ meinkonto.saldo); meinkonto.einzahlen(300.00); // Methodenaufruf meinkonto.auszug(); System.out.println(); Konto deinkonto = new Konto(); // deinkonto zeigt auf neue Instanz der Klasse Konto deinkonto.kontonummer = 1733065; deinkonto.saldo = 1000.00; deinkonto.auszug(); deinkonto.auszahlen(100.00); deinkonto.auszug(); Oberon-2 Oberon-2 verwendet sogenannte typgebundene Prozeduren, um die Zugehörigkeit der Methoden zur Klasse deutlich zu machen. Die Attribute einer Klasse werden als Felder eines Recordtyps dargestellt. Da Oberon nicht automatisch mit Referenzvariablen arbeitet, wird auÿerdem ein Referenztyp zum Recordtyp der Klasse deniert. Die Implementierung der Methoden muss zusätzlich einen speziellen Parameter vor dem Prozedurnamen besitzen. Dieser Parameter wird Empfänger genannt und repräsentiert das Objekt, für das die Methode aufgerufen wird. Der Typ des Empfängers gibt an, zu welcher Klasse die Methode gehört. Im Prozedurrumpf wird der Empfänger genutzt, um auf die Attribute der Klasse zuzugreifen. Dabei wird wieder die Punktnotation (Empfänger.Attribut) angewendet. In Oberon-2 müssen zunächst alle Datentypen deklariert werden, bevor Prozeduren implementiert werden können. Deshalb sollte jede Klasse in einem separaten Modul beschrieben werden. Sind mehrere Klassendenitionen in einem Modul enthalten, geht schnell die Übersichtlichkeit verloren und es ist nicht mehr klar erkennbar, welche Methoden zu welchem Datentyp gehören. (* Datei: Konto1/Konto.mod *) (* Beispiel : Aggregierung und Kopplung *) MODULE Konto; IMPORT Out; TYPE (* Attribute *) Konto* = RECORD kontonummer* : LONGINT; saldo * : REAL END; 5

(* zugehoeriger Referenztyp *) KontoRef* = POINTER TO Konto; (* Methoden *) (* > Aggregierung durch typgebundene Prozeduren*) PROCEDURE (k : KontoRef) einzahlen*(betrag : REAL); k.saldo := k.saldo + betrag; (* > Kopplung *) END einzahlen; PROCEDURE (k : KontoRef) auszahlen*(betrag : REAL); k.saldo := k.saldo betrag; (* > Kopplung *) END auszahlen; PROCEDURE (k : KontoRef) auszug*(); Out.String("Kontonummer: "); Out.Int(k.kontonummer, 10); Out.String(" Saldo: "); Out.Real(k.saldo, 10); Out.String(" Euro"); Out.Ln; END auszug; END Konto. Um eine Instanz der Klasse Konto zu erzeugen, wird eine Variable vom Typ KontoRef deklariert. Der Aufruf NEW(meinKonto) legt ein Objekt vom Typ Konto an, d.h. er stellt entsprechenden Speicherplatz zur Verfügung. Zudem bewirkt er, dass meinkonto auf dieses Objekt verweist. Über die Variable meinkonto können die Attribute der Instanz angesprochen werden (meinkonto.attribut). Für den Aufruf von Methoden wird ebenfalls die Punktnotation (meinkonto.methode()) verwendet. (* Datei: Konto1/KontoTest.mod *) (* Beispiel : Aggregierung und Kopplung *) MODULE KontoTest; IMPORT Konto, Out; PROCEDURE ProgMain*(); VAR meinkonto, deinkonto : Konto.KontoRef; (* Variablen vom Referenztyp Konto *) NEW(meinKonto); (* NEW erzeugt Instanz der Klasse Konto *) meinkonto.kontonummer := 4531088; (* Zugri auf Attribute *) meinkonto.saldo := 200.00; Out.String("Kontonummer: "); Out.Int(meinKonto.kontonummer, 10); Out.String(" Saldo: "); Out.Real(meinKonto.saldo, 10); Out.Ln; meinkonto.einzahlen(300.00); (* Methodenaufruf *) meinkonto.auszug(); Out.Ln; NEW(deinKonto); (* deinkonto zeigt auf neue Instanz der Klasse Konto *) deinkonto.kontonummer := 1733065; deinkonto.saldo := 1000.00; deinkonto.auszug(); 6

deinkonto.auszahlen(100.00); deinkonto.auszug(); END ProgMain; END KontoTest. 2.2 Datenkapselung Das Prinzip der Datenkapselung wurde bereits 1972 von David Parnas propagiert 5. Er prägte damals den Begri Information Hiding. Im Deutschen wird oft die Bezeichnung Geheimnisprinzip verwendet. Für den Benutzer einer Klasse ist relevant, wie er eine Komponente verwenden kann, nicht wie sie realisiert ist. Deshalb wird die Struktur eines Objektes und die Implementierung der Methoden nicht oen gelegt, sondern in der Klasse verborgen. Der Zugri auf die gekapselten Attribute und deren Manipulation ist dann ausschlieÿlich über die Methoden der Klasse durchführbar. So wird sichergestellt, dass Attributwerte nicht willkürlich geändert und nur zulässige Werte gespeichert werden. Das Verstecken der Implementierungsdetails vermindert die Fehleranfälligkeit, da ein unerwarteter Zugri unmöglich ist. Änderungen der Implementierung haben keine Auswirkung auf den Nutzer, da dieser die Zugrismethoden weiterhin verwenden kann. Im Fall der Klasse Konto sollen die Attribute kontonummer und saldo vor unkontrolliertem Zugri geschützt werden. Da das Lesen und Verändern der Attribute aber zunächst noch möglich sein soll, werden neue Methoden benötigt. Die Methoden getkontonummer() und setkontonummer(nummer) ermöglichen Lese- und Schreibzugri auf das Attribut kontonummer. Für die Manipulation von saldo wurden die Operationen getsaldo() und setsaldo(betrag) deniert. Java Die Zugrisrechte werden in Java über sogenannte Modizierer festgelegt. Wird ein Attribut ohne Zusatz deklariert, so ist es in allen Klassen des deklarierenden Paketes 6 sichtbar, nicht jedoch in anderen Paketen. Das Schlüsselwort public erlaubt lesenden und schreibenden Zugri, d.h. die Attribute sind in allen Paketen sichtbar. Sollen Attribute nur innerhalb der Klasse sichtbar sein, so müssen sie mit dem Modizierer private gekennzeichnet werden. Da die Attribute kontonummer und saldo versteckt werden sollen, sind sie ab sofort mit dem Vorsatz private versehen. Modizierer regeln auch die Sichtbarkeit von Methoden. Da die Methoden der Klasse Konto in jedem Paket zugänglich sein sollen, müssen sie als public deklariert werden. 5 Das Konzept der Datenkapselung ist ein wichtiges Prinzip der Informatik, das nicht nur in der objektorientierten Programmierung eingesetzt wird. 6 Pakete bestehen aus mehreren Klasse, die zu einer gröÿeren Einheit zusammengefasst werden. Um eine Klasse einem bestimmten Paket zuzuordnen muss die Anweisung package Paketname; als erste Anweisung im Quellcode stehen. 7

Das Schlüsselwort public kann auch auf Klassen angewendet werden. Klassen, die mit public gekennzeichnet sind, können überall benutzt werden. In einer Quelldatei darf jedoch höchstens eine Klasse als public deklariert werden. //Datei: Konto2/Konto.java //Beispiel : Datenkapselung public class Konto{ private int kontonummer; // > Datenkapselung private double saldo; // neue Methoden fuer sicheren Zugri auf Attribut kontonummer public int getkontonummer(){ return kontonummer; public void setkontonummer(int nummer){ kontonummer = nummer; // neue Methoden fuer sicheren Zugri auf Attribut saldo public double getsaldo(){ return saldo; public void setsaldo(double betrag){ saldo = betrag; // urspruengliche Methoden public void einzahlen(double betrag){ saldo = saldo + betrag; public void auszahlen(double betrag){ saldo = saldo betrag; public void auszug(){ System.out.println("Kontonummer: "+kontonummer+" Saldo: "+saldo+" Euro"); Auÿerhalb der Klasse Konto ist ein direkter Zugri auf die Attribute kontonummer und saldo nicht mehr möglich. Der Befehl meinkonto.kontonummer = 4531088 führt zu einem Fehler bei der Übersetzung. Sogar der Versuch, lesend auf die Variable zuzugreifen erzeugt eine Fehlermeldung. Die Attribute können nur über entsprechende Methoden angesprochen werden. //Datei: Konto2/KontoTest.java //Beispiel : Datenkapselung public class KontoTest{ public static void main(string[] args){ Konto meinkonto = new Konto(); /* meinkonto.kontonummer = 4531088;!! Fehler System.out.println(meinKonto.kontonummer);!! Fehler */ meinkonto.setkontonummer(4531088); // schreibender Zugri auf Attribute ueber entsprechende Methoden meinkonto.setsaldo(200.00); System.out.print("Kontonummer: "+meinkonto.getkontonummer()); // lesender Zugri System.out.println(" Saldo: "+meinkonto.getsaldo()+" Euro"); 8

Oberon-2 In Oberon-2 werden Attribute und Methoden nur dann exportiert, wenn sie in ihrer Deklaration mit einem Stern (*) markiert sind. Wird die Markierung weggelassen, so sind die Namen nur innerhalb des Moduls sichtbar, in der die Klasse implementiert wird. Andere Module, die das Modul importieren, können nur auf die exportierten Attribute und Methoden zugreifen. In der Klasse Konto wird, der Stern an den Attributen kontonummer und saldo entfernt. Der Name des Record, der zugehörige Referenztyp und die Methoden sollen weiterhin sichtbar sein und behalten deshalb ihre Markierung. (* Datei: Konto2/Konto.mod *) (* Beispiel : Datenkapselung *) MODULE Konto; IMPORT Out; TYPE Konto* = RECORD kontonummer : LONGINT; (* > Datenkapselung *) saldo : REAL END; KontoRef* = POINTER TO Konto; (* neue Methoden fuer sicheren Zugri auf Atrribut kontonummer *) PROCEDURE (k : KontoRef) getkontonummer*() : LONGINT; RETURN k.kontonummer; END getkontonummer; PROCEDURE (k : KontoRef) setkontonummer*(nummer : LONGINT); k.kontonummer := nummer; END setkontonummer; (* neue Methoden fuer sicheren Zugri auf Atrribut saldo *) PROCEDURE (k : KontoRef) getsaldo*() : REAL; RETURN k.saldo; END getsaldo; PROCEDURE (k : KontoRef) setsaldo*(betrag : REAL); k.saldo := k.saldo + betrag; END setsaldo; (* urspruengliche Methoden *) PROCEDURE (k : KontoRef) einzahlen*(betrag : REAL); k.saldo := k.saldo + betrag; END einzahlen; PROCEDURE (k : KontoRef) auszahlen*(betrag : REAL); k.saldo := k.saldo betrag; END auszahlen; PROCEDURE (k : KontoRef) auszug*(); Out.String("Kontonummer: "); Out.Int(k.kontonummer, 10); Out.String(" Saldo: "); Out.Real(k.saldo, 10); Out.String(" Euro"); Out.Ln; 9

END auszug; END Konto. Die Namen kontonummer und saldo werden vom Modul Konto nicht mehr exportiert. Die Verwendung dieser Namen im Modul KontoTest führt deshalb zu der Fehlermeldung Error 83: undened record eld. Um die Attribute trotzdem zu bearbeitet, benutzt man die set- und get-methoden. (* Datei: Konto2/KontoTest.mod *) (* Beispiel : Datenkapselung *) MODULE KontoTest; IMPORT Konto, Out; PROCEDURE ProgMain*(); VAR meinkonto : Konto.KontoRef; NEW(meinKonto); (* meinkonto.kontonummer = 4531088;!! Fehler Out.Int(meinKonto.kontonummer);!! Fehler *) meinkonto.setkontonummer(4531088); (* schreibender Zugri auf Attribute ueber entsprechende Methoden *) meinkonto.setsaldo(200.00); Out.String("Kontonummer: "); Out.Int(meinKonto.getKontonummer(),10); (* lesender Zugri *) Out.String(" Saldo: "); Out.Real(meinKonto.getSaldo(),10); Out.String(" Euro"); END ProgMain; Out.Open END KontoTest. 2.3 Konstruktor Konstruktoren sind spezielle Methoden einer Klasse, die immer dann zum Einsatz kommen, wenn ein neues Objekt erzeugt werden soll. Sie sind eine elegante Möglichkeit, Objekte zu initialisieren, können aber auch individuelles Verhalten implementieren. Die Klasse Konto erhält einen Konstruktor, der als Parameter eine Nummer übergeben bekommt. Diese Nummer dient dem Konstruktor als Initialwert für das Attribut kontonummer. Die Methode setkontonummer(nummer) wird gelöscht, da eine Kontonummer einmalig bei der Erönung des Kontos vergeben wird. Der Wert von saldo wird durch den Konstruktor auf 0.00 gesetzt. Änderungen des Kontostandes sollen anschlieÿend nur über die Methoden einzahlen(betrag) und auszahlen(betrag) möglich sein, weshalb setsaldo(betrag) entfernt wird. Java In Java ist der Konstruktor eine Methode, die den gleichen Namen, wie die zugehörige Klasse trägt. Er unterscheidet sich bei der Denition von anderen Methoden dadurch, dass kein 10

Objekttyp für die Rückgabe speziziert werden darf. Der Konstruktor wird bei der Erzeugung eines Objektes nach dem Operator new aufgerufen. Ein expliziter Aufruf der Form: Referenz.Konstuktor() ist nicht möglich. Ist für eine Klasse kein Konstruktor explizit deklariert, dann baut der Compiler einen Standardkonstruktor ohne Parameter ein. Dieser Konstruktor initialisiert alle Attribute mit NULL. //Datei: Konto3/Konto.java //Beispiel : Konstruktor public class Konto{ private int kontonummer; private double saldo; // > Konstruktor public Konto(int nummer){ kontonummer = nummer; saldo = 0.0; public int getkontonummer(){ return kontonummer; // setkontonummer(nummer) entfernt public double getsaldo(){ return saldo; // setsaldo(betrag) entfernt public void einzahlen(double betrag){ saldo = saldo + betrag; public void auszahlen(double betrag){ saldo = saldo betrag; public void auszug(){ System.out.println("Kontonummer: "+kontonummer+" Saldo: "+saldo+" Euro"); Bisher wurden die Instanzen der Klasse Konto mit dem Standardkonstruktor Konto() erstellt. Dieser wird jetzt durch den neuen Konstruktor Konto(nummer) ersetzt. Er übernimmt die Initialisierung der Attribute, so dass dies nicht mehr explizit gesetzt werden müssen. //Datei: Konto3/Konto.java //Beispiel : Konstruktor public class KontoTest{ public static void main(string[] args){ Konto meinkonto; /* bisher: meinkonto = new Konto(); // Objekt erzeugen meinkonto.setkontonummer(4531088); // Kontonummer initialisieren meinkonto.setsaldo(0.00); // Kontostand initialisieren */ /* jetzt : */ meinkonto = new Konto(4531088); // Konstruktor erzeugt Objekt und initialisiert Attribute 11

meinkonto.auszug(); Oberon-2 Im Sprachkonzept von Oberon-2 sind Konstruktoren nicht enthalten. Sie können aber durch entsprechend implementierte Methoden nachgebaut werden. Im Beispiel der Klasse Konto wurde eine Methode Konto(nummer) deniert, die als Konstruktor verwendet wird. Diese Methode ist verantwortlich für die Initialisierung der Attribute kontonummer und saldo. (* Datei: Konto3/Konto.mod *) (* Beispiel : Konstruktor *) MODULE Konto; IMPORT Out; TYPE Konto* = RECORD kontonummer : LONGINT; saldo : REAL END; KontoRef* = POINTER TO Konto; (* > Konstruktor *) PROCEDURE (k : KontoRef) Konto*(nummer : LONGINT); k.kontonummer := nummer; k.saldo := 0.0; END Konto; PROCEDURE (k : KontoRef) getkontonummer*() : LONGINT; RETURN k.kontonummer; END getkontonummer; (* setkontonummer(nummer) entfernt *) PROCEDURE (k : KontoRef) getsaldo*() : REAL; RETURN k.saldo; END getsaldo; (* setsaldo(betrag) entfernt *) PROCEDURE (k : KontoRef) einzahlen*(betrag : REAL); k.saldo := k.saldo + betrag; END einzahlen; PROCEDURE (k : KontoRef) auszahlen*(betrag : REAL); k.saldo := k.saldo betrag; END auszahlen; PROCEDURE (k : KontoRef) auszug*(); Out.String("Kontonummer: "); Out.Int(k.kontonummer, 10); Out.String(" Saldo: "); Out.Real(k.saldo, 10); Out.String(" Euro"); 12

Out.Ln; END auszug; END Konto. Instanzen einer Klasse werden weiterhin durch den Operator NEW erzeugt. Die Methode Konto(nummer) initialisiert lediglich die Attribute. Da Konto(nummer) eine normale Methode ist, kann sie - im Gegensatz zu Konstruktoren in Java - uneingeschränkt genutzt und mittels Referenz.Konto(nummer) aufgerufen werden. Der Programmierer muss selbst darauf achten, dass sie nur nach der Generierung eines neuen Objektes verwendet wird, da sie sonst eventuell die Daten eines bereits bestehenden Objektes überschreibt. 7 (* Datei: Konto3/KontoTest.mod *) (* Beispiel : Konstruktor*) MODULE KontoTest; IMPORT Konto, Out; PROCEDURE ProgMain*(); VAR meinkonto : Konto.KontoRef; NEW(meinKonto); (* Objekt erzeugen *) (* bisher: meinkonto.setkontonummer(4531088); // Kontonummer initialisieren meinkonto.setsaldo(0.00); // Kontostand initialisieren *) (* jetzt : *) meinkonto.konto(4531088); (* Konstruktor initialisiert Attribute *) meinkonto.auszug; END ProgMain; Out.Open END KontoTest. 2.4 Klassen- und instanzspezische Komponenten Für Klassen können statische Variablen und Methoden deniert werden. Das besondere an diesen Komponenten ist, dass sie nicht auf die Existenz von Instanzen der Klasse angewiesen sind. Von Klassenvariablen existiert, unabhängig von der Anzahl der Instanzen, nur ein Exemplar, das von allen Objekten der Klasse gemeinsam genutzt wird. Sie werden beim Laden der Klasse erzeugt und erst freigegeben, wenn das Programm endet. Während der Zugri auf Instanzvariablen durch den Befehl Instanz.Variablenname erfolgt, werden klassenspezische Variablen in der Form: Klassenname.Variablenname angesprochen. Wenn ein Attribut für alle Instanzen einer Klasse den gleichen Wert haben soll, ist die Verwendung von Klassenvariablen angebracht. Anstatt den Wert in jedem einzelnen Objekt anzulegen, wird er in der Klasse 7 Eine weitere Variante der Konstruktormethode für Oberon-2-Programme, die den NEW-Operator beinhaltet, wird in den Beispielen Mediendatenbank und geometrische Figuren vorgestellt. 13

gespeichert. Klassenmethoden werden eingesetzt um Verhalten zu implementieren, dass für alle Instanzen einer Klasse gleich ist. Man muss jedoch darauf achten, dass sie nicht auf Instanzvariablen zugreifen oder Instanzmethoden aufrufen, da sie auch aufgerufen werden dürfen, wenn keine Instanz existiert. Zudem wäre in solch einer Situation nicht eindeutig festgelegt, welche Instanz verwendet werden muss. Klassenmethoden werden - genau wie Klassenvariablen - über den Name der Klasse aufgerufen. Die Klasse Konto könnte zum Beispiel einen Instanzenzähler enthalten, der festhält, wie viele Objekte vom Typ Konto erzeugt wurden. Der Wert der Variablen muss also immer dann um 1 erhöht werden, wenn ein neues Objekt angelegt wird. Deshalb sollte die entsprechende Anweisung im Konstruktor implementiert werden. Zu Beginn der Programm-Abarbeitung steht der Zähler auf 0, da noch keine Instanz existiert. Java Klassenvariablen und -methoden werden in Java durch das Schlüsselwort static gekennzeichnet. Im Beispiel der Klasse Konto wird das Attribut zaehler durch den Vorsatz static zu einer Klassenvariablen. Unabhängig von der Anzahl der Konto-Objekte existiert nur ein Exemplar dieser Variablen. Die Attribute kontonummer und saldo sind Instanzvariablen. Sie werden für jede Instanz der Klasse Konto neu angelegt (siehe Abb.3). //Datei: Konto4/Konto.java //Beispiel : Klassen und Instanzvariablen public class Konto{ static int zaehler = 0; // > Klassenvariable private int kontonummer; // > Instanzvariablen private double saldo; public Konto(int nummer){ zaehler = zaehler + 1; kontonummer = nummer; saldo = 0.00; public int getkontonummer(){ return kontonummer; public double getsaldo(){ return saldo; public void einzahlen(double betrag){ saldo = saldo + betrag; public void auszahlen(double betrag){ saldo = saldo betrag; public void auszug(){ System.out.println("Kontonummer: "+kontonummer+" Saldo: "+saldo+" Euro"); 14

Abbildung 3: Instanz- und Klassenvariablen Für die Variable zaehler wird beim Laden der Klasse Konto Speicherplatz belegt, der mit 0 vorinitialisiert ist. Nachdem durch den Konstruktor eine Instanz erzeugt wurde, ist der Wert von zaehler 1. Das Anlegen einer weiteren Instanz bewirkt eine erneute Erhöhung. // Datei: Konto4/KontoTest.java // Beispiel : Klassenvariablen public class KontoTest{ public static void main(string[] args){ // Zugri auf Klassenvariablen ueber Klassennamen System.out.println("Anzahl Konten: "+Konto.zaehler); Konto meinkonto = new Konto(4531088); System.out.println("Anzahl Konten: "+Konto.zaehler); Konto deinkonto = new Konto(1733065); System.out.println("Anzahl Konten: "+Konto.zaehler); Oberon-2 In Oberon-2 gibt es keine statischen Komponenten im eigentlichen Sinne. Die Datenfelder des Recordtyps sind Instanzvariablen und werden für jedes Objekt neu angelegt. Klassenvariablen können somit nicht im Record deklariert werden. Stattdessen werden sie im Variablendeklarationsteil des Moduls deniert. Man muss jedoch beachten, dass diese Variablen nicht an eine Klasse gebunden sind. Viel mehr sind es Modulvariablen, die von auÿen mittels Modulname.Variablenname angesprochen werden. Dies ist insbesondere dann wichtig, wenn der Klassenname von Namen des Moduls abweicht oder mehrere Klassen in einem Modul implementiert sind. Ähnliches gilt für Methoden. Instanzmethoden werden durch einen Empfängerparameter dem 15

Recordtyp zugeordnet. Wird dieser Parameter weggelassen, so sind die Prozeduren statisch. Sie können in Modulen, über den Modulnamen aufgerufen werden. In unserem Beispiel wird im Modul Konto eine Integer-Variable zaehler deklariert. Der Konstruktor der Klasse Konto verwendet diese Variable, um die Anzahl der Instanzen zu zählen. Um auf den Wert der Variable zuzugreifen genügt innerhalb des deklarierenden Moduls der Variablenname. (* Datei: Konto4/Konto.mod *) (* Beispiel : Klassen und Instanzvariablen *) MODULE Konto; IMPORT Out; TYPE Konto* = RECORD kontonummer : LONGINT; (* > Instanzvariablen *) saldo : REAL END; KontoRef* = POINTER TO Konto; (* > Modulvariable, ersetzt Klassenvariable *) VAR zaehler* : INTEGER; PROCEDURE (k : KontoRef) Konto*(nummer : LONGINT); zaehler := zaehler + 1; k.kontonummer := nummer; k.saldo := 0.0; END Konto; PROCEDURE (k : KontoRef) getkontonummer*() : LONGINT; RETURN k.kontonummer; END getkontonummer; PROCEDURE (k : KontoRef) getsaldo*() : REAL; RETURN k.saldo; END getsaldo; PROCEDURE (k : KontoRef) einzahlen*(betrag : REAL); k.saldo := k.saldo + betrag; END einzahlen; PROCEDURE (k : KontoRef) auszahlen*(betrag : REAL); k.saldo := k.saldo betrag; END auszahlen; PROCEDURE (k : KontoRef) auszug*(); Out.String("Kontonummer: "); Out.Int(k.kontonummer, 10); Out.String(" Saldo: "); Out.Real(k.saldo, 10); Out.String(" Euro"); Out.Ln; END auszug; zaehler := 0; END Konto. 16

(* Datei: Konto4/KontoTest.mod *) (* Beispiel : Klassen und Instanzvariablen*) MODULE KontoTest; IMPORT Konto, Out; PROCEDURE ProgMain*(); VAR meinkonto, deinkonto : Konto.KontoRef; Out.String("Anzahl Konten: "); (* Zugri auf Klassenvariablen ueber Modulnamen *) Out.Int(Konto.zaehler,2); Out.Ln; NEW(meinKonto); meinkonto.konto(4531088); Out.String("Anzahl Konten: "); Out.Int(Konto.zaehler,2); Out.Ln; NEW(deinKonto); meinkonto.konto(1733065); Out.String("Anzahl Konten: "); Out.Int(Konto.zaehler,2); END ProgMain; Out.Open END KontoTest. 2.5 Manipulierbarkeit Instanzen einer Klasse können wie andere Werte manipuliert werden. Dazu gehört unter anderem, dass sie einer anderen Referenzvariable vom selben Typ zugewiesen werden können. Im Programmbeispiel werden drei Referenzvariablen angelegt, aber nur zwei Instanzen erzeugt. Die Zuweisung sorgt dafür, dass die beiden Variablen meinkonto und unserkonto auf dasselbe Objekt verweisen, während deinkonto die zweite Instanz referenziert (siehe Abb. 4). Auÿerdem können Objekte auf Gleichheit und Ungleichheit getestet werden. Wichtig ist dabei, dass nur Zeigervergleiche und keine Wertvergleiche stattnden. Obwohl die Kontonummer und der Kontostand von meinkonto und deinkonto identisch sind, liefert der Vergleich den Wert FALSE. Nur der Vergleich von meinkonto und unserkonto ergibt TRUE. Es ist möglich, Prozeduren oder Funktionen zu denieren, die Klasseninstanzen als Parameter haben. Für die Klasse Konto wurde eine Prozedur ueberweisen implementiert, die als Argumente zwei Konto-Objekt nimmt und einen vorgegebenen Betrag von einem auf das andere überweist. Abbildung 4: Zuweisung und Vergleich von Objekten 17

Java //Datei: Konto5/Konto.java //Beispiel : Manipulierbarkeit public class KontoTest{ static void ueberweisen(double betrag, Konto kontoa, Konto kontoz){ kontoa.auszug(); kontoz.auszug(); kontoa.auszahlen(betrag); kontoz.einzahlen(betrag); System.out.print("Von Konto "+kontoa.getkontonummer()); System.out.print(" wurden "+betrag+" Euro "); System.out.println("auf Konto "+kontoz.getkontonummer()+" ueberwiesen."); kontoa.auszug(); kontoz.auszug(); public static void main(string[] args){ Konto meinkonto = new Konto(4531088); meinkonto.einzahlen(300.00); Konto deinkonto = new Konto(4531088); deinkonto.einzahlen(300.00); Konto unserkonto; // Zuweisung unserkonto=deinkonto; // Vergleich if (meinkonto == deinkonto) System.out.println("Mein Konto und dein Konto sind identisch."); else System.out.println("Mein Konto und dein Konto sind verschieden."); if (unserkonto == deinkonto) System.out.println("Unser Konto und dein Konto sind identisch."); else System.out.println("Unser Konto und dein Konto sind verschieden."); // Parameter ueberweisen(30.00, meinkonto, deinkonto); Oberon-2 (* Datei: Konto5/KontoTest.mod *) (* Beispiel : Manipulierbarkeit*) MODULE KontoTest; IMPORT Konto,Out; PROCEDURE ueberweisen(betrag : REAL; kontoa, kontoz : Konto.KontoRef); kontoa.auszug(); kontoz.auszug(); kontoa.auszahlen(betrag); kontoz.einzahlen(betrag); Out.String("Von Konto "); Out.Int(kontoA.getKontonummer(),10); Out.String(" wurden "); Out.Real(betrag,10); Out.String(" Euro auf Konto "); Out.Int(kontoZ.getKontonummer(),10); Out.String(" ueberwiesen."); Out.Ln; 18

kontoa.auszug(); kontoz.auszug(); END ueberweisen; PROCEDURE ProgMain*(); VAR meinkonto, deinkonto, unserkonto : Konto.KontoRef; NEW(meinKonto); meinkonto.konto(4531088); meinkonto.einzahlen(300.00); NEW(deinKonto); deinkonto.konto(1733065); deinkonto.einzahlen(100.00); (* Zuweisung *) unserkonto := deinkonto; (* Vergleich *) IF meinkonto = deinkonto THEN Out.String("Mein Konto und dein Konto sind identisch."); Out.Ln; ELSE Out.String("Mein Konto und dein Konto sind verschieden."); Out.Ln; END; IF unserkonto = deinkonto THEN Out.String("Unser Konto und dein Konto sind identisch."); Out.Ln; ELSE Out.String("Unser Konto und dein Konto sind verschieden."); Out.Ln; END; (* Parameter *) ueberweisen(30.00, meinkonto, deinkonto); END ProgMain; Out.Open END KontoTest. 2.6 Vererbung Oft modellieren Klassen Dinge der realen Welt, die zwar in verschiedenen Varianten vorkommen, aber auch grundlegende Gemeinsamkeiten haben. In einer Bank gibt es z.b. verschiedene Kontoarten. Ein Sparkonto ist ein Konto mit Kontonummer und Kontostand; zusätzlich zum normalen Konto werden jedoch Zinsen auf das Guthaben gezahlt. Auÿerdem gibt es noch Girokonten, die über ein bestimmtes Kreditlimit verfügen. Für beide Konten sind das Einzahlen und Auszahlen von Geldbeträgen, sowie das Drucken eines Kontoauszuges typische Handlungen. Diese Methoden sind bereits in der Klasse Konto implementiert und können durch Kopieren in die Klassen Sparkonto und Girokonto übernommen werden. Damit müssen jedoch drei Versionen des selben Algorithmus gepegt werden. Eine Möglichkeit, diese Code-Duplizierung zu vermeiden ist Vererbung. Vererbung ist eines der mächtigsten und interessantesten Konzepte des objektorientierten Programmierens. Sie ermöglicht, dass neue Klassen auf bereits vorhandenen Klassen und deren Funktionalität aufbauen. Haben mehrere Klassen gleiche Eigenschaften, so werden diese in einer allgemeinen Superklasse zusammengefasst. Wird von dieser Klasse eine Subklasse abgeleitet, so erbt sie alle 19

Komponenten der übergeordneten Klasse, d.h. Attribute und Methoden werden automatisch übernommen und müssen nicht erneut implementiert werden. Die Subklasse kann anschlieÿend die für sie relevanten Attribute und Methoden hinzufügen. Auf diese Art und Weise ist es möglich, hierarchische Beziehungen zwischen einzelnen Klassen herzustellen. So können z.b. mehrere Klassen von einer Superklasse erben, und eine Subklasse kann wiederum selbst Superklasse weiterer Subklassen sein. Von der Klasse Konto soll zunächst nur die Klasse Sparkonto abgeleitet werden. Diese erbt die Attribute kontonummer und saldo, benötigt aber noch ein weiteres Attribut zinssatz, in dem festgehalten wird viele Prozent Zinsen gezahlt werden. Auf das Attribut kann über die Methoden getzinssatz() und setzinssatz(zins) zugegrien werden. Für die Buchung der Zinsen auf das jeweilige Konto, wird eine zusätzliche Methode verzinsen() implementiert. Alle weiteren Methoden werden von der Superklasse übernommen. Insgesamt ergibt sich damit das in Abb. 5 dargestellte Klassendiagramm. Abbildung 5: Vererbung Java Um in Java eine neue Klasse aus einer bestehenden abzuleiten, wird im Kopf der Klassenbeschreibung das Schlüsselwort extends zusammen mit dem Namen der Superklasse verwendet. Die Superklasse gibt dann die Variablen und Methoden, die public oder protected deklariert sind, an die abgeleiteten Klassen weiter. Komponenten, die als private eingestuft sind, werden nicht vererbt. Sollen Attribute oder Methoden für andere Klassen nicht sichtbar sein, aber trotzdem an die Subklasse vererbt werden, so müssen sie mit den Schlüsselwort protected gekennzeichnet sein. 8 Deshalb ändert sich der Modizierer der Attribute kontonummer und saldo von private in protected. Die Methoden der Klasse Konto behalten den Zusatz public, damit sie auch für andere Klassen sichtbar sind. //Datei: Konto6/Konto.java //Beispiel : Vererbung public class Konto{ 8 Komponenten für die kein Modizierer angegeben ist, werden nur innnerhalb eines Paketes an Subklassen vererbt. 20

static int zaehler = 0; protected int kontonummer; // Attribute sollen vererbt werden protected double saldo; public Konto(int nummer){ zaehler = zaehler + 1; kontonummer = nummer; saldo = 0.00; // Implementierung der Methoden hier ausgelassen public int getkontonummer(){ public double getsaldo(){ public void einzahlen(double betrag){ public void auszahlen(double betrag){ public void auszug(){ Die Klasse Sparkonto wird durch extends von der Klasse Konto abgeleitet. Dadurch erbt sie alle Eigenschaften der übergeordneten Klasse und kann diese im Programmcode verwenden. Alle Deklarationen die im Rumpf der Klasse gemacht werden, sind Erweiterungen von Konto. Konstruktoren werden nicht vererbt, aus diesem Grund benötigt die Klasse Sparkonto einen eigenen Konstuktor Sparkonto(nummer, zins). In diesem wird mit dem Befehl super(nummer) zunächst der Konstruktor der Superklasse aufgerufen, d.h. alle Anweisungen von Konto(nummer) werden ausgeführt. Anschlieÿend muss nur noch das neue Attribut zinssatz initialisiert werden. Die Methode verzinsen() ändert den Kontostand der aufrufenden Instanz. Obwohl das Attribut saldo nicht in der Klasse Sparkonto deklariert worden ist, kann der Name verwendet werden. //Datei: Konto6/Sparkonto.java //Beispiel : Vererbung // > Vererbung public class Sparkonto extends Konto{ private double zinssatz; // zusaetzliches Attribut // Konstuktor der Klasse Sparkonto public Sparkonto(int nummer, double zins){ super(nummer); // Konstruktor der Superklasse Konto wird ausgerufen zinssatz = zins; // neue Methoden fuer Zugri auf Attribut zinssatz public double getzinssatz(){ return zinssatz; public void setzinssatz(double zins){ zinssatz = zins; // neue Methode public void verzinsen(){ saldo = saldo + (zinssatz*saldo)/100; // verwendet geerbte Attribute Eine Instanz der Klasse Sparkonto wird durch den Konstruktor Sparkonto(nummer,zins) erzeugt und initialisiert. Jedes Objekt von Typ Sparkonto besitzt die 3 Attribute kontonummer, 21

saldo und zinssatz, die mit Hilfe der Methoden getkontonummer(), getsaldo() und getzinssatz() ausgelesen werden können. Das Datenfeld zinssatz kann durch die Methode setzinssatz(zins) beschrieben werden. Alle Methoden, die für eine Instanz der Klasse Konto deniert sind, können auch auf ein Objekt vom Typ Sparkonto angewendet werden. Dazu gehören die Methoden einzahlen(betrag), auszahlen(betrag) und auszug(). Zusätzlich verfügt jedes Sparkonto-Objekt über die Methode verzinsen(). //Datei: Konto6/KontoTest.java //Beispiel : Vererbung public class KontoTest{ public static void main(string[] args){ Sparkonto meinsparkonto = new Sparkonto(5613990,3.4); // jede Instanz der Klasse Sparkonto hat 3 Attribute System.out.print("Kontonummer: "+meinsparkonto.getkontonummer()); // geerbtes Attribut System.out.print(" Saldo: "+meinsparkonto.getsaldo()+" Euro"); //geerbtes Attribut System.out.println(" Zinssatz: "+meinsparkonto.getzinssatz()); // neu deklariertes Attribut // Methoden einzahlen(betrag), auszahlen(betrag) und auszug() koennen verwendet werden meinsparkonto.einzahlen(250.00); // geerbte Methoden meinsparkonto.auszug(); meinsparkonto.auszahlen(10.00); meinsparkonto.auszug(); // ausserdem gibt es fuer Instanzen der Klasse Sparkonto die Methode verzinsen() meinsparkonto.verzinsen(); // neu implementierte Methode meinsparkonto.auszug(); Oberon-2 In Oberon-2 erbt die Subklasse nur die Komponenten, die vom Modul der Superklasse exportiert werden. Soll die Klasse Sparkonto die Attribute kontonummer und saldo enthalten, so müssen diese in der Klasse Konto mit einem Stern markiert sein. Damit sind sie auch in anderen Modulen sichtbar und nicht mehr gekapselt. Jeder Programmier muss für seine Anwendung selbst entscheiden, ob Datenkapselung oder Vererbung wichtiger ist. Beide Konzepte können nur dann parallel verwendet werden, wenn Sub- und Superklasse in einem Modul implementiert sind. Dies geht aber zu Lasten der Programmlesbarkeit und das Prinzip der Aggregierung wird gelockert. (* Datei: Konto6/Konto.mod *) (* Beispiel : Vererbung *) MODULE Konto; IMPORT Out; TYPE Konto* = RECORD kontonummer* : LONGINT; (* Attribute sollen vererbt werden *) saldo * : REAL END; KontoRef* = POINTER TO Konto; 22

VAR zaehler* : INTEGER; (* Implementierung des Konstruktors und der Methoden wurde hier ausgelassen *) PROCEDURE (k : KontoRef) Konto*(nummer : LONGINT); PROCEDURE (k : KontoRef) getkontonummer*() : LONGINT; PROCEDURE (k : KontoRef) getsaldo*() : REAL; PROCEDURE (k : KontoRef) einzahlen*(betrag : REAL); PROCEDURE (k : KontoRef) auszahlen*(betrag : REAL); PROCEDURE (k : KontoRef) auszug*(); zaehler := 0; END Konto. Indem man den Recordtyp einer Klasse in Klammern hinter das Schlüsselwort RECORD in die Typdeklaration einer neuen Klasse schreibt, drückt man aus, dass diese von der anderen abgeleitet werden soll. Bendet sich die Implementierung der Superklasse in einem anderen Modul, so muss dieses importierte Modul und der Modulname bei der Typableitung mit angegeben werden. Die Klasse Sparkonto übernimmt somit alle Attribute und Methoden der Klasse Konto, inklusive der Konstruktormethode. Diese wird im neuen Konstruktor Sparkonto(nummer, zins) verwendet, um die geerbten Attribute kontonummer und saldo zu initialisieren. Das neue Attribut zinssatz muss explizit mit einem Startwert belegt werden. Die zusätzlichen Methoden der Klasse Sparkonto werden wie gewohnt als typgebundene Prozeduren implementiert. (* Datei: Konto6/Sparkonto.mod *) (* Beispiel : Vererbung *) MODULE Sparkonto; IMPORT Konto, Out; TYPE Sparkonto* = RECORD (Konto.Konto) (* > Vererbung *) zinssatz * : REAL; (* zusaetzliches Attribut *) END; SparkontoRef* = POINTER TO Sparkonto; (* Konstuktor der Klasse Sparkonto *) PROCEDURE (sk : SparkontoRef) Sparkonto*(nummer : LONGINT; zins : REAL); sk.konto(nummer); (* Konstruktor der Superklasse Konto wird aufgerufen *) sk. zinssatz := zins; END Sparkonto; (* neue Methoden fuer Zugri auf Attribut zinssatz*) PROCEDURE (sk : SparkontoRef) getzinssatz*() : REAL; RETURN sk.zinssatz; END getzinssatz; PROCEDURE (sk : SparkontoRef) setzinssatz*(zins : REAL); sk. zinssatz := zins; END setzinssatz; (* neue Methode *) PROCEDURE (sk : SparkontoRef) verzinsen*(); sk.saldo := sk.saldo + (sk. zinssatz*sk.saldo)/100; (* verwendet geerbte Attribute *) 23

END verzinsen; END Sparkonto. Der NEW -Operator erzeugt ein Objekt vom Typ Sparkonto und speichert einen Adressverweis auf dieses Objekt in meinsparkonto. Die Attribute werden von durch den Aufruf der Methode Sparkonto(nummer, zins) mit Werten belegt, so dass sich die in Abb. 6 dargestellte Situation ergibt. Für die Instanz meinsparkonto können alle Methoden aufgerufen werden, die in den Klassen Sparkonto und Konto implementiert wurden. Abbildung 6: Instanz der Klasse Sparkonto (* Datei: Konto6/KontoTest.mod *) (* Beispiel : Verbung*) MODULE KontoTest; IMPORT Sparkonto, Out; PROCEDURE ProgMain*(); VAR meinsparkonto : Sparkonto.SparkontoRef; NEW(meinSparkonto); meinsparkonto.sparkonto(5613990,3.4); (* jede Instanz der Klasse Sparkonto hat 3 Attribute *) Out.String("Kontonummer: "); Out.Int(meinSparkonto.getKontonummer(),10); (* geerbtes Attribut *) Out.String(" Saldo: "); Out.Real(meinSparkonto.getSaldo(),10); (* geerbtes Attriubut *) Out.String(" Euro Zinssatz: "); Out.Real(meinSparkonto.getZinssatz(),10); (* neu deklariertes Attribut *) Out.Ln; (* Methoden einzahlen(betrag), auszahlen(betrag) und auszug() koennen verwendet werden *) meinsparkonto.einzahlen(250.00); (* geerbte Methoden *) meinsparkonto.auszug(); meinsparkonto.auszahlen(10.00); meinsparkonto.auszug(); (* ausserdem gibt es fuer Instanzen der Klasse Sparkonto die Methode verzinsen() *) meinsparkonto.verzinsen(); (* neu implementierte Methode *) meinsparkonto.auszug(); END ProgMain; Out.Open END KontoTest. 24

2.7 Reimplementierung In vielen Fällen reicht es nicht aus, Methoden unverändert von der Superklasse zu erben. Für ein Girokonto muss bspw. beim Auszahlen überprüft werden, ob der Überziehungskredit überschritten wird. Ist dies der Fall, darf kein Geld ausgezahlt werden. 9 Die Klasse Girokonto kann trotzdem von Konto abgeleitet werden, die geerbte Methode muss lediglich an die neue Situation angepasst werden. Wird in einer Subklasse eine Methode der Superklasse mit einer anderen Funktionalität implementiert, so bezeichnet man diesen Vorgang als Überschreiben oder Reimplementieren der Methode. Das ist dann der Fall, wenn man die Methode in der Subklasse mit gleichem Rückgabewert, Namen und Parametern deniert und die Anweisungen im Methodenrumpf ändert. Die Objekte der Subklasse haben dann zwei Methoden mit gleichem Namen und gleicher Signatur, jedoch wird die ursprüngliche Methode der Superklasse von der überschreibenden Methode verdeckt. Java Solange eine Methode in der Superklasse nicht mit nal gekennzeichnet ist, kann man sie in einer Subklasse überschreiben. Dazu wird der Methodenkopf aus der übergeordneten Klasse übernommen und die Anweisungen im Methodenrumpf werden der Aufgabe entsprechend angepasst. Die Klasse Girokonto wird von Konto abgeleitet und reimplementiert die Methode auszahlen(betrag). Der gewünschte Betrag wird nicht mehr in allen Fällen vom Konto abgebucht, sondern nur wenn das Limit nicht überschritten ist. Diese Voraussetzung überprüft die eingebaute if-anweisung. Ist die Bedingung erfüllt, ruft der Befehl super.auszahlen(betrag) die verdeckte Methode der Superklasse Konto auf. In alle anderen Fällen wird eine Fehlermeldung ausgegeben. Alle anderen Methoden werden unverändert von Konto übernommen. //Datei: Konto7/Girokonto.java //Beispiel : Reimplementierung public class Girokonto extends Konto{ private double limit; public Girokonto(int nummer, double limit){ super(nummer); if (limit < 0) limit = limit; this.limit = limit; // Parameter this zeigt auf das Objekt fuer das die Methode aufgerufen wird public double getlimit(){ return limit; // Methode fuer schreibenden Zugri ueberprueft ob limit postiv ist public void setlimit(double limit){ if (limit < 0) 9 Eine Überprüfung, ob das Konto überzogen wird ist natürlich auch für Konten ohne Kreditrahmen sinnvoll. Ich habe jedoch darauf verzichtet. 25

limit = limit; this.limit = limit; // > Reimplementierung public void auszahlen(double betrag){ if (betrag <= saldo + limit) super.auszahlen(betrag); else System.out.println("Limit ueberschritten!"); Genau wie die Klasse Sparkonto erbt Girokonto alle Attribute und Methoden von Konto. Insbesondere die Methode einzahlen(betrag) kann auf Instanzen der Klasse Girokonto angewendet werden. Ist auf dem Konto noch genügend Geld vorhanden, so verhält sich die Methode auszahlen(betrag) - wenn sie für ein Girokonto-Objekt aufgerufen wird - genauso, als wäre das Objekt eine Instanz der Klasse Konto. Der Unterschied zwischen beiden Implementierungen zeigt sich erst wenn man das Konto überzieht. Vom normalen Konto wird der Betrag abgebucht, während das Girokonto die Auszahlung verweigert. Welche Implementierung verwendet wird, hängt davon ab, von welchem Typ das aufrufende Objekt ist. //Datei: Konto7/KontoTest.java //Beispiel : Reimplenetierung public class KontoTest{ public static void main(string[] args){ Konto meinkonto = new Konto(4531088); meinkonto.einzahlen(400.00); meinkonto.auszug(); System.out.println("Versuche 100 Euro abzuheben."); meinkonto.auszahlen(100.00); // Methode auszahlen(betrag) der Klasse Konto meinkonto.auszug(); System.out.println("Versuche 500 Euro abzuheben."); meinkonto.auszahlen(500.00); // Methode auszahlen(betrag) der Klasse Konto meinkonto.auszug(); System.out.println(); Girokonto meingirokonto = new Girokonto(1733065,100); meingirokonto.einzahlen(400.00); meingirokonto.auszug(); System.out.println("Versuche 100 Euro abzuheben."); meingirokonto.auszahlen(100.00); // Methode auszahlen(betrag) der Klasse Girokonto meingirokonto.auszug(); System.out.println("Versuche 500 Euro abzuheben."); meingirokonto.auszahlen(500.00); // Methode auszahlen(betrag) der Klasse Girokonto meingirokonto.auszug(); Oberon-2 Oberon-2 ermöglicht ebenfalls das Überschreiben von Methoden. Hierzu deklariert man die Prozedur mit der gleichen Schnittstelle, bindet sie aber durch den Empfängerparameter an die Subklasse. Die verdeckte Methode der Superklasse wird aufgerufen, wenn an den Methodennamen ein Pfeil (^) angehängt wird. 26

An der Oberon-Syntax wird nochmal deutlich, dass die Klasse Girokonto tatsächlich über zwei Varianten der Methode auszahlen(betrag) verfügt, die geerbte Variante aber nur dann auswählt wird, wenn man dies explizit fordert. Die Methode setlimit(limit) zeigt, warum Attribute nur durch Methoden verändert werden sollten, auch wenn sie gekapselt sind. Sie stellt sicher, dass der Überziehungskredit immer als positiver Wert gespeichert ist. Dies ist ein Detail der Implementierung, das in der Methode auszahlen(betrag) zum Tragen kommt. Wären negative Werte möglich, so würde in bestimmen Fällen die Auszahlung verweigert werden, obwohl noch genügend Geld auf dem Konto ist. Dank der im Konstruktor und in setlimit(limit) realisierten Betragsbildung muss sich der Anwender jedoch nicht um dieses Problem kümmern. (* Datei: Konto7/Girokonto.mod *) (* Beispiel : Reimplementierung *) MODULE Girokonto; IMPORT Konto, Out; TYPE Girokonto* = RECORD (Konto.Konto) limit * : REAL; END; GirokontoRef* = POINTER TO Girokonto; PROCEDURE (gk : GirokontoRef) Girokonto*(nummer : LONGINT; limit : REAL); gk.konto(nummer); IF limit < 0 THEN limit := limit END; gk.limit := limit; END Girokonto; PROCEDURE (gk : GirokontoRef) getlimit*() : REAL; RETURN gk.limit; END getlimit; (* Methode fuer schreibenden Zugri ueberprueft ob limit positiv ist *) PROCEDURE (gk : GirokontoRef) setlimit*(limit : REAL); IF limit < 0 THEN limit := limit END; gk.limit := limit; END setlimit; (* > Reimplementierung *) PROCEDURE (gk : GirokontoRef) auszahlen*(betrag : REAL); IF betrag <= gk.saldo + gk.limit THEN gk.auszahlen^(betrag); ELSE Out.String("Limit ueberschritten!"); Out.Ln; END; END auszahlen; END Girokonto. 27