Objektorientierung leicht gemacht
Werbung
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 1
Prof. Hermann Meyer, Karsten Schleider
Objektorientierung leicht gemacht
1. Auflage
Bestellnummer 20570
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 2
www.bildungsverlag1.de
Bildungsverlag EINS
Sieglarer Straße 2, 53842 Troisdorf
ISBN 978-3-427-20570-8
Copyright 2007*: Bildungsverlag EINS GmbH, Troisdorf
Das Werk und seine Teile sind urheberrechtlich geschützt. Jede Nutzung in anderen als den gesetzlich
zugelassenen Fällen bedarf der vorherigen schriftlichen Einwilligung des Verlages.
Hinweis zu § 52a UrhG: Weder das Werk noch seine Teile dürfen ohne eine solche Einwilligung eingescannt und
in ein Netzwerk eingestellt werden. Dies gilt auch für Intranets von Schulen und sonstigen Bildungseinrichtungen.
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 3
Vorwort
Der objektorientierte Ansatz hat die Softwareentwicklung in den letzten Jahren
revolutioniert, da alte Programmiersprachen die Anforderungen an moderne
Anwendungen nicht mehr wirtschaftlich
erfüllen. Wichtige Prinzipien der Objektorientierung wie Vererbung und Kapselung
finden sich auch in anderen Teildisziplinen
der Informatik. So findet man z. B. bei
der Verwaltung von Netzen Vererbungsstrukturen in der Benutzerverwaltung.
Damit verbunden ist die Notwendigkeit,
die objektorientierte Denkweise frühzeitig
zu erlernen. Ziel des Buches muss es sein,
die Sachverhalte schülergerecht und
möglichst einfach darzustellen. Es ist nicht
die Absicht der Autoren, den objektorientierten Ansatz einschließlich UML und
Java umfassend und detailliert vorzustellen.
Vielmehr steht das Denken mit Klassen und
Objekten im Blickpunkt.
Als Sprache wird Java verwendet, da sie
zunehmend an Bedeutung gewinnt, auf
vielen Plattformen verfügbar ist und eine
relativ einfache Umsetzung des objektorientierten Ansatzes bietet.
Die Autoren gehen davon aus, dass der
Schüler/die Schülerin bereits Kenntnisse
über Kontrollstrukturen und SQL-Befehle
besitzt. Ist dies nicht der Fall, sollten
zunächst die Kapitel im Anhang durchgearbeitet werden.
Auf Vereinfachungen und Optimierungen
der Praxis, die dem Grundprinzip der
Objektorientierung widersprechen, wird
bewusst verzichtet. Zugunsten einer übersichtlichen Darstellung werden komplexe
Sachverhalte auf das Wesentliche reduziert.
Dadurch ist der Weg frei zu einem grundlegenden Verständnis und das Interesse an
einer intensiveren Beschäftigung mit dem
Thema wird so geweckt.
Die Fachinhalte werden mit einfachen und
schülernahen Beispielen an charakteristischen ökonomischen Problemen dargestellt. Natürlich soll dennoch der essentielle
und exemplarische Ansatz der Objektorientierung vermittelt werden.
Durch eine einheitliche, zielorientierte Gliederung der Kapitel wird ein strukturiertes
Lernen unterstützt. UML-Klassendiagramme und Java-Code sind gesondert hervorgehoben.
Zu beachten ist, dass für die Programmierung der grafischen Oberflächen (GUI)
integrierte Entwicklungsumgebungen (IDE)
vorausgesetzt werden, die „Fenster“ generieren. Auf diese Erzeugung wird nicht
näher eingegangen, da sie von der verwendeten Software abhängig ist. Als beispielhafte Produkte seien ECLIPSE, NetBeans oder JBuilder genannt. Die Autoren
verzichten am Anfang des Buches bewusst
auf grafische Oberflächen, obwohl dies für
den Entwickler motivierend ist. Nur setzten
grafische Oberflächen das Verstehen von
Klassen, Objekten, Import und Vererbung
voraus. Die Autoren sind dieser zwingenden Sachstruktur gefolgt.
Die Autoren danken den Mitgliedern der
Zentralen Projektgruppe (ZPG) am Landesinstitut für Schulentwicklung in Stuttgart
für die vielen Anregungen und Diskussionen.
Die Autoren
3
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 4
Inhaltsverzeichnis
1
Objekte, Attribute und Fachklasse
1.1
1.2
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lösungsansatz: Objekte, Klassen, Attribute und Methoden (Operationen) . . . . . . . . .
1.2.1
Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.2
Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.3
Attribute (Eigenschaften) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.4
Methoden (Verhalten) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.5
Die Klasse „Artikel“ in UML-Darstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2.6
Modellierung der Fachklasse „Artikel“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Umsetzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.1
Die Fachklasse „Artikel“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3.2
Vereinbarung von Attributen (Attributsdeklarationen) . . . . . . . . . . . . . . . . . . . . . . .
1.3.3
Methodendeklarationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
10
10
11
11
12
14
15
16
18
18
19
2
Dynamische Klassen
22
2.1
2.2
2.3
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lösungsansatz für die Erzeugung von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.1
Die Startklasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.2
Deklaration und Erzeugen von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.3
Schreiben von Attributswerten in ein Objekt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2.4
Lesen von Attributswerten aus Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Umsetzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
22
22
24
25
26
27
3
Arbeiten mit importierten Klassen (Paketen)
32
3.1
3.2
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
32
32
1.3
4
9
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 5
Inhaltsverzeichnis
4
Vererbung
36
4.1
4.2
4.3
4.4
4.5
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Umsetzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.1
Die Fachklasse „Artikel“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.2
Die Fachklassen „Spitzer“ und „Schreiber“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.3
Die Startklasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
36
38
39
41
41
41
42
43
5
Assoziationen
44
5.1
5.2
5.3
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.1
Binäre Assoziation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.2
Assoziative Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.3
Navigation bzw. Unidirektionalität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Umsetzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4.1
Die Fachklasse „Artikelgruppe“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4.2
Die Fachklasse „Artikel“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4.3
Die Startklasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exkurs: Bidirektionale Assoziation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.6.1
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.6.2
Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.6.3
Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.6.4
Umsetzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
44
45
45
45
47
49
49
50
50
50
51
52
52
52
52
53
6
Darstellungen mit GUI (Graphical User Interface)
57
6.1
6.2
6.3
6.4
6.5
6.6
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Umsetzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Erster Exkurs: Fehlerbehandlung mit „try“ und „catch“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zweiter Exkurs: Rechnen in einer eigenen Klasse
(Objekt- und Klassenmethoden) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
57
58
60
61
63
5.4
5.5
5.6
64
5
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 6
Inhaltsverzeichnis
7
Das Formular und die Fachklasse
(2-Schichten-Architektur)
68
7.5
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Umsetzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.4.1
Die Startklasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.4.2
Die Klasse „Fensterklasse“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.4.3
Codierung der Ereignisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
68
68
69
70
71
72
72
78
8
Dauerhafte Speicherung von Objekten (Persistenz)
80
8.1
8.2
8.3
8.6
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.3.1
Speichern von Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.3.2
Lesen von gespeicherten Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Umsetzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.4.1
Die Fachklasse „Artikel“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.4.2
Die Startklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Exkurs: GUI, Speichern von Objekten und Listenobjekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.5.1
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.5.2
Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.5.3
Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.5.4
Java-Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
80
80
80
80
80
81
82
82
88
88
88
89
91
96
9
Datenbankanbindung (3-Schichten-Architektur)
97
9.1
Erfassen und Speichern von Artikeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1.1
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1.2
Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1.3
Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.1.4
Umsetzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Suchen eines Artikels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2.1
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2.2
Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2.3
Umsetzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7.1
7.2
7.3
7.4
8.4
8.5
9.2
6
97
97
100
101
102
106
106
107
108
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 7
Inhaltsverzeichnis
10 Applets und Webanbindung
116
10.1 Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.2 Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3 Umsetzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3.1
Die Appletklasse „ArtikelApplet“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3.2
Das HTML-Dokument „Artikel.html“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3.3
Freischalten des Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.3.4
Die Klasse „DBZugriff“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10.4 Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
116
116
117
117
120
121
122
123
11 Anhang: Kontrollstrukturen
124
11.1 Folgen und Konvertierung (Datenumwandlung) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.1.1
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.1.2
Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.1.3
Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.1.4
Umsetzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.1.5
Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.2 Verzweigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.2.1
Zweiseitige Verzweigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.2.2
Geschachtelte Verzweigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.2.3
Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.3 Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.3.1
Zählerschleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.3.2
Kopf- und fußgesteuerte Schleife . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.3.3
Übungsaufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.4 Fehlerbehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.4.1
Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.4.2
Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.4.3
Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11.4.4
Umsetzung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
124
124
124
125
126
128
128
128
129
131
131
131
134
136
137
137
137
137
137
7
OLG-06-3871_Umbruch
8
15.03.2007
11:33 Uhr
Seite 8
12 Anhang: SQL-Einführung
138
12.1 Situation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2 Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.3 Umsetzung in SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.3.1
Abfragen auf eine Tabelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.3.2
Abfragen über mehrere Tabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
138
138
138
138
141
Sachwortverzeichnis
143
.......................................................................................................
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 9
Objekte, Attribute und Fachklasse
1.1
1
Situation
Im kaufmännischen Zentrum der Ludwig-Erhard-Schule in Stuttgart wurde im Juli 2006
eine Juniorenfirma gegründet. Im November des gleichen Jahres erfolgte die Eintragung
ins Vereinsregister. Bei Juniorenfirmen handelt es sich im Unterschied zu reinen Übungsfirmen und Lernbüros um am Markt operierende Unternehmen. Die Mitarbeiterinnen und
Mitarbeiter sind gleichzeitig Schülerinnen und Schüler des Schulzentrums.
Kevin, ein Schüler der kaufmännischen Berufsschule, und Lea, eine Schülerin der 13. Klasse
des beruflichen Gymnasiums, sind zurzeit die verantwortlichen Geschäftsführer der
Juniorenfirma. Kevin beschreibt die dargebotenen Dienstleistungen:
„Wir verkaufen Schreibwaren am eigenen
Verkaufsstand in der Pausenhalle. Außerdem bieten wir EDV-Serviceleistungen an,
z. B. das Drucken von individuellen Briefköpfen, Visitenkarten und farbigen Fotos.
Die Schreibwaren verkaufen wir täglich
während der großen Pause und nach dem
Vormittagsunterricht. Kunden sind die
Schüler und Lehrer des Schulzentrums.
Unser größter Umsatzträger sind die selbst
gedruckten Klassenarbeitsblöcke mit
Korrekturrand. Im Prinzip laufen in unserem Juniorenbetrieb genau die gleichen Geschäftsprozesse ab wie in einem Schreibwarengeschäft außerhalb der Schule.“
Die Schüler haben die Absicht, ihre Geschäftsprozesse mithilfe einer selbst entwickelten
Software zu unterstützen.
Kevin macht eine Ausbildung zum IT-Kaufmann. Lea hat das Fach Wirtschaftsinformatik
belegt. Beide haben im Unterricht von objektorientierter Softwareentwicklung gehört und
sind von der Idee so begeistert, dass sie, gleichlaufend zu Ihrem Informatikunterricht, ihre
DV-Kenntnisse im Schreibwarenshop anwenden wollen.
9
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 10
1 Objekte, Attribute und Fachklasse
1.2
Lösungsansatz: Objekte, Klassen, Attribute und
Methoden (Operationen)
1.2.1
Objekte
Objektorientierte Softwareentwicklung bedeutet, wie der Name bereits sagt, dass Programme erstellt werden, die von Objekten handeln.
Objekte sind zunächst reale oder abstrakte Dinge (vgl. Abbildung 1, Seite 13), wie sie etwa
im Shop von Kevin und Lea auftreten. Dazu gehören z. B. die einzelnen Kunden, Artikel,
Lieferanten und Mitarbeiter, aber auch Verkaufsvorgänge und Bestellungen bei Lieferanten. Der Klassenarbeitsordner, das Geodreieck oder der Textmarker, Variante „grün“,
sind beispielsweise reale Objekte. Natürlich können diese realen Dinge nicht direkt in
unserem Rechner verarbeitet werden, deshalb werden sie in der Programmierung
beschrieben mit den Eigenschaften „Artikelbezeichnung“, „Artikelpreis“ und „Lagerbestand“. Diese Beschreibung der Eigenschaften ist für alle Artikel gleich. Die Werte dieser
Eigenschaften, z. B. „Textmarker „grün“, „1,29“ und „30 Stück“, sind natürlich verschieden.
Objekte, hier die einzelnen Artikel, müssen erfasst, geändert und gelöscht werden können.
Diese Operationen (Methoden) gelten für alle gleichartigen Artikelobjekte. Übertragen
lassen sich die Aussagen auch auf andere Objekte, z. B. auch auf Kunden- oder Lieferantenobjekte. Alle Lieferanten haben einen Namen, eine Lieferernummer, ihnen wird ein
Zahlungsziel zugeordnet sowie weitere gleiche Attribute. Auch bei den Operationen
„Erfassen“, „Ändern“ und „Löschen“ gibt es Überschneidungen.
Merke:
1
Objekte sind reale oder abstrakte Dinge (ein bestimmter „Radiergummi“ oder die
„Quittung“ für den Kunden).
2
Im Programm findet eine Abstraktion (Beschreibung) und Reduzierung dieser Dinge
auf die für die Betrachtung notwendigen Aspekte statt.
3
Alle Objekte einer bestimmten Menge (Artikel, Kunde oder Mitarbeiter) haben
dieselben Eigenschaften (Attribute), aber verschiedene Attributswerte.
4
Alle gleichartigen Objekte unterwerfen sich denselben Operationen bzw. Methoden1
(z. B. Erfassen, Ändern, Löschen, Anzeigen).
Jedes Objekt hat eine eigene Identität (Identity)2. Die Struktur (State) und das gleiche Verhalten (Behavior) von Objekten einer bestimmten Menge (Artikel oder Kunden) werden in
Klassen zusammengefasst.
1
2
10
Operatoren und Methoden haben in diesem Zusammenhang die selbe Bedeutung.
Die englischen Begriffe in Klammern entsprechen der internationalen Fachsprache.
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 11
1.2 Lösungsansatz: Objekte, Klassen, Attribute und Methoden (Operationen)
1.2.2
Klassen
Lea und Kevin möchten für den Shop eine kleine Artikelverwaltung in Java programmieren.
Sie überlegen sich, welche bedeutenden Informationen sie für den Verkauf benötigen. Bei
der Betrachtung ihrer Artikel finden sie als gemeinsame Eigenschaften (Attribute) zunächst
die Artikelbeschreibung (bezeichnung)1, den Preis (preis) und den Lagerbestand (bestand).
Dieses Muster gilt für alle Artikel.
Klassen beschreiben also nicht individuelle Objekte, sondern definieren eine Menge von
Objekten, die ein gemeinsames Muster besitzen. In dem Shop gibt es entsprechend die
Klasse der Kunden, die Klasse der Lieferanten, die Klasse der Mitarbeiter und die Klasse der
Artikel. Der Begriff Klasse (class) ist der anerkannte Fachbegriff zur Definition solcher
Muster.
Eine Klasse ist die abstrakte Beschreibung (Schablone) der Objekte. Jedes dieser Objekte
(„Klassenarbeitsordner“) ist ein Exemplar (instance), z. B. der Klasse „Artikel“. Es darf im
objektorientierten Entwurf keine Objekte geben, die nicht zu einer bestimmten Klasse
gehören. Der Lieferant „Faulhaber & Geizig“ ist ein Exemplar (instance of) der Klasse
„Lieferer“. Die Schülerin „Lea Scardi“ oder der Schüler „Kevin Schneider“ sind Exemplare
(object) der Klasse Mitarbeiter.
Es ist wichtig, den Unterschied zwischen Klassen und Objekten zu begreifen. Die Klasse
beschreibt eine Menge von möglichen Objekten (vgl. Abbildung 1).
Bei der Analyse von Geschäftsprozessen wird der Klassenbegriff bei der Zusammenfassung
(Clustering) von realen Dingen verwendet. In der Welt der objektorientierten Systementwicklung dient die Klasse primär der Erzeugung von Objekten (vgl. Abbildung 1). Diese sind
dann Elemente, die während des Programmablaufs aus der durch die Klasse vorgegebenen
Schablone erzeugt werden.
Merke:
1 Eine Klasse erzeugt Objekte.
2 Alle Objekte einer Klasse haben die gleichen Eigenschaften (= Attribute).
3 Alle Objekte einer Klasse haben das gleiche Verhalten (= Methoden).
1.2.3
Attribute (Eigenschaften)
Ein Objekt wird durch seine Attribute und deren Werte beschrieben. Das Objekt „artikel_1“
vom Typ der Klasse „Artikel“ hat beispielsweise die Bezeichnung „Radiergummi, Plastik,
rot“, kostet 1€ und hat zurzeit einen Lagerbestand von 25 Stück. Die Attribute beschreiben
die Eigenschaften eines Objektes.
1
Attribute werden in der Objektorientierung klein geschrieben.
11
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 12
1 Objekte, Attribute und Fachklasse
Merke:
1 Attributswerte beschreiben die Eigenschaft eines Objektes.
2 Alle Objekte derselben Klasse besitzen die gleichen Attribute, aber unterschiedliche Attributswerte.
3 Jedes Objekt benötigt Speicherplatz für seine Attributswerte.
1.2.4
Methoden (Verhalten)
Attributswerte werden den Objekten über Operationen (Methoden) zugeordnet. Für die
einzelnen Artikel benötigt man jeweils eine Methode zum Erfassen eines Attributswertes.
Bei den Geschäftsprozessen brauchen die Mitarbeiter Informationen über die gespeicherten Objekte, z. B. spielt beim Verkauf eines Artikels der Verkaufspreis eine entscheidende Rolle. Deshalb wird auch eine Methode zum Auslesen der einzelnen Attributswerte erstellt.
Das Artikelobjekt „artikel_1“ hat die Attribute „Artikelbezeichnung“, „Artikelpreis“ und
„Artikelbestand“. Für das Erfassen der Attributswerte werden dann die Methoden
„setBezeichnung()“, „setPreis()“ und „setBestand()“ verwendet. Die Methoden zum Erfassen
von Daten haben das Präfix „set“. Zum Auslesen werden entsprechende andere Methoden
in der Klasse mit dem Präfix „get“ zur Verfügung gestellt, z. B. „getBestand()“.
Selbstverständlich lassen sich mit Methoden auch Attributswerte ändern, etwa bei einer
Preiserhöhung „erhoehePreis()“.
Merke:
1 Mit Methoden werden Attributswerte in Objekte eingelesen, geändert und ausgelesen. Das Einlesen erfolgt mit set-Methoden, das Auslesen mit get-Methoden.
2 Alle Objekte, die aus derselben Klasse erzeugt wurden, besitzen die selben
Methoden (mindestens Erfassen und Auslesen der einzelnen Attributswerte).
3 Die Methoden werden von der Fachklasse zur Verfügung gestellt.
Aufgaben
1. Nennen Sie mindestens fünf reale Objekte des Schreibwarenshops.
2. Welche Attribute muss nach Lea und Kevin ein Artikelobjekt besitzen, damit die
Eigenschaften eines bestimmten Artikels beschrieben werden können?
3. Beschreiben Sie in eigenen Worten den Unterschied zwischen Attribut und Attributswert.
4. Beschreiben Sie in eigenen Worten die Beziehung zwischen Klasse und Objekt.
5. Wer stellt Methoden zur Verfügung? Welche Methoden müssen mindestens vorhanden sein?
12
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 13
1.2 Lösungsansatz: Objekte, Klassen, Attribute und Methoden (Operationen)
6. Sie kennen vielleicht Attributswerte bei den Tabellen eines relationalen Datenbankmanagementsystems (rDBMS, z. B. MS Access)1. Wie werden dort dem Benutzer die Artikeldaten zur Verfügung gestellt? Beschreiben Sie den entscheidenden
Unterschied zum Lesen von Attributen eines OO-Objektes.
externe Objekte
Realität
Klasse Artikel
Artikel
UML
Klasse
UML
Objekte
Im Beispiel
werden zwei
Objekte dargestellt.
bezeichnung
preis
bestand
setBezeichnung()
setPreis()
setBestand()
getBezeichnung()
getPreis()
getBestand()
Objekte werden aus der Schablone
Artikel erzeugt
훳
훳
Artikel: linealHolz
Artikel: bleiStift
bezeichnung =
Lineal Holz
Länge 100 cm
preis = 3,20
bestand = 22
bezeichnung =
Bleistift mit
Radiergummi
Größe 12
preis = 1,40
bestand = 4
Eine Klasse
– ist die abstrakte
Beschreibung
(= Schablone) der
Objekte
– legt die Attribute
(= Struktur) der
Objekte fest
– legt die Operationen
(= Verhalten) der
Objekte fest
Ein Objekt (interne
Objekte)
– ist erzeugt aus der
Klassenschablone
– repräsentiert die
vom Programm zu
verwaltenden konkreten Daten
(Attributwerte)
– besitzt eine eindeutige Idendität
(Es könnten beliebig viele Objekte aus der Schablone erzeugt werden.)
Abbildung 1: Darstellung von Klasse, Methoden und zwei Objekten.
Ganz oben werden drei reale Objekte des Schreibshops dargestellt. Alle Artikel werden
im Rechner repräsentiert (Abstraktion der Realität) durch die drei Attribute Bezeichnung,
Preis und Lagerbestand. Dafür gibt es in der Klasse Artikel die Attributsnamen:
bezeichnung, preis und bestand. Die Klasse stellt für jedes Attribut Methoden zur Verfügung, und zwar eine zum Erfassen (set-Methoden) der Daten und eine zum Lesen (getMethoden) der Daten. Im Beispiel werden die beiden Objekte „linealHolz“ und „bleiStift“
aus der Klasse (Schablone) „Artikel“ erzeugt. Die Attributswerte stehen rechts vor dem
Gleichheitszeichen.
■
1
MS Access ist ein eingetragenes Warenzeichen der Microsoft Corporation USA.
13
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 14
1 Objekte, Attribute und Fachklasse
1.2.5
Die Klasse „Artikel“ in UML-Darstellung
Die Abbildung 2 zeigt, dass die Klasse „Artikel“ (= Schablone) aus folgenden Elementen
beschrieben wird:
– dem Klassennamen,
– den vereinbarten Attributen
– und den Methoden.
Die Unified Modeling Language1 ist eine Vereinbarung zur Konstruktion und
Dokumentation von Modellen für Softwaresysteme. Ziel ist es, den Entwurf und die Entwicklung von Softwaremodellen auf einheitlicher Basis zu diskutieren. Ein Element der UML
stellt Klassen und ihre Beziehungen dar, das Klassendiagramm (class diagram). Klassen, z. B.
„Artikel“, „Mitarbeiter“, „Kunden“, „Lieferanten“ usw. sind „Objektfabriken“. Lea und Kevin
haben eine Vorstellung, welche Artikelobjekte die Objektfabrik zunächst erstellen soll.
Dabei begnügen sie sich in der Übungsphase, wie bereits erwähnt, zunächst mit drei
Attributen.
In großen Projekten der betrieblichen Praxis werden die Vorstellungen der Unternehmer in
einem Pflichtenheft (Sollkonzept) festgehalten. Die Fachklassen, z. B. „Artikel“, „Mitarbeiter“, „Kunden“, „Lieferanten“, setzen die im Pflichtenheft festgelegten fachlichen
Anforderungen in einen objektorientierten Ansatz um.
Die Vorgaben von Kevin und Lea
Klassendiagramm allgemein
Artikel
Klassennamen
bezeichnung
preis
bestand
Attribute
setBezeichnung()
setPreis()
setBestand()
getBezeichnung()
getPreis()
getBestand()
Methoden
Abbildung 2
Merke:
1
Fachklassen erzeugen Objekte.
2
Fachklassen realisieren die im Pflichtenheft festgelegten Anforderungen.
3
Eine Fachklasse erhält einen Namen, Attribute und Methoden.
1
14
Entwickelt wurde die UML von Grady Boch, Ivar Jacobsen und Jim Rumbaugh.
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 15
1.2 Lösungsansatz: Objekte, Klassen, Attribute und Methoden (Operationen)
1.2.6
Modellierung der Fachklasse „Artikel“
Kevin und Lea haben im Internet nachgeschaut und festgestellt, dass es zahlreiche Werkzeuge (Software-Tools) auf dem Markt gibt, mit denen man UML-Modellierung vornehmen
kann. Kevin benutzt in seiner Berufsschulklasse ein anderes Tool als Lea. Beide Tools sind
für private Benutzer kostenfrei (Freeware). Für die weitere Vorgehensweise entscheiden sie,
dass jeder mit seinem Tool modelliert und den Code in der Programmiersprache Java1 entwickelt. Anschließend findet ein Vergleich der Ergebnisse statt.
Lea liefert folgendes Ergebnis:
Artikel
– bezeichnung: String
– preis: int
– bestand: int
+
+
+
+
+
+
+
Artikel()
getBezeichnung()
setBezeichnung(pBezeichnung: String)
getPreis()
setPreis(pPreis: int)
getBestand()
setBestand(pBestand: int)
Abbildung 3
Folgende Änderungen zum ersten Modell sind erkennbar:
– Die Attribute haben einen Datentyp.7
– Den get-Methoden wird ein entsprechender Datentyp zugeordnet.
– Die set-Methoden erhalten einen Parameter zur Übergabe von Werten.
– + Artikel() ist eine besondere Methode. Man nennt sie „Konstruktor“; sie dient der
Erzeugung von Objekten (hier Artikelobjekte). Mit ihrer Hilfe wird für das zu
erstellende Objekt Speicherplatz reserviert.
– Folgende Regeln sind in UML zwingend:
– Klassennamen beginnen mit Großbuchstaben
– Attributs- und Methodennamen beginnen mit Kleinbuchstaben.
– Der Konstruktor beginnt mit einem Großbuchstaben (= Name der Klasse).
1
2
Java ist ein Produkt des Unternehmens Sun Microsystems.
Das Attribut Preis erhält vorläufig aus Vereinfachnungsründen den Datentyp Integer „int“, der für ganze Zahlen steht.
15
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 16
1 Objekte, Attribute und Fachklasse
Merke:
1
Die Fachklasse besteht aus dem Klassennamen und Klassenrumpf. Der Klassenrumpf
besteht aus Attributen und Methoden.
2
Eine spezielle Methode ist der Konstruktor. Er dient der Erzeugung von Objekten einer
Klasse.
3
Die set-Methoden übertragen Attributswerte an die Objekte. Deshalb benötigen sie
einen Parameter.
4
Die get-Methoden lesen Daten aus einem Objekt. Ihre Parameter repräsentieren die zugehörigen Attribute des Objektes und haben daher die entsprechenden Datentypen.
Aufgaben
1.
2.
3.
4.
1.3
Schildern Sie in eigenen Worten die Aufgaben des Konstruktors.
Welche Aufgaben haben die set-Methoden? Was ist ein Parameter?
Welche Aufgaben übernehmen die get-Methoden?
Erstellen Sie selbstständig mit ihrem Modellierungstool die Fachklasse Artikel.
Umsetzung in Java
Lea verwendet eines von vielen Modellierungstools, das aus einem UML-Modell automatisch den Java-Code erzeugt. In diesem Tool sind UML-Darstellung und JAVA-Code
in eigenen Fenstern sichtbar:
Aus dem
UML-Modell
wird
der JAVA Code
generiert
16
Abbildung 4
OLG-06-3871_Umbruch
15.03.2007
11:33 Uhr
Seite 17
1.3 Umsetzung in Java
Für Java gibt es eine täglich größer werdende Zahl von Entwicklungsumgebungen.
Bei der hier verwendeten sind im Paketexplorer die wichtigsten Elemente des Projektes
dargestellt. Bei der UML-Modellierung wird den Attributen wie üblich ein Datentyp
zugeordnet. Die entsprechenden „set“ und „get“-Methoden werden dann automatisch
generiert. Bei dem oben verwendeten Tool wird der Konstruktor gesondert bestimmt.
■
Folgender Code wird generiert (ähnliche Darstellungen möglich):
class Artikel
{
private String bezeichnung;
//die Variablendekla//rationen
private int preis;
private int bestand;
Artikel()
{
}
// der Konstruktor
String getBezeichnung() // die Standardmethoden
{
return bezeichnung;
}
void setBezeichnung(String pBezeichnung)
{
this.bezeichnung = pBezeichnung;
}
int getPreis()
{
return preis;
}
void setPreis(int pPreis)
{
this.preis = pPreis;
}
int getBestand()
{
return bestand;
}
void setBestand(int pBestand)
{
this.bestand = pBestand;
}
}
17
