Kuhlmann Programmieren mit JAVA
Kuhlmann Programmieren mit JAVA
Kuhlmann Programmieren mit JAVA
Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.
YUMPU macht aus Druck-PDFs automatisch weboptimierte ePaper, die Google liebt.
<strong>Kuhlmann</strong> <strong>Programmieren</strong> <strong>mit</strong> <strong>JAVA</strong><br />
Eine strukturierte Einführung<br />
Merkur<br />
Verlag Rinteln
Wirtschaftswissenschaftliche Bücherei für Schule und Praxis<br />
Begründet von Handelsschul-Direktor Dipl.-Hdl. Friedrich Hutkap †<br />
Die Verfasser:<br />
Gregor <strong>Kuhlmann</strong><br />
Weiteres Begleitmaterial zum Buch fi nden Sie unter<br />
http://www.merkur-verlag.de/datencd/0804.zip<br />
Das Werk und seine Teile sind urheberrechtlich geschützt. Jede Nutzung in anderen als den gesetzlich<br />
zugelassenen Fällen bedarf der vorherigen schriftlichen Einwilligung des Verlages. Hinweis zu<br />
§ 52 UrhG: Weder das Werk noch seine Teile dürfen ohne eine solche Einwilligung eingescannt und<br />
in ein Netzwerk eingestellt werden. Dies gilt auch für Intranets von Schulen und sonstigen Bildungseinrichtungen.<br />
* * * * *<br />
1. Aufl age 2012<br />
© 2012 by MERKUR VERLAG RINTELN<br />
Gesamtherstellung:<br />
MERKUR VERLAG RINTELN Hutkap GmbH & Co. KG, 31735 Rinteln<br />
E-Mail: info@merkur-verlag.de<br />
lehrer-service@merkur-verlag.de<br />
Internet: www.merkur-verlag.de<br />
ISBN 978-3-8120-0804-4
Editorial<br />
Die Entwicklung der elektronischen Datenverarbeitung weist drei grundlegende<br />
Elemente auf. Man kann sie festmachen an den Begriffen Miniaturisierung, Digitalisierung<br />
und Vernetzung. Die drei Meilensteine erinnern an fundamentale Ereignisse<br />
der jüngeren Technikgeschichte. Erst die Kleinheit des Rechners ermöglichte es bei<br />
geringem Gewicht, der raumfahrtorientierten Raketentechnik den Weg zum Mond<br />
zu weisen. Der digitalisierte Austausch von Informationen – vom Satellitenempfang<br />
bis hin zur Unterhaltungsmusik und zum Handytelefon – ermöglicht das, was man<br />
heute <strong>mit</strong> den Anwendungslösungen unserer modernen Informationsgesellschaft<br />
verbindet.<br />
Aus einer anderen Sichtweise offenbart die Entwicklung der Daten- und Informationsverarbeitung<br />
neben mechanischen und elektronischen Computerelementen Aspekte<br />
der Software bzw. der Programme, die als Schlüsselpositionen in die gesellschaftlichen<br />
Entwicklungen gewissermaßen eingebettet sind. Die aktuelle<br />
Diskussion, Kommunikation in den digitalen Netzen einer politischen Kontrolle zu<br />
unterwerfen und gespeicherte Daten zu erschließen, offenbart, dass Information und<br />
digitalisierte Kommunikation von großer gesellschaftlicher Bedeutung sind – Wissen<br />
ist Macht.<br />
Der technische Fortschritt der von maschineller Intelligenz geprägten Computerindustrie<br />
ist die Chance, Innovation zu gewinnen und wirtschaftliche Wettbewerbsfähigkeit<br />
zu erhalten. Technologischer Fortschritt ist der Motor dafür, die strukturellen<br />
Veränderungen der Weltwirtschaft in den Griff zu bekommen und die Grenzen<br />
weiter zu stecken, als sie durch die Verknappung der natürlichen Ressourcen vorgegeben<br />
scheinen.<br />
Der Schul-, Ausbildungs- und Weiterbildungsbereich nimmt dazu eine Schlüsselposition<br />
ein. Die neue vom Merkur Verlag Rinteln herausgegebene Buchreihe MER-<br />
KUR-COMPUTER-ANWENDUNGEN macht Problemlösungen durch eine benutzerorientierte<br />
Aufbereitung von Softwarewissen nachvollziehbar. Die vorliegenden<br />
Bücher bieten grundlegende Informationen für die Arbeit <strong>mit</strong> modernen Informations-<br />
und Kommunikationssystemen, so wie sie beispielsweise im berufsbezogenen<br />
Unterricht in beruflichen Schulen, Volkshochschulen und im betrieblichen Alltag von<br />
IT-Fachleuten, Kaufleuten, Auszubildenden und von Studierenden an Fachhochschulen<br />
benötigt werden. Ziel ist die Ver<strong>mit</strong>tlung der Grundlagen in logischen Zusammenhängen.<br />
Die Bücher eignen sich sowohl als Lehrbücher für den Unterricht<br />
als auch für ein Selbststudium im Fachgebiet Informationswirtschaft. Für die praktische<br />
Umsetzung der Beispiele und Aufgaben werden Rechner <strong>mit</strong> dem Betriebssystem<br />
Windows benötigt.<br />
Rudolf Hambusch
4<br />
Inhaltsverzeichnis<br />
Inhaltsverzeichnis<br />
Einführung 10<br />
1 Ein erster Blick auf ein Java-Programm 12<br />
1.1 Klasse und Objekt 12<br />
1.2 Repräsentation eines Objektes im Rechner 13<br />
1.2.1 Klassendiagramm 13<br />
1.2.2 Umsetzung in eine Java-Klasse 14<br />
1.2.3 Trennung zwischen Fachklasse und Bedienoberfläche 21<br />
1.3 Zusammenfassung 22<br />
1.4 Aufgaben 23<br />
1.5 Lösungen 25<br />
2 Programmierumgebung 26<br />
2.1 Java installieren 26<br />
2.2 Integrierte Entwicklungsumgebung für Java 26<br />
2.3 Eingabe des Quellcodes 27<br />
2.4 Übersetzen 31<br />
2.5 Ausführen eines Programms 34<br />
2.6 Testen eines Programms 35<br />
2.6.1 Testen einer Klasse 35<br />
2.6.2 Gesamttest 38<br />
2.7 Zusammenfassung 40<br />
2.8 Aufgaben 41<br />
2.9 Lösungen 42<br />
3 Elemente eines Java-Programms 44<br />
3.1 Schreibweisen in Java 44<br />
3.2 Aufbau einer Klassendefinition 45<br />
3.2.1 Kommentare 45
Inhaltsverzeichnis 5<br />
3.2.2 Klassenvereinbarung 46<br />
3.3 Variablen 47<br />
3.3.1 Pri<strong>mit</strong>ive Datentypen 47<br />
3.3.2 String 49<br />
3.4 Konstruktor 52<br />
3.4.1 Einfacher Konstruktor 52<br />
3.4.2 Konstruktor <strong>mit</strong> Parameter 52<br />
3.5 Methoden 55<br />
3.5.1 Arten von Methoden 55<br />
3.5.2 Aufruf einer Methode 58<br />
3.6 Methoden überladen 61<br />
3.7 Zusammenfassung 64<br />
3.8 Aufgaben 65<br />
3.9 Lösungen 67<br />
4 Zuweisungen und Botschaften 72<br />
4.1 Wertzuweisungen bei Rechenoperationen 72<br />
4.1.1 Typanpassung – cast 72<br />
4.1.2 Rechenoperationen 73<br />
4.1.3 Zuweisungen bei Zeichenketten 77<br />
4.1.4 Zuweisung zwischen Zeichenkette und Int-Variablen 78<br />
4.2 Wertzuweisung durch Tastatureingabe 79<br />
4.3 Ausgabeanweisung 82<br />
4.4 Botschaften zwischen zwei Objekten einer Klasse 85<br />
4.5 Zusammenfassung 92<br />
4.6 Aufgaben 93<br />
4.7 Lösungen 96<br />
5 Auswahlanweisungen 105<br />
5.1 Einseitige Auswahl 105<br />
5.1.1 Klärung der Problemstellung 105
6<br />
Inhaltsverzeichnis<br />
5.1.2 if-Anweisung 108<br />
5.1.3 Ablaufsteuerung 110<br />
5.2 Bedingungsausdrücke 111<br />
5.2.1 Einfacher numerischer Bedingungsausdruck 111<br />
5.2.2 Vergleich bei Zeichenketten und booleschen Ausdrücken 112<br />
5.3 Geschachtelte if-Anweisung 113<br />
5.4 Zusammenfassung 114<br />
5.5 Aufgaben 115<br />
5.6 Lösungen 119<br />
5.7 Zweiseitige Auswahl 124<br />
5.7.1 Klärung der Problemstellung 124<br />
5.7.2 if-else-Anweisung 124<br />
5.7.3 Ablaufsteuerung 127<br />
5.7.4 Entwicklung einer komplexen Anwendung 129<br />
5.7.5 Leeranweisung 138<br />
5.8 Komplexe Bedingungen 140<br />
5.8.1 UND-Verknüpfung 140<br />
5.8.2 ODER-Verknüpfung 141<br />
5.9 Zusammenfassung 145<br />
5.10 Aufgaben 146<br />
5.11 Lösungen 149<br />
5.12 Mehrseitige Auswahl 155<br />
5.12.1 Charakteristik 155<br />
5.12.2 Zusammenfassung 158<br />
5.12.3 Aufgaben 159<br />
5.12.4 Lösungen 161<br />
6 Wiederholungsanweisungen 167<br />
6.1 Kopfgesteuerte Schleife: while 168<br />
6.1.1 Funktionsweise 168<br />
6.1.2 Ablaufsteuerung 171
Inhaltsverzeichnis 7<br />
6.2 Fußgesteuerte Schleife: do - while 171<br />
6.2.1 Funktionsweise 171<br />
6.2.2 Ablaufsteuerung 175<br />
6.3 Zählergesteuerte Schleife: for 175<br />
6.3.1 Funktionsweise 175<br />
6.3.2 Ablaufsteuerung 179<br />
6.4 Break 181<br />
6.5 Zusammenfassung 183<br />
6.6 Aufgaben 184<br />
6.7 Lösungen 189<br />
7 Objektsammlungen 198<br />
7.1 Felder für einfache Datentypen 198<br />
7.1.1 Eindimensionales Feld 198<br />
7.1.2 Zweidimensionales Feld 208<br />
7.2 Felder für Objekte 213<br />
7.3 ArrayList 216<br />
7.3.1 ArrayList bei vordefiniertem Objekttyp 216<br />
7.3.2 ArrayList bei selbst definierten Objekten 221<br />
7.4 Zusammenfassung 227<br />
7.5 Aufgaben 228<br />
7.6 Lösungen 236<br />
8 Vererbung, Polymorphie und Interface 250<br />
8.1 Konzept 250<br />
8.2 Programmtechnische Umsetzung 251<br />
8.3 Vererbung <strong>mit</strong> Redefinition 256<br />
8.4 Polymorphie 259<br />
8.5 Interface 261<br />
8.6 Zusammenfassung 264<br />
8.7 Aufgaben 265
8<br />
Inhaltsverzeichnis<br />
8.8 Lösungen 269<br />
9 Exceptions – Behandlung von Ausnahmen 279<br />
9.1 Programmabstürzen vorbeugen 279<br />
9.1.1 Häufige Fehlertypen 279<br />
9.1.2 try-catch-Konstruktion 279<br />
9.1.3 Einschub: Wrapper-Klasse 280<br />
9.1,4 Ablauflogik der try-catch-Konstruktion 281<br />
9.1.5 Reihung von catch-Blocks 283<br />
9.2 Zusammenfassung 285<br />
9.3 Aufgaben 285<br />
9.4 Lösungen 286<br />
10 Persistenz – Speicherung von Daten 291<br />
10.1 Begriff 291<br />
10.2 Textdateien 291<br />
10.2.1 Schreiben einer Textdatei 291<br />
10.2.2 Lesen einer Textdatei 293<br />
10.3 Binärdateien 294<br />
10.3.1 Schreiben einer Binärdatei 294<br />
10.3.2 Lesen einer Binärdatei 297<br />
10.4 Zusammenfassung 298<br />
10.5 Aufgaben 299<br />
10.6 Lösungen 301<br />
11 Benutzeroberflächen 309<br />
11.1 NetBeans als Entwicklungsumgebung 309<br />
11.1.1 Eingabe eines Programms 309<br />
11.1.2 Übernahme von Klassen aus BlueJ 311<br />
11.1.3 Debbuger 312<br />
11.2 Graphical User Interface 313
Inhaltsverzeichnis 9<br />
11.2.1 Aufbau einer Benutzeroberfläche 313<br />
11.2.2 Funktionen und Methoden programmieren 317<br />
11.3 Entwicklung einer komplexen Anwendung 319<br />
11.3.1 Problemstellung 319<br />
11.3.2 Klassen und Methoden implementieren 320<br />
11.4 Zusammenfassung 328<br />
11.5 Aufgaben 329<br />
11.6 Lösungen 331<br />
12 Datenbank-Anwendung 340<br />
12.1 Datenbankverbindung <strong>mit</strong>tels Treiber 340<br />
12.2 Installation von MySQL 340<br />
12.3 Anlage einer Datenbank 341<br />
12.4 Mit einer Datenbank arbeiten 342<br />
12.4.1 Direkter Zugriff auf die Datenbank 342<br />
12.4.2 Zugriff per Java-Programm 344<br />
12.4.3 Verknüpfung von Tabellen 348<br />
12.5 Windows-Anwendung und Datenbankzugriff 349<br />
12.6 Zusammenfassung 355<br />
12.7 Aufgaben 355<br />
12.8 Lösungen 356<br />
13 Anhang 362<br />
13.1 Diagrammformen 362<br />
13.2 Literaturverzeichnis 364<br />
13.3 Sachwortregister 365
10<br />
Einführung<br />
Einführung<br />
Ein Buch über die Programmiersprache Java zu schreiben ist fast ein aussichtsloses<br />
Unterfangen. Selbst Bücher <strong>mit</strong> einem Umfang von mehr als 600 Seiten sind nicht in<br />
der Lage, alle Klassen und Methoden dieser Sprache darzustellen. Nun, das ist möglicherweise<br />
auch nicht erforderlich, weil zu Java ausgezeichnete Dokumentationen im Internet<br />
existieren. Das vorliegende Buch stellt nur einen kleinen Teil der Java-Klassen dar.<br />
Dieses Buch hat nicht die Aufgabe, die Programmiersprache Java in allen Einzelheiten<br />
zu beschreiben. Es geht dem Autor vielmehr darum aufzuzeigen, wie man unter Verwendung<br />
der objektorientierten Sprache Java Programme zur Lösung von Problemen entwickelt<br />
und zum Laufen bringt. Da hilft keine ausführliche Syntaxbeschreibung, genauso<br />
wenig wie man durch Auswendiglernen der Regeln des Tennisspiels ein guter Tennisspieler<br />
werden kann. Aus diesem Grund werden hier die Programme vollständig abgebildet,<br />
da<strong>mit</strong> man nachvollziehen kann, wie es gemacht wird. Es sollte aber nicht beim<br />
Lesen der Programme bleiben. Für das Verständnis der Programmierung sind die Eingabe<br />
der Programme und die anschließende Ausführung von großer Wichtigkeit. Auch<br />
hier gilt wie beim Sport: Der praktische Vollzug fördert das Verständnis für Begrifflichkeit<br />
und Syntax.<br />
Um dieses Buch effektiv nutzen zu können, sollten Sie Grundkenntnisse des Betriebssystems<br />
haben, <strong>mit</strong> dem Sie arbeiten. Java kann auf allen gängigen Betriebssystemen<br />
eingesetzt werden. Hier wird, falls erforderlich, auf Windows Bezug genommen.<br />
Javas Unabhängigkeit vom Betriebssystem ist einer der Gründe, weshalb Java heute in<br />
fast allen Bereichen der Informationstechnologie eingesetzt wird. Java-Programme findet<br />
man auf Handys, Navigationssystemen, Web-Servern oder eben auch auf Arbeitsplatzrechnern.<br />
Die Unabhängigkeit wird durch die Java Virtual Machine, kurz VM genannt,<br />
hergestellt. Die VM sorgt für die Ausführung des von Ihnen geschriebenen Java-<br />
Programms. So<strong>mit</strong> kommuniziert ein Java–Programm auch nicht direkt <strong>mit</strong> dem Betriebssystem.<br />
Für die Eingabe eines Java-Programms genügt ein einfacher Editor. Auf Kommandozeilen-Ebene<br />
kann man die Programme übersetzen und starten. Das ist jedoch recht mühselig.<br />
Deshalb ist eine Vielzahl von Programmierumgebungen bzw. Integrated Development<br />
Environments, kurz: IDE, entwickelt worden, um dem Programmierer die Arbeit<br />
zu erleichtern.<br />
Im ersten Teil wird die IDE BlueJ eingesetzt, die man auch als Lernumgebung charakterisieren<br />
kann. In den letzten beiden Kapiteln wird das professionelle NetBeans eingesetzt.<br />
Beide Programme wie auch Java selbst und die später eingesetzte Datenbankssoftware<br />
MySQL sind kostenfrei im Internet erhältlich.
Einführung 11<br />
Java: www.java.com<br />
BlueJ: www.bluej.org<br />
NetBeans: www.netbeans.org<br />
MySQL: www.mysql.de<br />
Für die Dokumentation von Klassen ist die BlueJ-Erweiterung Klassenkarte hilfreich.<br />
Dieses Programm können Sie herunterladen unter http://klassenkarte.steinhuber.de.<br />
Zum Aufbau des Buches: Im ersten Abschnitt erhalten Sie einen Überblick über wichtige<br />
Begrifflichkeiten wie Klasse und Objekt sowie ihre Umsetzung in ein Java-Programm.<br />
Im zweiten Kapitel werden Sie in die praktische Handhabung der Programmierumgebung<br />
BlueJ eingeführt, sodass Sie ein Programm eingeben und testen können. Wurden<br />
Sie in den ersten beiden Kapiteln durch die Java-Welt geführt, beginnt im dritten Abschnitt<br />
der Einstieg in die Systematik. Dort werden die Elemente, aus denen ein Java-<br />
Programm besteht, näher erläutert. Mit Zuweisungen und Botschaften zwischen Objekten<br />
beschäftigt sich das vierte Kapitel.<br />
Viele Problemstellungen in Wirtschaft und Technik lassen sich nicht durch lineare Prozesse<br />
lösen. Es werden Befehle benötigt, die alternative oder iterative Programmausführungen<br />
ermöglichen. Auswahl- und Wiederholungsanweisungen sind Gegenstand der<br />
beiden folgenden Abschnitte. Im siebten Kapitel wird die Frage diskutiert, wie komplexe<br />
Datengebilde bzw. Objektsammlungen im Rechner abgebildet und programmtechnisch<br />
behandelt werden. Ein für objektorientierte Programmierung sehr wichtiges Thema<br />
steht im achten Kapitel an: Vererbung.<br />
In den Kapiteln 10, 11 und 12 werden Dateioperationen sowie Ein- und Ausgabeoperationen<br />
in einer Benutzeroberfläche behandelt. Da bei diesen Operationen Fehler auftreten<br />
können, die zu einem Systemabsturz führen, muss entsprechende Vorsorge getroffen<br />
werden. Die dazu erforderlichen Anweisungen werden im Kapitel 9 erläutert. „Richtige“<br />
Datenverarbeitung wird im Kapitel 10 thematisiert: Dateioperationen. Abschnitt 11<br />
führt in die Arbeit <strong>mit</strong> Benutzeroberflächen ein. Dabei wird auch die Bedienweise von<br />
NetBeans skizziert. Kapitel 12 schließlich zeigt auf, wie eine Datenbank eingebunden<br />
und für die Datenhaltung genutzt werden kann.<br />
Zur Erleichterung der Arbeit können Sie die vom Autor verwendeten Beispiele und Lösungen<br />
der Übungsaufgaben von der Website<br />
http://www.merkur-verlag.de/datencd/0804.zip<br />
herunterladen. Die Dateien entpacken Sie in ein Verzeichnis, zum Beispiel c:\javalernen.<br />
Sie können aber auch ein anderes Verzeichnis wählen.<br />
Der Autor wünscht den Leserinnen und Lesern viel Freude beim Lesen und Lernen. Er<br />
freut sich über Rückmeldungen: gkuhlmann@gmx.de<br />
Ein herzliches Dankeschön gilt Ute Jacobs, Werner Löhr, Nana Dyckerhoff, Heike Köppe<br />
und Stefan Justen für die konstruktive Kritik und Durchsicht des Manuskriptes.<br />
Gregor <strong>Kuhlmann</strong>
12<br />
Ein erster Blick auf ein Java-Programm<br />
1 Ein erster Blick auf ein Java-Programm<br />
Von der Programmiersprache Java behauptet man, sie sei relativ leicht zu erlernen. Diese<br />
Aussage gilt nur bedingt. Java weist einen in sich systematischen Aufbau auf und ist<br />
im Internet gut dokumentiert. Wenn man die Logik, nach der Java-Programme aufgebaut<br />
werden müssen, verstanden hat, ist die Programmentwicklung in Java zwar nicht<br />
leicht, aber gut erlernbar.<br />
1.1 Klasse und Objekt<br />
Für das Verständnis der Programmentwicklung in Java ist der Begriff Objekt äußerst<br />
wichtig. Objekte sind Gegenstände der realen oder ideellen Welt. So sind ein Auto oder<br />
auch ein Vertrag abbildbare Objekte. Ein Objekt wird unter den Gesichtspunkten Attribute<br />
und Methoden betrachtet. Methoden beschreiben die Operationen, die ein Objekt<br />
ausführen kann. Attribute kennzeichnen die Beschaffenheit eines Objektes.<br />
Ein Beispiel mag die Begriffe Klasse und Objekt verdeutlichen. Wenn Sie ein Sparkonto<br />
bei einem Kreditinstitut anlegen möchten, müssen Sie einen Kontovertrag <strong>mit</strong> der Bank<br />
abschließen. Der Kontovertrag beinhaltet folgende Bestimmungen:<br />
• Das Sparbuch muss auf eine bestimmte Person ausgestellt sein.<br />
• Die Bank führt das Konto auf Guthabenbasis. Sie lässt also keine Kontoüberziehung<br />
zu.<br />
• Sie vergütet die eingezahlten Beträge <strong>mit</strong> Zinsen zu einem festgelegten Zinssatz und<br />
schreibt am Ende des Jahres die Zinsen dem Konto gut.<br />
• Der Kontoinhaber erhält dazu ein Sparbuch.<br />
Aus der Umsetzung dieser Bestimmungen des Kontovertrages ergibt sich, dass für die<br />
Erfüllung des Vertrages das Konto über folgende Attribute verfügen muss:<br />
• Angaben zum Kontoinhaber<br />
• Kontostand<br />
• Aufgelaufene Zinsen (Zinsbestand) sowie<br />
• Kontonummer (zur leichteren Verwaltung)<br />
Da<strong>mit</strong> der Kontostand und die Zinsen berechnet werden können, sind folgende Methoden<br />
erforderlich:<br />
• Berechnung des Kontostandes nach Ein- bzw. Auszahlungen<br />
• Berechnung der Zinsen; Grundlage ist der Einzahlungs- bzw. Auszahlungsbetrag<br />
• Fortschreibung des Zinsbestandes durch Zu- und Abbuchen der Zinsen.<br />
Das Sparkonto, das <strong>mit</strong> den obigen Eigenschaften und Methoden für einen Kontoinhaber<br />
angelegt wird, ist so<strong>mit</strong> die Konkretisierung des Vertrages. Es stellt im Sinne der<br />
Objektorientierung ein Objekt dar. Aus der Sicht des Kontoinhabers bildet das übergebene<br />
Sparbuch das Objekt.
Ein erster Blick auf ein Java-Programm 13<br />
Für das Kreditinstitut bedeutet der Vertragsabschluss, dass es ein neues Sparkonto in<br />
seiner Datenbank anlegen muss. Dort wird ein neues Objekt <strong>mit</strong> den persönlichen und<br />
vertraglichen Daten erzeugt. Wie das programmtechnisch realisiert wird, ist in einer<br />
oder mehreren Klassen festgelegt.<br />
Allgemein ausgedrückt beschreibt eine Klasse für eine bestimmte Gruppe von Objekten<br />
deren Attribute und deren Methoden. Ein Objekt ist die Konkretisierung einer Klasse,<br />
auf dem die in der Klasse definierten Methoden angewendet werden können.<br />
1.2 Repräsentation eines Objektes im Rechner<br />
1.2.1 Klassendiagramm<br />
Im Arbeitsspeicher eines Computers kann natürlich nicht ein realer Gegenstand, wie<br />
zum Beispiel das Sparbuch, stehen. Es wird vielmehr durch eine binäre Darstellung<br />
repräsentiert. Wie ein solches Objekt im Arbeitsspeicher aufzubauen ist, beschreibt die<br />
Klasse <strong>mit</strong> den Anweisungen an das Computersystem.<br />
Man kann, wie das obige Beispiel zeigt, die Regelungen aus dem Vertrag zur Führung<br />
eines Sparkontos als Klasse betrachten. Alle Sparkonten werden nach denselben Regeln<br />
bearbeitet. Das ist möglich, weil sie dieselben Attribute und Verarbeitungsmethoden<br />
haben. Nennen wir die Klasse Sparkonto, so soll sie hier vereinfacht über folgende Attribute<br />
verfügen, dargestellt in einem UML-Klassendiagramm:<br />
Sparkonto Klassenname<br />
Kontonummer: Zeichenkette<br />
Kontoinhaber: Zeichenkette<br />
Kontostand: Ganzzahl<br />
Attribute <strong>mit</strong> Datentyp<br />
Ferner muss die Klasse Sparkonto <strong>mit</strong> folgenden Methoden ausgestattet sein:<br />
• Speichern von Kontonummer, Kontoinhaber, Kontostand,<br />
• Wiedergabe von Kontonummer, Kontoinhaber, Kontostand sowie<br />
• Berechnung des neuen Kontostandes nach einer Ein- oder Auszahlung (Kontobewegung).
14<br />
Sparkonto Klassenname<br />
kontonummer: Zeichenkette<br />
Attribute <strong>mit</strong> Datentyp<br />
kontoinhaber: Zeichenkette<br />
kontostand: Ganzzahl<br />
speichern kontonummer<br />
Methoden<br />
speichern kontoinhaber<br />
speichern kontostand<br />
ausgabe kontonummer<br />
ausgabe kontoinhaber<br />
ausgabe kontostand<br />
bearbeiten kontobewegung<br />
Ein erster Blick auf ein Java-Programm<br />
Bei der objektorientierten Programmentwicklung ist es üblich, die Klasse in einem<br />
UML-Klassen-Diagramm zu beschreiben. UML steht für Unified Modeling Language.<br />
Im oberen Teil des Diagramms steht der Name der Klasse. Darunter werden die Attribute<br />
notiert. Im unteren Teil werden die Methoden aufgeführt.<br />
In der Bankpraxis weist ein Sparkonto noch weitere Attribute und Methoden auf. Zur<br />
Erklärung, was eine Klasse ist und wie sie in Java umgesetzt wird, mag die obige Festlegung<br />
reichen.<br />
1.2.2 Umsetzung in eine Java-Klasse<br />
Das obige UML-Klassendiagramm lässt sich relativ leicht in eine Java-Klasse umsetzen.<br />
Klasse Sparkonto<br />
[1] public class Sparkonto<br />
[2] {<br />
[3] private String kontonummer;<br />
[4] private String kontoinhaber;<br />
[5]<br />
[6]<br />
private int kontostand;<br />
[7] public Sparkonto() { // Konstruktor<br />
[8] }<br />
[9] public void setKontonummer (String ktonr) {<br />
[10] kontonummer = ktonr;<br />
[11] }<br />
[12] public void setKontoinhaber (String sparer) {<br />
[13] kontoinhaber = sparer;<br />
[14] }<br />
[15] public void setKontoStand (int betrag) {<br />
[16] kontostand = betrag;<br />
[17] }<br />
[18] public String getKontonummer() {<br />
[19] return kontonummer;<br />
[20] }
Ein erster Blick auf ein Java-Programm 15<br />
[21] public String getKontoinhaber() {<br />
[22] return kontoinhaber;<br />
[23] }<br />
[24] public double getKontoStand() {<br />
[25] return kontostand;<br />
[26] }<br />
[27] public void kontobewegung (int betrag) {<br />
[28] kontostand = kontostand + betrag;<br />
[29] }<br />
[30] }<br />
Erläuterungen<br />
Die folgenden Ausführungen sollen Ihnen einen Überblick darüber ver<strong>mit</strong>teln, wie eine<br />
Klasse <strong>mit</strong> ihren Attributen und Methoden definiert wird.<br />
• Klassenkopf<br />
Die Beschreibung einer Klasse in Java beginnt <strong>mit</strong> der Angabe des Namens der Klasse.<br />
public class Klassenname<br />
{<br />
Variablen<br />
Methoden<br />
}<br />
Mit class wird dem System <strong>mit</strong>geteilt, dass nun eine Klasse beschrieben wird. Alles, was<br />
zu dieser Klasse gehören soll, wird in ein Paar geschweifter Klammern { } gesetzt.<br />
• Variablenvereinbarung<br />
Anschließend werden die Attribute der Klasse bzw. die Variablen vereinbart.<br />
Beispiel<br />
[3] private String kontonummer;<br />
[4] private String kontoinhaber;<br />
[5] private int kontostand;<br />
Die Werte der Attribute werden in Variablen gespeichert. Sie geben Auskunft über den<br />
aktuellen Zustand eines Objekts. Die Variablen bezeichnen Speicherplätze im Arbeitsspeicher<br />
des Computers. Der Begriff Variable erklärt sich daraus, dass der Inhalt der<br />
Speicherplätze veränderbar, variabel ist. Da<strong>mit</strong> das System weiß, wie viel Speicherplatz<br />
bereitgestellt werden muss und wie der Inhalt zu interpretieren ist, muss der Datentyp<br />
angegeben werden.<br />
Vor kontostand steht der Begriff int. int steht für Integer und besagt, dass die Variable<br />
kontostand nur ganze Zahlen aufnehmen kann. Nachkommastellen von Dezimalzahlen<br />
können nicht darin gespeichert werden. Das ist auch nicht erforderlich, weil in diesem<br />
Beispiel die Geldeinheit nicht Euro, sondern Cent ist. In String-Objekten werden Zei-
16<br />
Ein erster Blick auf ein Java-Programm<br />
chenketten gespeichert, wie zum Beispiel “Euro“. Eine Zeichenkette wird stets in Anführungszeichen<br />
gesetzt.<br />
Auf die Charakteristik der verschiedenen Datentypen wird später genauer eingegangen.<br />
• Konstruktor<br />
Auf die Variablenvereinbarung folgt der Konstruktor:<br />
[7] public Sparkonto() { // Konstruktor<br />
[8] }<br />
Der Konstruktor hat denselben Namen wie die Klasse. Hinter dem Namen steht das<br />
Klammerpaar ( ). In allgemeiner Form:<br />
public Klassenname() {<br />
}<br />
Jede Klasse hat einen Konstruktor. Der Konstruktor hat unter anderem die Aufgabe, für<br />
die Umsetzung der Klasse in ein dv-technisch funktionierendes Objekt zu sorgen, da die<br />
Klasse lediglich den Bauplan für die Erzeugung eines Objektes darstellt. Falls der Programmierer<br />
keinen Konstruktor angegeben hat, setzt das Java-System den Standard-<br />
Konstruktor ein.<br />
• set- und get-Methoden<br />
Mit set-Methoden werden die Attributwerte den Speicherplätzen zugewiesen.<br />
[12] public void setKontoinhaber (String sparer) {<br />
[13] kontoinhaber = sparer;<br />
[14] }<br />
Die Arbeitsweise sei hier nur kurz skizziert, weil die Methoden weiter unten näher erklärt<br />
werden. Die Methode setKontoinhaber erhält von einer anderen Stelle des Programms<br />
den Namen des Kunden in einer „Transportvariablen“ sparer <strong>mit</strong>geteilt. Der<br />
Inhalt von sparer wird anschließend der Variablen kontoinhaber zugewiesen. Das<br />
Gleichheitszeichen ist der Operator für eine Wertzuweisung. Der Wert des Ausdrucks,<br />
der rechts vom Gleichheitszeichen steht, wird der Variablen zugewiesen, die links davon<br />
steht.<br />
Mit Hilfe der get-Methoden werden Inhalte von Variablen an eine aufrufende Stelle<br />
geliefert.<br />
[21] public String getKontoinhaber() {<br />
[22] return kontoinhaber;<br />
[23] }<br />
Es ist in Java gebräuchlich, die Namen der Methoden, die Inhalte übernehmen oder<br />
Inhalte liefern, als setter- bzw. als getter-Methoden zu bezeichnen.