Begleittext - Institut für Wissenschaftliches Rechnen

Begleittext: Einführung in das Programmieren in
Java für Nichtinformatiker
Andreas Keese
Institut f. Wissenschaftliches Rechnen
TU Braunschweig
17. November 2014
Der Text, die Abbildungen und Programme wurden mit größter Sorgfalt erarbeitet. Der Autor
kann dennoch für möglicherweise verbliebene fehlerhafte Angaben und deren Folgen weder eine
juristische Verantwortung noch irgendeine Haftung übernehmen. Die in diesem Text erwähnten
Software– und Hardwarebezeichnungen sind in den meisten Fällen auch eingetragene Marken und
unterliegen als solche den gesetzlichen Bestimmungen.
Copyright 1999, 2000, Andreas Keese. Alle Rechte vorbehalten
Inhaltsverzeichnis
1 Einleitung
1.1 Lehrbücher zu Java . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Über diesen Text . . . . . . . . . . . . . . . . . . . . . . . . . . .
2 Grundlagen: Wie arbeitet ein Computer ?
2.1 Der Aufbau eines Computers . . . . . . . . . . . . .
2.2 Organisation des Arbeitsspeichers — Bits und Bytes
2.3 Die Organisation des Arbeitsspeichers — Adressen .
2.4 Programmierung eines Computers . . . . . . . . . .
2.5 Zusammenfassung des Kapitels . . . . . . . . . . . .
3 Das
3.1
3.2
3.3
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2
2
3
5
5
7
9
9
12
Java–Programmiersystem JDK
13
Bestandteile des JDK . . . . . . . . . . . . . . . . . . . . . . . . 13
Übersetzen und Ausführen von Java-Programmen . . . . . . . . . 14
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4 Erste Schritte — die Turtlegraphik
17
4.1 Testen der Turtlegraphik . . . . . . . . . . . . . . . . . . . . . . . 17
4.2 Die Bestandteile eines einfachen Java–Programms . . . . . . . . . 18
4.3 Turtlebefehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1
5 Grundlagen der Java-Syntax
24
5.1 Grundsätzliches zur Syntax von Java–Programmen . . . . . . . . 24
5.2 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . 28
6 Variablen und Datentypen
6.1 Variablen und ihr Typ . . . . . . .
6.1.1 Ganze Zahlen . . . . . . . .
6.1.2 Fließkommazahlen . . . . .
6.1.3 Logischer Datentyp . . . . .
6.1.4 Zeichen und Zeichenketten
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
29
29
30
31
31
32
7 Ausdrücke
7.1 Was ist ein Ausdruck ? . . . . . . . . . . . . .
7.2 Literal–Ausdrücke . . . . . . . . . . . . . . .
7.2.1 Ganzzahlige Literale . . . . . . . . . .
7.2.2 Reellwertige Literale . . . . . . . . . .
7.2.3 Litarale vom Typ boolean . . . . . . .
7.2.4 Zeichenliterale . . . . . . . . . . . . .
7.2.5 Zeichenketten . . . . . . . . . . . . . .
7.3 Verwendung von Variablen . . . . . . . . . .
7.4 Ausdrücke mit Operatoren . . . . . . . . . . .
7.4.1 Arithmetische Operatoren . . . . . . .
7.4.2 Inkrement und Dekrement–Operatoren
7.4.3 Relationale Operatoren . . . . . . . .
7.4.4 Logische Operatoren . . . . . . . . . .
7.4.5 Bitweise Operatoren . . . . . . . . . .
7.4.6 Zuweisungsoperatoren . . . . . . . . .
7.4.7 Weitere Operatoren . . . . . . . . . .
7.5 Zusammenfassung . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
33
33
35
35
36
37
38
39
40
42
45
45
48
48
49
50
51
52
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
8 Typwandlungen
53
8.1 Automatische Typkonvertierungen . . . . . . . . . . . . . . . . . 53
8.2 Manuelle Typkonvertierungen . . . . . . . . . . . . . . . . . . . . 56
8.3 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . 57
9 Anweisungen und Kontrollstrukturen
9.1 Leere Anweisung . . . . . . . . . . . .
9.2 Blockanweisung . . . . . . . . . . . . .
9.3 Variablendefinitionen . . . . . . . . . .
9.4 Ausdrucksanweisungen . . . . . . . . .
9.5 If–Anweisung . . . . . . . . . . . . . .
9.6 Switch–Anweisung . . . . . . . . . . .
9.7 Schleifen . . . . . . . . . . . . . . . . .
2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
58
58
58
59
60
61
62
63
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
63
65
67
70
71
10 Objekte in Java
10.1 Objekte und primitive Datentypen . . . .
10.2 Der Lebenszyklus eines Objektes . . . . .
10.2.1 Die Erzeugung von Objekten . . .
10.3 Die Identität eines Objektes . . . . . . . .
10.4 Die Kommunikation mit Objekten . . . .
10.5 Welche Botschaften versteht ein Objekt ?
10.6 Die Zerstörung von Objekten . . . . . . .
10.7 Zusammenfassung . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
72
72
74
75
77
79
81
82
83
11 Arrays
11.1 Definition von Arrays . . . . . . .
11.2 Verwendung von Arrays . . . . . .
11.3 Array–Literale . . . . . . . . . . .
11.4 Primitive Arrays und Objektarrays
11.5 Referenztypen am Array-Beispiel
11.6 Mehrdimensionale Arrays . . . . .
11.7 Zusammenfassung . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
85
85
86
88
88
89
90
92
12 Klassen in Java
12.1 Instanz- und Klassenbestandteile . . . . .
12.2 Zugriff auf Methoden und Attribute . . .
12.3 Die Bestandteile einer Java–Klasse . . . .
12.4 Attribute . . . . . . . . . . . . . . . . . .
12.5 Definition von Methoden . . . . . . . . . .
12.6 Mehrere Methoden mit gleichem Namen .
12.7 Konstruktoren . . . . . . . . . . . . . . .
12.8 Die Parameterübergabe an eine Methode
12.9 Zusammenfassung . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
93
93
95
96
98
99
103
105
105
106
9.8
9.7.1 Die While–Schleife
9.7.2 Die Do–Schleife . .
9.7.3 Die For–Schleife .
9.7.4 break und continue
Zusammenfassung . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
13 Dokumentieren von Java–Programmen
108
13.1 Wie arbeitet javadoc ? . . . . . . . . . . . . . . . . . . . . . . . . 108
13.2 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . 109
14 Vererbung — Extensionen von
14.1 Ein einführendes Beispiel . .
14.2 Erweitern von Klassen . . . .
14.3 Überschreiben von Methoden
Klassen
110
. . . . . . . . . . . . . . . . . . . . 110
. . . . . . . . . . . . . . . . . . . . 112
. . . . . . . . . . . . . . . . . . . . 113
3
14.4 Die super–Variable . . . . . . . . . .
14.5 Vererbung und Konstruktoren . . . .
14.6 Beispiele . . . . . . . . . . . . . . . .
14.7 Die Object-Klasse . . . . . . . . . .
14.8 Abstrakte Klassen . . . . . . . . . .
14.9 Zuweisung an Variablen und Arrays
14.10Zusammenfassung . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
115
116
117
119
119
121
123
15 Packages
125
15.1 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . 127
16 Exceptions
16.1 Try–catch . . . . . . . . . . . . . . .
16.2 Ausnahmen werfen . . . . . . . . . .
16.3 Exceptions in Methoden . . . . . . .
16.4 Ein paar abschließende Bemerkungen
16.5 Zusammenfassung . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
128
128
130
131
132
133
A Anhang: Unix, Editor und CIP-Pool
A.1 Hinweise zu weiterer Unix-Literatur .
A.2 Editoren . . . . . . . . . . . . . . . . .
A.2.1 Der nedit-Editor . . . . . . . .
A.2.2 Der Emacs-Editor . . . . . . .
A.3 Das Hilfe-System . . . . . . . . . . . .
A.3.1 Der man-Befehl . . . . . . . . .
A.3.2 Der Apropos-Befehl . . . . . .
A.4 Ausgabeumleitung . . . . . . . . . . .
A.5 Trennung von Rechner und Bildschirm
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
134
134
134
134
134
135
135
136
137
139
B Anhang: Verwendung von Java unter Unix
B.1 Java-Compiler und Laufzeitumgebung . . . . . . . . . . . . . . .
B.2 Kompilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
B.3 Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
141
141
141
142
C Probleme
143
C.1 Probleme bei Verwendung von javac . . . . . . . . . . . . . . . . 143
C.2 Probleme bei Verwendung von java . . . . . . . . . . . . . . . . . 144
D Goldene Regeln fürs Programmieren
D.1 Allgemeines . . . . . . . . . . . . .
D.2 Quelldateien . . . . . . . . . . . . . .
D.3 Klassen . . . . . . . . . . . . . . . .
D.4 Methoden . . . . . . . . . . . . . . .
D.5 Variablen, Konstanten und Literale .
4
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
146
146
146
147
147
147
D.6 Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . 149
E Installation von Java und Turtle–Graphik
E.1 Installation von Java . . . . . . . . . . . .
E.2 Der CLASSPATH . . . . . . . . . . . . .
E.3 Installation der Turtle–Graphik . . . . . .
E.4 Erweitern des CLASSPATH . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
150
150
150
151
152
1
Einleitung
In der Veranstaltung Einführung in das Programmieren“ wollen wir Sie dabei
”
unterstützen, das Programmieren in Java1 zu erlernen. Dabei gehen wir davon
aus, daß Ihre bisherige Erfahrung im Programmieren vernachlässigbar sind.
Bitte beachten Sie:
Dieser Begleittext ist im Wintersemester 1999/2000 entstanden und ist auf die
damalige Form dieser Veranstaltung zugeschnitten. Im Sommersemester 2000
wurde der Fokus der Veranstaltung etwas verändert.
Momentan passen nur die ersten 4 Kapitel sowie die Anhänge zur momentanen
Form der Veranstaltung. Es ist nicht sicher, ob wir auch die späteren Kapitel
überarbeiten werden. Unabhängig davon können Sie die ersten 4 Kapitel dennoch mit Gewinn für sich nutzen.
1.1
Lehrbücher zu Java
Es sollte zunächst erwähnt werden, daß Java sehr viele Bestandteile hat. Zum
einen gehört zu Java die Java-Programmiersprache, zum anderen enthält Java
viele Werkzeuge, die es ermöglichen, Fenster und Graphiken auf dem Monitor
anzuzeigen. Es gibt Werkzeuge, mit denen der Rechner zur Tonerzeugung verwendet werden kann oder mit denen man Programme fürs Internet schreiben
kann. Alle Bestandteile von Java zusammen nennt man das JDK: Java Development Kit.
Die meisten Lehrbücher zu Java versuchen, alles über Java erzählen, und das
geht dann zu Lasten der Erklärung der Programmiersprache — meistens ist für
die Grundlagen der Programmierung in diesen Büchern weniger als ein Drittel
vorgesehen.
Nun wollen wir Ihnen in dieser Veranstaltung aber gerade die Grundlagen des
Programmierens vermitteln. Die Entwicklung von Internet-, Fenster- und Graphikanwendungen mag ja sehr interessant sein, aber bevor man derartige Programme schreibt, sollte man doch die Grundlagen der Programmierung beherrschen.
Ein sich uneingeschränkt eignendes Lehrbuch zu Java für Programmieranfänger,
haben wir leider nicht gefunden. Daher haben wir den vorliegenden Text erstellt.
Die folgenden Lehrbücher sind bedingt empfehlenswert:
• Computing Concepts with JAVA Essentials Cay S. Horstmann
John Wiley & Sons, 2000, 89,90,– DM
Computing Concepts with JAVA Essentialsßeichnet sich aus durch eine
anfängerorientierte, didaktisch sehr gute Darstellung des Stoffes, die für
den Studienanfänger durch die englische Sprache - mit Fachidiom der EDV
und Programmiersprachen - gedämpft wird. Das Buch enthält eine Vielzahl an Programmbeispielen und stellt alle Konzepte der Sprache weitgehend umfassend und gut verständlich dar. Rückgriffe auf Rechnerarchitektur und Historie lockern den Stoff auf.
1 http://www.java.sun.com
5
6
Das Buch ist gut geeignet, die Veranstaltung im Selbststudium zu ergänzen.
Auf der Webseite2 des Authors finden Sie weitere Hinweise zum Buch.
• Go To Java 2
Guido Krüger
Addison–Wesley, 1999, ISBN 3–8273–1370–8, 89,90,– DM
Dieses Buch eignet sich sehr gut für Leser mit etwas Programmiererfahrung. Das Buch ist in einer Online–Version frei erhältlich, welche wir auf
unserem Server3 spiegeln.
Falls Sie an einem Rechner außerhalb des Netzes der TU Braunschweig
arbeiten, können Sie das Buch auf den Seiten des Authors4 lesen.
erhalten. Außerdem können Sie anhand der Fragen prüfen, ob Sie das
Kapitel verstanden haben.
• Wir präsentieren viele Beispiele. Bitte vollziehen Sie die Programmierbeispiele und Kommandos am Rechner nach.
• Kommandozeilenbefehle präsentieren, schreiben wir als
> Kommando
Dabei bedeutet das führende Größerzeichen, daß Sie diesen Text auf der
Kommandozeile eingeben sollen. Es soll nicht mit eingetippt werden.
• Java in 21 Tagen
Laura Lemay, Charles L. Perkins
Markt u. Technik, 1999, 89,95,– DM.
Dieses Buch eignet sich gut für Programmieranfänger. Es ist im WWW5
frei verfügbar.
Beim Erlernen des Programmierens in Java wünschen wir Ihnen viel Erfolg !
• The Java Tutorial Mary Campione, Kathy Walrath
Addison Wesley, 1998, 85,- DM
The Java Tutorial“ richtet sich an Personen, die bereits programmieren
”
können. Es beschreibt mit vielen instruktiven Beispielen, wie man in Java
Fenster-, Graphik- oder Internetanwendungen programmiert.
Dabei ist aufgrund der vielen Querverweise im Buch die Html-Version vermutlich besser lesbar als die gedruckte Fassung. Wir spiegeln die Online–
Fassung6 .
Wenn Sie an einem Rechner außerhalb des Netzes der TU Braunschweig
arbeiten, können Sie es auf den Seiten von Sun7 lesen.
1.2
Über diesen Text
Aufgrund der Probleme bei der Suche nach einem Lehrbuch haben wir uns entschlossen, einen Begleittext zur Veranstaltung zu schreiben. Er soll gemeinsam
mit den Hausaufgabe als Leitfaden durch die Veranstaltung dienen — wir werden Ihnen in den Hausaufgaben mitteilen, wann Sie welche Kapitel lesen sollen
oder wann Sie auf Sekundärliteratur zurückgreifen sollen.
Es ist empfehlenswert, den Text parallel zu den Hausaufgaben zu verwenden.
Sie finden in den Hausaufgabenblöcken Hinweise, welche Teile im Begleittext
vor oder während der Bearbeitung gelesen werden sollten.
Zum Lesen des Textes noch folgende Hinweise:
• Jedes Kapitel endet mit einer Reihe von Fragen, die Sie nach dem Lesen
des Kapitels beantworten können sollten. Sie können diese Fragen verwenden, um vor dem Lesen des Kapitels einen Eindruck von seinem Inhalt zu
2 http://www.horstmann.com/
3 http://www.tu-bs.de:82/wir/EIP/gj/cover.html
4 http://www.gkrueger.com
5 http://www.mut.de/leseecke/buecher/java2/inhalt.html
6 http://www.tu-bs.de:82/wir/EIP/tutorial/
7 http://java.sun.com/docs/books/tutorial/
7
8
2
Grundlagen: Wie arbeitet ein Computer ?
Bevor wir auf die Programmierung von Rechnern eingehen, möchten wir sichergehen, daß Sie ein Grundverständnis vom Aufbau und von der Funktionsweise
eines Rechners haben. Was es bedeutet, einen Rechner zu programmieren wollen
wir Ihnen auch beschreiben.
Im weiteren verwenden wir übrigens den deutschen Begriff Rechner“ und den
”
englischen Begriff Computer“ synonym.
”
Wenn Sie bereits eine klare Vorstellung vom Aufbau und der Funktionsweise
eines Computers haben, können Sie diesen Abschnitt überfliegen oder überspringen und Ihr Wissen anhand der Zusammenfassung am Ende des Kapitels
überprüfen.
2.1
Der Aufbau eines Computers
Es bedarf eigentlich keines Kommentars, daß Computer heutzutage in allen
Lebensbereichen eingesetzt werden. Computer berechnen, ob geplante Brücken
stehenbleiben werden, sie steuern Flugzeuge, erledigen Ihre Steuererklärung und
moderne Filme werden meist komplett im Computer nachbearbeitetet.
Es mag vielleicht überraschen — aber es gibt einen Oberbegriff für diese vielfältigen Fähigkeiten von Computern: Datenverarbeitung“. Egal, was ein Com”
puter tut, er verarbeitet immer Daten. Dabei ist ein Computer ziemlich dumm
— ob er Musikdaten verarbeitet, für einen Film künstliche Dinosaurier auferstehen lässt, ob er Ihre Steuereklärung bearbeitet oder Lara Croft aufregende
Abenteuer bestehen läßt, ist ihm ziemlich egal. Er ist nicht dazu in der Lage,
einen Unterschied zwischen all diesen verschiedenen Daten zu bemerken. Für
ihn bestehen Daten nur aus Zahlen. Wir Menschen müssen ihm bis ins kleinste
Detail erklären, wie all diese Zahlen verarbeitet und interpretiert werden sollen.
Ob aus einer Zahlenkolonne dann ein Lied, ein Film oder eine Steuererklärung
wird, wird nur durch die Datenverarbeitungsregeln — durch das Programm
— bestimmt.
Die wesentlichen Bestandteile eines Computers zeigt die folgende Graphik:
Graphik 1 : Aufbau eines Computers
Datenausgabe
Dateneingabe
Benutzer−
schnittstelle
Tastatur
Maus
Drucker
Bildschirm
Zentraleinheit (CPU)
Speicher
ROM
RAM
Arbeitsspeicher
Festplatte
Diskette
Nicht−flüchtiger Speicher:
Die zu verarbeitenden Daten müssen dem Computer irgendwie übergeben wer9
den — jeder Computer benötigt also Dateneingabe-Möglichkeiten. Die wichtigsten Dateneingabegeräte sind die Tastatur und die Maus.
Auch die Regeln, nach denen er diese Daten verarbeiten soll, müssen dem Computer irgendwie genannt werden. Da diese Regeln bzw. Programme nichts anderes als spezielle Daten sind, können sie auf dieselbe Art und Weise in den
Computer eingeben werden wie alle anderen Daten auch.
Da wir Menschen die vom Computer verarbeiteten Daten irgendwie weiter verwenden wollen, besitzen fast alle Computer Möglichkeiten zur Datenausgabe
wie Monitor, Drucker oder Soundkarte.
Die zu verarbeitenden Daten und die Programme muß sich der Computer irgendwo merken. Dies geschieht im Speicher des Computers. Wir unterscheiden
flüchtigen und nicht-flüchtigen Speicher.
Die im flüchtigem Speicher enthaltenen Daten werden bei jedem Ausschalten
des Computers gelöscht. Unter flüchtigem Speicher versteht man vor allem den
RAM — Random Access Memory — genannten Teil des Arbeitsspeichers.
Wenn man den Computer ausschaltet, gehen alle Inhalte des RAM verloren.
Dem RAM kommt eine besondere Bedeutung zu, weil in der Regel alle vom
Computer zu verarbeitenden Daten und Programme vor der Verarbeitung hierher übertragen werden müssen.
Die Datenverarbeitung selber geschieht mit Hilfe der CPU (Central Processing
Unit = Zentraleinheit), welche auch Prozessor genannt wird. Der Prozessor ist
eigentlich immer beschäftigt — sobald der Computer angeschaltet wird, beginnt
er damit, im Arbeitsspeicher enthaltene Programme abzuarbeiten und gönnt
sich dabei (fast) keine Pause, bis man den Computer ausschaltet.
Damit die Programme und Daten nicht bei jedem Anschalten des Computers
neu eingetippt werden müssen, besitzt heutzutage jeder Computer auch nichtflüchtigen Speicher, also Speicher dessen Inhalt beim Ausschalten des Computers
nicht verloren geht. Als wichtigste Vertreter sind hier die Festplatte, Diskettenlaufwerke und CD-Roms zu nennen. Da die Festplatte meist einer der schnellsten
nicht-flüchtigen Speicher eines Rechners ist, werden häufig benötigten Daten
dort gespeichert.
Ein weiterer wichtiger nicht-flüchtigen Speicher ist das ROM (Read-only Memory). Das ROM ist ein nicht-beschreibbarer Teil des Arbeitsspeichers. Sie selbst
können im ROM Ihres Computers also keine Daten ablegen. Trotzdem könnte
kein Computer ohne ROM arbeiten. Der Grund hierfür ist, daß ein Computer
nichts tun kann, das man ihm nicht in allen Einzelheiten erklärt. Er benötigt
sogar ein Programm, das ihm erklärt, wie er zu starten hat. Beim Start muß der
Computer nämlich alle angeschlossenen Geräte erkennen und in Gang setzen,
und wie er das zu tun hat, ist im ROM beschrieben.
Außerdem muß der Computer direkt nach dem Anschalten das Betriebssystem starten, auch OS (Operating System) oder DOS (Disk Operating System)
genannt. Ein Betriebssystem ist ein sehr umfangreiches Programm, welches den
Computer durch Menschen benutzbar macht. Das Betriebssystem ermöglicht
dem Computer, mit seinen Benutzern zu kommunizieren (wichtige Betriebssysteme sind MS DOS, MS Windows, das Mac-OS sowie Unix-Betriebssysteme
wie Linux oder Solaris). Ohne Betriebssystem wüsste der Computer nicht, was
er auf dem Bildschirm anzeigen soll, und man könnte ihn weder per Maus noch
per Tastatur bedienen.
10
Wie wird das Betriebssystem gestartet ? Beim Anschalten weiß der Computer
noch gar nicht, wie er das Betriebssystem von der Festplatte laden und starten
soll. Deshalb hat der Hersteller des Computers die hierfür benötigten Programme im ROM abgelegt. Beim Start befolgt der Computer zunächst das im ROM
gespeicherte Startprogramm und startet dabei das Betriebssystem.
Die Rechner, an denen Sie im CIP-Pool während des Kurses arbeiten werden,
laufen übrigens alle unter einer Variante des Betriebssystems Unix, welche von
der Firma IBM unter dem Namen AIX vertrieben wird. Beim Bearbeiten der
ersten Hausaufgabe werden Sie einige Dinge über Unix lernen.
Drei Bits können die acht Zustände 000,001,010,011,100,101,110,111 darstellen.
Es ist sehr leicht zu sehen, daß n Bits genau 2n verschiedene Zustände annehmen
können. Will man also N verschiedene Zustände beschreiben, benötigt man eine
Anzahl von Bits, die sich durch Aufrunden von log2 N ergibt.
Beispiel: Um jede Zahl von 0 bis 15 darstellen zu können, benötigt man
log2 16 = 4 Bits.
Zur Darstellung der Zahlen 0 . . . 100 sind 7 Bits nötig (log2 101 = 6, 66).
2.2
Organisation des Arbeitsspeichers — Bits und Bytes
Alle Daten und Programme müssen vor ihrer Verarbeitung im RAM abgelegt
werden. Auf der physikalischen Ebene ist das RAM aus unzähligen elektrischen
Kondensatoren und Transistoren aufgebaut. Ein Kondensator kann dabei in
einem von zwei Zuständen sein: entweder trägt er elektrische Ladung oder er
ist entladen. Zustände, in denen Kondensatoren nur teilweise aufgeladen sind,
werden heutzutage nicht berücksichtigt.
Eine Speichereinheit, die nur zwei Zustände annehmen kann, nennen wir Bit,
und die beiden Zustände eines Bits beziffern wir mit 0 und 1. Zum Beispiel könnte dem durch einen ungeladenen bzw. geladenen Kondensator repräsentierten
Bit der Wert 0 bzw. 1 zugeordnet werden.
Da ein Bit nur sehr kleine Informationsmengen speichern kann, werden mehrere
Bits zu größeren Einheiten gruppiert.
Beispiel: Sicher haben auch Sie schon Werbeslogans gehört, in welchen
für 32-Bit-Betriebssysteme oder 32-Bit-Prozessoren geworben wird. Ein
32-Bit-Prozessor ist in der Lage, immer 32 Bit auf einmal aus dem Speicher
zu lesen und als eine Einheit zu verarbeiten.
Ein älterer 16-Bit-Prozessor hingegen verarbeitet Daten immer in 16-BitPortionen. Da ein 16-Bit-Prozessor nur 16 Bit auf einmal verarbeiten kann,
müsste er zweimal auf den Speicher zugreifen, um 32 Bit zu lesen, und er
müsste zwei Operationen ausführen, um 32-Bit zu verarbeiten.
Die Anzahl von Bits, die ein Prozessor auf einmal aus dem Speicher holen
und verarbeiten kann, nennt man übrigens die Bus-Breite des Prozessores (ein Bus ist ein Bündel von Leitungen, über das Daten transportiert
werden).
Wenn die zu verarbeitenden Daten in größeren Gruppen als 16 Bit vorliegen, kann ein 32-Bit-Prozessor also tatsächlich schneller sein als ein
16-Bit-Prozessor. Allerdings müssen die benutzten Programme dazu auch
wirklich eine Verarbeitung in 32-Bit-Portionen vorsehen.
Bevor wir darauf eingehen, zu was für Gruppen man Bits zusammenfaßt, wollen
wir uns überlegen, wie viele Zustände man mit einer vorgegebenen Anzahl von
Bits darstellen kann.
Die wichtigsten Einheit, zu denen Bits zusammengefaßt werden, sind:
Byte:
Ein Byte besteht aus 8 Bit und kann 28 = 256 Zustände annehmen.
Word:
Die Größe eines Word hängt vom verwendeten Computer ab. Es besteht
in der Regel aus sovielen Bits, wie der Computer zugleich verarbeiten
kann. Heutzutage versteht man unter einem Word meist 8 Byte oder
64 Bit.
Meist verwendet man die Begriffe Byte oder Word, um einen einzelnen Zahlenwert zu beschreiben. Jedem Zustand eines Bytes oder Words kann man eine Dezimalzahl zuweisen. Dazu fasst man die Zustände der einzelnen Bits als
Binärzahl auf.
Der Dezimalwert einer Binärzahl berechnet sich wie folgt: Die Bits der Zahl
werden von rechts beginnend und mit der Zahl 0 startend durchnumeriert. Anschließend bildet man eine Summe, in welcher man für jedes an der Position i
gesetzte Bit die Zahl 2i einsetzt.
Beispiel: Zum Beispiel hat die Binärzahl 010 die Dezimaldarstellung
21 = 2.
Die Zahl 010100100 die Dezimaldarstellung 22 + 25 + 27 = 164.
Beispiel: Ein weiteres Beispiel: Computer verwenden meist Byte-Werte,
um Buchstaben und andere Zeichen zu beschreiben. Dabei wird jedem
Zeichen ein anderer Zahlenwert zugewiesen. Auf meinem Rechner sehen
einige Beispiele für diese Zuordnung so aus:
Zeichen
a
b
c
A
#
+
1
Zahlenwert
97
98
99
65
35
43
49
Darstellung in Bits
01100001
01100010
01100011
01000001
00100011
00101011
00110001
Prüfen Sie bitte nach, ob die dezimale Darstellung und die Bit-Darstellung
zusammenpaßt.
Beispiel: Wenn wir ein Bit verwenden, können wir nur die zwei Zustände
0 und 1 darstellen.
Wenn wir zwei Bits verwenden, können wir die vier Zustände 00, 01, 10,
11 darstellen.
Wir haben nun die Grundeinheiten kennengelernt, mit denen ein Computer
operiert. Diese Einheiten werden Ihnen auch bei der Programmierung mit Java
immer wieder begegnen, denn auch wenn Sie in Java mit Zahlen rechnen, müssen
11
12
Sie manchmal angeben, in welcher Grundeinheit die Zahlen gespeichert werden
sollen.
Will man beschreiben, wieviele Daten ein Computer speichern kann, benützt
man noch größere Einheiten:
KB, Kilo–Byte: 1 KB (Ein Kilo–Byte) sind 210 = 1024 Byte.
MB, Mega–Byte: 1 MB (Ein Mega–Byte) sind 210 Kilo–Byte oder 220 = 1.048.576
Byte.
GB, Giga–Byte: 1 GB (Ein Giga–Byte) sind 210 Mega–Byte oder 230 = 1.063.641.824
Byte.
TB, Tera–Byte: 1 TB (Ein Tera–Byte) sind 2
10
40
Giga–Byte bzw. 2
Byte.
Beispiel: Neue Rechner für den Heimgebrauch oder fürs Büro haben
heutzutage in der Regel 128 MB Arbeitsspeicher oder mehr und einige
GB Festplattenspeicher; Höchstleistungsrechner haben mehrere GB Arbeitsspeicher und mehrere hundert GB Festplattenspeicher.
2.3
Die Organisation des Arbeitsspeichers — Adressen
Sie haben erfahren, daß der Arbeitsspeicher eines Rechners aus vielen Bits besteht, die zu Bytes oder größeren Gruppierungen zusammengefaßt werden. Obwohl Sie dies zur Programmierung mit Java nicht unbedingt wissen müssen,
möchten wir Ihnen dennoch ganz kurz erzählen, wie der Prozessor Daten im
Arbeitsspeicher verwendet.
Jedes Byte des Arbeitsspeichers hat eine eindeutige Nummer — die Nummer
eines Bytes nennt man seine Adresse. Der Prozessor kann über die Adresse
Daten im Arbeitsspeicher auslesen und Daten in den Arbeitsspeicher schreiben.
Beispiel: Wir können dem Prozessor befehlen, eine Zahl in dem Byte
an der Adresse 100 und eine weitere Zahl in dem an der Adresse 200 beginnenden Word zu speichern. Anschließend können wir ihn anweisen, die
beiden Zahlen zu addieren und das Ergebnis an der Adresse 300 abzulegen. Da hierbei ein Byte und ein Word addiert wird, sollte das Ergebnis
mindestens Word-Größe haben.
2.4
Beispiel: Die Regeln, nach welchen die Dezimaldarstellung einer
Binärzahl mit den Bits bn , . . . , b0 berechnet werden, könnte umgangssprachlich so beschrieben werden wie im vorigen Kapitel (Seite 2.2):
Der Dezimalwert einer Binärzahl berechnet sich wie folgt: Die
Bits der Zahl werden von rechts beginnend und mit der Zahl 0
startend durchnumeriert. Anschließend bildet man eine Summe, in welcher man für jedes an der Position i gesetzte Bit die
Zahl 2i einsetzt.
Allerdings kann diese Beschreibung mißverstanden werden. Sie ist auch
kein Algorithmus, da sie nicht eindeutig ist. Es ist zum Beispiel nicht
festgelegt, in welcher Reihenfolge die Summe gebildet werden soll.
Ein Computer benötigt immer eine Vorgehensvorschrift, in der jedes Detail genau beschrieben wird. Vor allem darf die Regel nicht den geringsten
Entscheidungsspielraum lassen und muß eindeutig sein. Eine Umsetzung
der obigen umgangssprachlichen Regel in einen Algorithmus könnte so
aussehen:
• Gegeben sei eine Binärzahl mit den Bits bn , . . . , b0 .
• Setze dezimal := 0
• Lasse i jeden Wert zwischen 0 und n aufsteigend durchlaufen und
Setze für jeden Wert von i
dezimal := dezimal + bi · 2i
• dezimal enthält nun die Dezimaldarstellung der Binärzahl bn , . . . , b0
Da die zweite Umrechenregel des obigen Beispiels eindeutig ist, könnte man
sie nun in ein Programm für einen Computer umsetzen. Ein Programm ist
die Formulierung eines Algorithmus in einer Programmiersprache. Wie schon
erwähnt, ist ein Computer ziemlich dumm — er versteht nur eine ganz spezielle,
für Menschen ungeeignete Sprache, die Maschinensprache. Maschinensprache
ist eine Sprache, die nur aus Zahlen besteht.
Beispiel: Um Sie von Maschinensprache abzuschrecken, zeigen wir Ihnen
ein Maschinensprache-Programm. Dabei zeigen wir Ihnen nicht die Zahlen, aus denen das Programm besteht sondern eine textliche Darstellung,
in der jeder Zahl ein kurzes Wort wie movl oder imull zugeordnet wurde:
Programmierung eines Computers
Nachdem Sie nun eine gewisse Vorstellung davon haben, wie ein Computer aufgebaut ist, folgt nun die Erklärung, wie ein Computer Programme verarbeitet.
Es ist hoffentlich bereits klar geworden sein, daß Programme nichts anderes
sind als Regeln, die einem Computer bis ins allerkleinste Detail erklären, wie
er gewisse Daten verarbeiten soll. Es stellt sich nun die Frage, wie man dem
Computer derartige Regeln mitteilen soll. Vorher stellt sich aber die Frage, was
für Regeln man einem Computer mitteilen kann.
Hier sollten Sie sich merken, daß die Regeln, die man einem Computer angibt,
immer eindeutig sein müssen. Regeln, die exakt und eindeutig sagen, was zu
tun ist, nennt man einen Algorithmus. Ein Computer kann nur Algorithmen
verarbeiten.
13
movl
movl
movl
imull
30,12345(%ebp)
50,23456(%ebp)
3456(%ebp),%eax
0xfffffff8(%ebp),%eax
Dieses Programm multipliziert die Zahlen 30 und 50.
Dazu legt es in der ersten Zeile mit dem Befehl movl die Zahl 30 an der
Adresse 12345 ab. Dann legt es in der zweiten Zeile die Zahl 50 an der
Adresse Zahl 23456 ab. In der dritten Zeile merkt es sich, daß das Ergebnis
der Rechnung an der Adresse 3456 gespeichert werden soll. Schließlich
multipliziert es in der vierten Zeile durch den imull-Befehl die Zahlen
und legt das Ergebnis an Adresse 3456 ab.
14
Sie sehen an diesem Beispiel, daß in Maschinensprache die einfachsten Dinge
recht umfangreich werden. Außerdem hat Maschinensprache einen Riesennachteil — jeder Prozessor hat eine andere Maschinensprache, und einen PC mit
Intel-Prozessor in Maschinensprache zu programmieren, ist etwas ganz anders,
als einen Macintosh-Rechner zu programmieren. Wenn Sie Maschinensprache
verwenden wollten, müssten Sie für jeden Rechnertyp, auf dem Ihr Programm
laufen soll, ein völlig anderes Programm erstellen.
Daher wird heutzutage eigentlich nur noch in höheren Programmiersprachen
wie Pascal, C, Pascal, C++ oder Java programmiert — höhere Programmiersprachen heißen so, weil Sie einen höheren“ Abstraktionsgrad vom Prozessor
”
haben als Maschinensprache. Nur ein paar wenige Freaks, Hacker und Spieleprogrammier programmieren heutzutage noch in Maschinensprache.
Die höheren Programmiersprachen bieten den großen Vorteil, daß man sich nicht
selbst darum kümmern muß, an welcher Adresse der Computer Daten ablegen
soll, außerdem entspricht ein einzelner Befehl in einer höheren Programmiersprachen einer ganzen Reihe von Befehlen in Maschinensprache. Die höheren
Programmiersprachen kommen dabei umgangssprachlichen Formulierungen sehr
nahe:
1. Es muß analysiert werden, was die Problemstellung genau beinhaltet und
welche Ziele mit der Programmentwicklung verfolgt werden sollen (Analysephase).
2. Es muß geplant werden, wie die Problemstellung in ein Programm umgesetzt werden soll. Insbesondere müssen die Regeln, nach denen das Programm arbeiten soll, umgangssprachlich formuliert werden. Berechnungsvorschriften müssen hierbei als Algorithmus formuliert werden (Design–
Phase).
3. Dann muß das Programm in einer Programmiersprache programmiert werden, man sagt auch: implementiert werden“ (Programmier–Phase).
”
4. Dann muß das Programm kompiliert werden und kann kann anschließend
getestet oder verwendet werden.
Graphik 2 : Entwicklung eines Programms
Programmvorhaben in umgangssprachlicher Fassung
Analyse und Entwurf
Beispiel: Zum Beispiel könnten die Regeln zur Umwandlung einer Binärin eine Dezimalzahl in Java so lauten:
Eindeutige umgangssprachliche Formulierung (Algorithmus)
Programmieren
/* die Bits der Binärzahl seien in b[0], b[1] ... bis in b[n]
* gespeichert
*/
dezimal = 0;
for( i = 0; i < n ; i++ ) {
dezimal = dezimal + b[i] * 2^i;
}
return dezimal;
Sie sehen, daß diese Regeln fast unserem umgangssprachlichen Algorithmus entsprechen. In Maschinensprache sähe das sehr viel komplizierter
aus.
Nun hatten wir vorhin doch erwähnt, daß ein Computer nur Maschinensprache versteht — wie kann er dann Programme höherer Programmiersprachen
verstehen ? Eigentlich ist die Antwort offensichtlich — immer wenn ein Computer etwas tun soll, benötigt er eine Vorgehensvorschrift. Damit ein Computer
Programme höherer Programmiersprachen verstehen kann, muß ihm ein Programm geben, das für ihn als Übersetzer arbeitet und den Programmtext in
Maschinensprache übersetzt.
Ein solches Programm nennt sich Compiler. Für jede Programmiersprache gibt
es für jeden Rechnertyp einen speziellen Compiler, der gültige Texte der Programmiersprache zu Maschinencode des jeweiligen Rechners kompiliert (kompilieren == übersetzen). Der Compiler dient dem Computer quasi als Dolmetscher für die von uns Menschen erstellten Textdateien.
Um ein Programm zu entwickeln und ablaufen zu lassen, sind also die folgenden
Schritte nötig:
15
Formulierung in höherer Programmiersprache
Kompilieren
Maschinensprache
2.5
Zusammenfassung des Kapitels
Sie sollten nun die folgenden Fragen beantworten können:
B Wie unterscheidet ein Computer Musik-, Graphik- und andere Daten ?
B Was sind Dateneingabe, Zentraleinheit, Speicher, Datenausgabe ?
B Was sind RAM und ROM ?
B Was ist ein Betriebssystem ?
B Wie ist das RAM aufgebaut ?
B Was sind Bits, Bytes, Words, Kilobytes, Megabytes ?
B Warum sind Binärzahlen für Computer wichtig ?
B Was zeichnet einen Algorithmus aus ?
B Was ist der Unterschied zwischen einem Algorithmus und einem Programm ?
B Warum programmiert man Computer meistens nicht in Maschinensprache ?
B Welche Beziehung besteht zwischen Maschinensprache, höherer Programmiersprache und Compiler ?
16
3
Das Java–Programmiersystem JDK
Im vorigen Kapitel haben Sie erfahren, daß ein Computer nicht in der Lage ist,
von Menschen lesbare Programme direkt zu verstehen. Der Computer benötigt
einen Dolmetscher, der das für Menschen verständliche Programm in seine Sprache übersetzt.
Zum Java–Programmiersystem gehören sogar zwei solche Dolmetscher — der
Java–Compiler und die sogenannte Java–Virtual–Machine. Bevor wir auf die
Programmierung von Java eingehen, müssen wir Sie mit dem Java–Programmiersystem und speziell mit diesen beiden Dolmetschern vertraut machen.
3.1
3.2
Übersetzen und Ausführen von Java-Programmen
Ein Java–Programm besteht aus einem oder mehreren Programmbausteinen,
welche Klassen genannt werden. Jede Klasse ist in der Regel in einer eigenen
Textdatei beschrieben und wird mit einem Text-Editor erstellt.
Bevor Sie weiterlesen, sollten Sie daher mit einem Text-Editor umgehen können.
Sie sollten auch mit der Kommandozeile von Unix umgehen können; Hinweise
hierzu finden Sie im Anhang A und in der ersten Hausaufgabe. Wenn Sie unter anderen Betriebssystemen als Unix arbeiten wollen, beschaffen Sie sich die
entsprechenden Informationen bitte selbst.
Beispiel: In dem untenstehenden Kasten sehen Sie ein sehr einfaches
Bestandteile des JDK
8
Schon in der Einleitung wurde erwähnt, daß Java nicht nur aus einer Programmiersprache besteht. Alles, was man zur Java-Programmierung benötigt,
wurde von den Schöpfern von Java, der Firma Sun9 , in einem Paket zusammengeschnürt, das sich JDK: Java Development Kit nennt.
Das JDK enthält folgende Dinge:
• Eine umfangreiche Sammlung von Programmbausteinen. Im JDK sind
bereits sehr viele Programmbausteine, sogenannte Klassen, enthalten.
Wenn man diese Bausteine in eigene Programme einbaut, kann man mit
Java relativ einfach Internet-, Graphik- oder Fenster-Anwendungen erzeugen.
Wir werden Ihnen in dieser Veranstaltung nur ganz wenige dieser Programmbausteine vorstellen, da wir zum Programmieren lernen lieber selbst
einfache Programme bauen wollen als komplizierte Programme aus diesen
Programmbausteinen zu erstellen.
• Umfangreiche Dokumentation: Für all diese fertigen Programmbausteine
(Klassen) und alle anderen Werkzeuge von Java liegt umfangreiche Dokumentation von HTML–Dateien vor, welche mit einem WWW–Browser
betrachtet werden kann.
Um die von Java bereitgestellten Programmbausteine zu verwenden, muß
man viel mit dieser Dokumentation arbeiten. Daher werden wir im Rahmen dieser Veranstaltung ein paar Aufgaben stellen, bei denen Sie sich in
der Dokumentation zurechtfinden müssen.
• Einige Werkzeuge, zum Beispiel ein Werkzeug, das Ihre Programme liest
und die enthaltene Dokumentation in HTML-Dokumenten zusammenfasst. Dieses Werkzeug werden Sie hier auch kennenlernen.
• Java–Compiler und Java–Virtual–Machine. Diese Programme sind die Dolmetscher zwischen Ihnen und dem Computer.
8 http://www.java.sun.com
9 http://www.sun.com
17
Java–Programm. Wenn man es startet, gibt es den Text Hallo, Welt“
”
aus.
Bitte tippen Sie das Programm in Ihrem Text–Editor ab und speichern
es in einer Datei namens Hallo.java. Beachten Sie hierbei bitte, daß die
Zeilennummern nicht zum Programm gehören — wenn wir Beispielprogramme abdrucken, numerieren wir die Zeilen durch, um auf die einzelnen
Programmteile eingehen zu können.
Außerdem achten Sie beim Abtippen bitte auf die Groß- und Kleinschreibung. Für Java besteht zwischen großgeschriebenen und kleingeschriebenen Buchstaben überhaupt keine Verbindung — so ist das Wort class
für Java etwas völlig anderes als das Wort Class.
Beispiel: Einfache Java–Klasse
1
2
3
4
5
6
7
class Hallo
{
public static void main(String[] args)
{
System.out.println("Hallo, Welt");
}
}
Da in diesem Kapitel nur der Java–Compiler behandelt werden soll, wollen
wir hier auf die Funktionsweise von Java–Programmen noch nicht eingehen. Sie brauchen noch überhaupt nicht zu verstehen, was die ganzen
kryptischen Symbole in dem Programm bedeuten; im nächsten Kapitel
wird das alles viel klarer werden.
Sie sollten nun eine Textdatei namens Hallo.java mit dem Text des vorigen
Beispiels in ihrem Arbeitsverzeichnis besitzen. Als nächstes soll aus dieser Textdatei ein vom Computer ausführbares Programm erzeugt werden.
Dazu verwendet man den Java-Compiler. In Kapitel 2.4 wurde ja bereits
erläutert, daß ein Compiler ein für Menschen verständliches Programm in ein
für Computer verständliches Programm umwandelt.
Bevor Sie den Compiler verwenden können, muß auf Ihrem Computer die JavaProgrammierumgebung installiert und laufbereit sein. Falls Sie im CIP-Pool
der TU Braunschweig arbeiten, dann ist das kein Problem — hier ist alles schon
fertig installiert. Wenn Sie jedoch zuhause arbeiten möchten, müssen Sie selbst
dafür sorgen, daß die Java–Umgebung funktioniert. Dabei helfen Ihnen vielleicht
unsere im WWW verfügbaren Tips weiter (siehe auch WWW-Seite ? ). Wir
18
gehen im weiteren davon aus, daß Sie eine funktionsfähige Java-Programmierumgebung haben.
Aber nun zum Java–Compiler — dieser ist ein Programm namens javac. Um
durch ihn, die zuvor von Ihnen erstellte Datei Hallo.java übersetzen zu lassen,
wechseln Sie bitte auf einer Kommandozeile in das Verzeichnis, in welchem Sie
die Datei abgespeichert haben. Dort geben Sie dann bitte ein:
> javac Hallo.java
Der Compiler prüft darauf zunächst, ob die Textdatei Hallo.java ein gültiges
Java–Programm enthält. Java–Programme müssen einen ganz bestimmten Aufbau haben, damit sie vom Compiler übersetzt werden können. Nur wenn die
Datei tatsächlich ein gültiges Programm enthält, übersetzt der Compiler sie in
eine dem Computer verständliche Form und dient so als Dolmetscher zwischen
uns und dem Computer. Wenn Sie die Klasse korrekt abgetippt haben, sollte
das Kompilier–Kommando zu keiner Bildschirmausgabe führen.
Der Compiler ist auch kleinsten Tippfehlern gegenüber sehr ungnädig — selbst
wenn Sie beim Abtippen des Programms nur kleine Fehler gemacht haben, kann
es ihnen passieren, daß der Compiler ihr Programm mit einer Fehlermeldung
ablehnt. Falls Ihnen das beim Compiler–Aufruf passiert ist, prüfen Sie bitte, ob
Sie das Beispielprogramm exakt abgetippt haben, korrigieren es, speichern die
Änderungen (!) und probieren dann erneut den Aufruf des Compilers. Wenn das
nicht hilft, lesen Sie bitte unsere Hinweise zu Fehlermeldungen in Anhang C.
Wenn Sie auch damit nicht weiterkommen, holen Sie sich bitte einen Hiwi zur
Hilfe.
Wir gehen im folgenden davon aus, daß der Aufruf des Compilers funktioniert
hat. In diesem Fall hat der Compiler Ihr Programm übersetzt und die übersetzte
Fassung in einer neuen Datei namens Hallo.class gespeichert. Schauen Sie
bitte nach, ob diese Datei tatsächlich erzeugt wurde10 .
Die neu erzeugte Datei Hallo.class enthält die für einen Computer verständliche Version unserer Klasse. Wenn Sie diese Datei mit dem cat-Kommando auf
den Bildschirm ausgeben, erhalten Sie eine ganz wilde Ausgabe — außerdem
müssen Sie danach möglicherweise eine neue Kommandozeile öffnen, weil Ihre
alte Kommandozeile nur noch komische Zeichen anzeigt. Wir Menschen können
mit dem Inhalt der erzeugten Datei Hallo.class also nicht viel anfangen.
Wir haben Ihnen bisher aber nur die halbe Wahrheit erzählt — es ist zwar
tatsächlich so, daß der Java–Compiler die Textdatei Hallo.java in eine Maschinnensprache–Datei Hallo.class umgewandelt hat. Es kann jedoch kein tatsächlich
existierender Computer die vom Java–Compiler benutzte Maschinensprache direkt verstehen. Der Java–Compiler übersetzt nämlich jedes Programm in eine
künstliche Maschinensprache, den Java–Bytecode.
Java–Bytecode ist eine Art Computer–Esperanto. Kein Computer versteht es
direkt, doch es ähnelt den meisten Computermaschinensprachen. Soll ein Computer das in einer Java–Bytecode–Datei enthaltene Programm abarbeiten, so
benötigt er einen weiteren Dolmetscher, der den Java–Bytecode für ihn übersetzt. Dieser zweite Dolmetscher nennt sich Bytecode-Interpreter11 .
10 Wenn
11 Das
Sie nicht wissen, wie das geht, haben Sie vermutlich Anhang A noch nicht gelesen
englische Wort Interpreter“ heißt auf deutsch Dolmetscher“
”
”
19
Man tut im übrigen so, als wäre Bytecode tatsächlich eine Maschinensprache
und stellt sich gerne vor, daß irgendwo ein Computer existieren könnte, der den
Bytecode direkt versteht. Da dieser Computer aber nur durch den BytecodeDolmetscher existiert, nennt man den Bytecode-Dolmetscher auch Java Virtual Machine (JVM) (virtueller Java-Computer).
Natürlich können Java-Programme damit nicht so schnell sein wie Programme anderer Programmiersprachen, welche für den jeweilige Computer direkt
verständlichen Programmcode erzeugen. Der Prozessor Ihres Computes führt ja
kompilierte Java–Programme niemals direkt aus sondern benutzt immer seinen
Bytecode–Dolmetscher.
Der Umweg über den Java–Bytecode ist aber auch ein sehr großer Vorteil und
hat den Einsatz von Java im Internet erst ermöglicht — hierdurch werden
Java-Programme nämlich systemunabhängig. In der Theorie läuft jedes JavaProgramm auf jeder Hardware und auf jedem Betriebssystem, für das eine virtuelle Java–Maschine existiert. Man muß sich also nicht mehr entscheiden, ob
man ein Programm für Windows, Macintosh, Unix oder sonst ein Betriebssystem kompiliert. Wenn die virtuelle Java-Maschine auf diesem Betriebssystem
vorhanden ist, läuft hierauf jedes kompilierte Java–Programm.
Das Programm, welches die virtuelle Maschine simuliert, heißt java. Um die
kompilerte Datei Hallo.class auszuführen, geben Sie bitte auf der Kommandozeile das Kommando
> java Hallo
ein. Daraufhin führt der Bytecode-Interpreter den in Hallo.class enthaltenen
Bytecode aus. Es sollte folgende Meldung am Bildschirm erscheinen:
Gratuliere, Ihr erstes Java--Programm funktioniert.
Ein Hinweis noch: Beachten Sie, daß die Endung .class“ beim Aufruf des
”
Bytecode-Interpreters nicht mit angegeben werden darf. Hingegen muß beim
Aufruf des Compilers javac immer die Endung .java“ mit angegeben werden.
”
3.3
Zusammenfassung
B Was ist das JDK ?
B Warum benötigt man einen Compiler ?
B Sie sollten den Java-Compiler aufrufen können.
B Was erzeugt der Java-Compiler ?
B Was ist ein Bytecode-Interpreter, und warum wird er benötigt ?
B Wie unterscheiden sich Java-Compiler und Bytecode-Interpreter
bezüglich der Endung von Dateinamen ?
B Überlegen Sie sich, wieso der Bytecode Java so gut für die Verwendung
im Internet geeignet macht — berücksichtigen Sie hierbei, daß für
Menschen verständlicher Programmtext meist als Geschäftsgeheimnis
angesehen wird.
20
4
Erste Schritte — die Turtlegraphik
Dieses Kapitel soll Sie anhand von einfachen Programmen mit einigen zentralen
Begriffen von Java vertraut machen, insbesondere dem Objekt– und Klassenbegriff.
4.1
Testen der Turtlegraphik
Bei der Einführung dieser Begriffe werden wir uns auf eine von uns erstellte
Java–Erweiterung beziehen, auf eine sogenannte Turtlegraphik. Die Idee der
Turtlegraphik stammt übrigens aus der Programmiersprache Logo — da die
Turtlegraphik mit sehr einfachen Mitteln die Erstellung ansprechender Graphiken ermöglicht und die graphische Ausgabe die Arbeitsweise eines Programms
verdeutlicht, wird sie ein wichtiger Bestandteil dieser Veranstaltung sein.
Der Turtlegraphik liegt die Vorstellung zugrunde, auf dem Bildschirm krabbele
ein kleines Tierchen herum, z.B. eine Schildkröte (engl. Turtle). Diesem Tierchen
kann man befehlen, eine gewisse Anzahl von Schritten vorwärts oder rückwärts
entlang seiner Blickrichtung zu gehen. Man kann ihm auch befehlen, sich nach
rechts oder links zu drehen und so seine Blickrichtung zu ändern. Die Turtle trägt
mit sich viele verschiedenfarbige Stifte herum, und man kann es dazu auffordern,
einen Stift auszuwählen und ihn abzusetzen oder anzuheben. Wenn sich die
Turtle bei abgesetztem Stift bewegt, zeichnet sie eine Linie in der Stiftfarbe.
In den CIP–Pools der TU ist die Turtlegraphik bereits installiert. Dennoch
müssen Sie gewisse Vorbereitungen treffen, um die Turtle zu verwenden (siehe erste Hausaufgabe). Wenn Sie die Hausaufgaben und den Begleittext jedoch
zuhause bearbeiten wollen, müssen Sie sie sich dort erst noch installieren. Eine
Installationsanleitung finden Sie im Anhang E.
Testen Sie bitte zuerst, ob die Turtlegraphik bei Ihnen korrekt installiert ist,
indem Sie auf der Kommandozeile
> java eip.TurtleDemo
eingeben. Falls das nicht funktioniert, schauen Sie bitte in den soeben genannten
Anhang.
Auf dem Bildschirm sollte sich ein zweigeteiltes Fenster öffnen. Im oberen Bereich des Fensters sehen Sie eine Schrift sowie ein dreieckiges Symbol, und im unteren, dunkleren Bereich sehen Sie Knöpfe, welche mit Step“, Run Slow“, Stop“
”
”
”
und Quit“ betitelt sind.
”
Drücken Sie nun einige Male auf den Step“–Knopf. Sie werden feststellen, daß
”
sich das dreieckige Symbol bei jedem Druck bewegt und dabei Striche malt, welche eine Art Baum ergeben. Das dreieckige Symbol werden wir im weiteren eine
Turtle“ nennen — Sie können sich das so vorstellen, daß auf dem Bildschirm
”
eine kleine Schildkröte herumkrabbelt und dabei Striche zieht.
Nach einigen Schritten wird das Drücken des Knopfes mühselig — drücken Sie
dann den Run Slow“ Knopf. Die Turtle läuft nun selbstständig über den Bild”
schirm, ohne auf weitere Knopfdrücke zu warten. Durch einen Druck auf den
Stop“–Knopf können Sie sie jederzeit anhalten.
”
Probieren Sie das und drücken Sie dann den Run“–Knopf. Nun läuft die Turtle
”
so schnell, daß sie gar nicht mehr zu sehen ist. Auch hier können Sie jederzeit
21
den Stop“–Knopf drücken. Wenn Sie das Programm verlassen wollen, können
”
Sie jederzeit den Quit“–Knopf verwenden.
”
4.2
Die Bestandteile eines einfachen Java–Programms
Bitte tippen Sie das folgende Beispiel ab und speichern es in einer Datei namens
Kreuz.java:
Kreuz.javaa
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapFirst/Kreuz.java
Anschließend kompilieren Sie es bitte durch
> javac Kreuz.java
und starten es dann mit dem Befehl
> java Kreuz
Sie sehen nun das Fenster, welches Sie bereits kennen, und wenn Sie die Turtle wie in Abschnitt 4.1 beschrieben laufen lassen, sollte ein Kreuz gezeichnet
werden.
Lassen Sie uns die einzelnen Bestandteile dieses Programms Zeile für Zeile untersuchen — Sie werden sicher nicht alle Erläuterungen verstehen. Lesen Sie bitte
die Ausführungen dennoch, um einen ersten Eindruck der Programmierung in
Java zu erhalten.
In Zeile 1–3 steht ein durch die Zeichen /*“ und */“ eingeschlossener Text.
”
”
Dies ist ein Kommentar. Der Java–Compiler ignoriert jeden so
umschlossenen Text, auch wenn er aus mehreren Zeilen besteht.
Kommentare dienen dazu, Programme lesbarer zu machen — man
kann in Kommentare Texte schreiben, welche beim Verständnis
der nebenstehenden Programmbefehle helfen.
Zeile 4
ist leer. Leerzeilen dienen der besseren Lesbarkeit des Programmes
für Menschen. Für Java haben Leerzeilen gar keine Bedeutung.
In Zeile 5–6 wird Java angewiesen, die Programmbausteine eip.TurtleScreen
und eip.Turtle zu importieren.
Jedes Java–Programm setzt sich aus kleineren Bausteinen zusammen, sogenannten Klassen. Einige Klassen sind in Java fest eingebaut und müssen Java nicht erst bekannt gemacht werden.
Die Klassen TurtleScreen und Turtle sind von uns erstellt worden und sind Java normalerweise nicht bekannt. Will man sie verwenden, muß man Java daher zuerst mitteilen, wo sie auf der
Festplatte zu finden sind.
Dies geschieht durch Angabe eines Verzeichnispfades, gefolgt vom
Namen des Programmbausteins. Wenn wir hier den Befehl
import eip.TurtleScreen
22
In Zeile 8
In Zeile 10
verwenden, so sagen wir Java damit: Wir möchten gerne die
”
Klasse TurtleScreen verwenden, die im Pfad eip zu finden ist.“
Java sucht darauf in gewissen Verzeichnissen12 nach einer Datei
TurtleScreen.class und macht den enthaltenen Programmbaustein für uns nutzbar.
sehen Sie den Text class Kreuz {.
So teilen wir dem Java–Compiler mit, daß wir nun selbst einen
Programmbaustein, nämlich die Klasse Kreuz, definieren. Java
verlangt, daß der Name einer Programmdatei gleich dem Namen der enthaltenen Klasse, ergänzt um das Anhängsel .java
ist. Die Klasse Kreuz muss also zwingend in einer Datei namens
Kreuz.java enthalten sein.
Eine Klasse (ein Programmbaustein) besteht aus vielen Java–
Befehlen. Immer, wenn in Java mehrere Anweisungen zu größeren
Einheiten gruppiert werden müssen, benutzt man dazu geschweifte Klammern.
Die geschweifte Klammer in Zeile 8 wird von der geschweiften
Klammer } in Zeile 22 geschlossen. So wird der Text der Zeilen
9–21 zusammengefasst. Java interpretiert so allen Text innerhalb
dieses Klammerpaares als Bestandteil der Klasse Kreuz.
Geschweifte Klammerpaare samt Inhalt nennt man Block. Blöcke
enthalten oft andere Blöcke. In unserem Beispiel enthält dieser die
Klasse definierende Block noch einen anderen Block, der sich über
die Zeilen 10–21 erstreckt.
sehen Sie den Beginn des Hauptprogramms der Kreuz–Klasse.
Jede Klasse besteht aus vielen kleineren Programmstücken. Dabei übernimmt jedes der kleineren Programmstücke eine spezielle
Aufgabe innerhalb der Klasse. Diese kleineren Programmstücke
heissen in Java übrigens Methoden.
Will man etwa ein Programm schreiben, welches zwei Kreuze
zeichnet, so würde man zuerst ein Programmstück (eine Methode) schreiben, welches ein Kreuz zeichnet und dann eine weitere
Methode, welche die erste Methode zweimal verwendet. Die Aufteilung eines Programms in viele kleine Stücke ist eine sehr gute
Sache, da sie Programme überschaubarer und leichter zu erweitern
macht.
Es stellt sich die Frage, welche Methode ablaufen soll, wenn man
ein Programm von der Kommandozeile startet (etwa durch den
Befehl java Kreuz“). In Java ist das so gelöst, daß immer die
”
sogenannte main–Methode gestartet wird, welche durch den Text
10 beginnt und in Zeile 21 geschlossen wird. Die main–Methode
besteht daher aus allen Anweisungen in den Zeilen 11 bis 20.
Zeile 11
Zeile 11 ist die erste Zeile des Hauptprogramms der Kreuz–Klasse.
Wenn Sie die Kreuz–Klasse von der Kommandozeile starten, beginnt hier die Ausführung des Programms.
In Zeile 11 wird auf der rechten Seite des Gleichheitszeichens
durch den Text new TurtleScreen() ein neuer TurtleScreen erzeugt. Ein TurtleScreen ist ein Fenster, in welchem die Turtle
umherläuft. Der Befehl new TurtleScreen() öffnet hier ein neues Fenster auf dem Bildschirm Ihres Computers.
Vorher, in Zeile 5, hatten wir Java mitgeteilt, wo es den Programmbaustein TurtleScreen finden kann. Hätten wir das nicht
getan, wüsste Java mit Zeile 11 nichts anzufangen.
Damit wir mit Java über den neu angelegten TurtleScreen reden
können, müssen wir ihm einen Namen geben. Dies geschieht auf
der linken Seite des Gleichheitszeichens, wo wir eine Variable namens ts erzeugen.
Zeile 11 ist somit die programmtechnische Formulierung des Befehls Öffne ein neues TurtleScreen–Fenster und benenne es mit
”
ts“.
Zeile 12
Zeile 12 ähnelt Zeile 11. Durch den Befehl new Turtle(ts) wird
eine neue Turtle angelegt, welche auf den in Zeile 11 angelegten
TurtleScreen gesetzt wird. Diese wird daraufhin als dreieckiges
Symbol auf dem Bildschirmfenster angezeigt.
Die neue Turtle erhält dabei den Namen t.
In Zeile 14–19 werden der in Zeile 12 erzeugten Turtle Botschaften geschickt.
In Zeile 14 steht beispielsweise der Programmbefehl
t.pd();
So schicken wir der Turtle namens t die Botschaft pd()“ (pd
”
steht für pendown“). Die Turtle senkt daraufhin ihren Stift.
”
Jede Botschaft an die Turtle t bewirkt die Ausführung zur Botschaft passenden Programmcodes, welcher innerhalb der Turtle–
Klasse definiert ist. Auf den Befehl pd() hin merkt sich die Turtle,
daß sie ab sofort beim umherlaufen Linien ziehen soll.
Ähnlich sind die Anweisungen t.fd(100);“ bzw. t.rt(120);“
”
”
Botschaften an die Turtle t, 100 Einheiten nach vorne zu laufen,
bzw. sich um 120 Grad nach rechts zu drehen ( fd“ steht für
”
forward“ und rt“ steht für rightturn“).
”
”
”
public static void main(String[] args)
12 In welchen Verzeichnissen gesucht wird, müssen Sie hier nicht wissen — falls es Sie
interessiert, können Sie es im Anhang ?? nachlesen.
Nachdem wir nun jede Zeile des Beispielprogramms besprochen haben, sollten
Sie selbständig kleine Änderungen vornehmen — was passiert, wenn Sie die Befehle t.fd(100) durch t.fd(200) ersetzen ? Was passiert, wenn Sie die Befehle
t.rt(120) durch t.rt(90) ersetzen ? Können Sie die Turtle dazu bringen, ein
Rechteck zu zeichnen ? (natürlich müssen Sie nach jeder Änderung der Datei die
Änderungen speichern, den Compiler aufrufen und dann das Programm erneut
starten).
23
24
gekennzeichnet ist.
Eine Methode besteht aus einer Reihe von Anweisungen, welche
durch geschweifte Klammern zusammengefasst werden. Im vorliegenden Beispiel erkennen Sie ein Klammerpaar, welches in Zeile
Ein Hinweis noch: Ihnen sollte aufgefallen sein, daß die meisten Zeilen des Beispielprogrammes mit einem Semikolon enden. In Java müssen die meisten Befehle durch Semikoli abgeschlossen werden. Beachten Sie dies beim Ändern des
Beispielprogramms.
4.3
new Color( Rotanteil, Gruenanteil, Blauanteil )
Z.B.:
t.setpc(
t.setpc(
t.setpc(
t.setpc(
Turtlebefehle
Hier stellen wir Ihnen alle Befehle vor, welche die Turtle versteht und zeigen
Ihnen in einigen Beispielprogrammen, wie diese Befehle zu verwenden sind. Bei
der Vorstellung der Befehle gehen wir davon aus, daß t eine Turtle bezeichnet.
pu( )
pen up“ — die Turtle hebt ihren Stift. Beim Bewegen zeichnet
”
die Turtle nicht.
pd( )
pen down“ — die Turtle senkt ihren Stift. Beim Bewegen zeich”
net die Turtle.
fd( n )
forward“ — die Turtle bewegt sich n Schritte vorwärts. Dabei
”
ist n eine reelle Zahl.
Beispielsweise bewegt sich die Turtle t durch den Befehl
t.fd( 3.5 );
rt( n )
right turn“ — die Turtle dreht sich um n Grad nach rechts.
”
Dabei ist n eine reelle Zahl.
lt( n )
left turn“ — die Turtle dreht sich um n Grad nach links. Dabei
”
ist n eine reelle Zahl.
home()
Bewegt die Turtle in die Mitte des Zeichenfeldes. Wenn ihr Stift
dabei unten ist, wird eine Linie gezeichnet.x
hide()
Macht die Turtle unsichtbar — sie zeichnet dann zwar noch,
verdeckt aber nicht mehr Teile der Zeichnung.
show()
Macht eine zuvor durch hide() versteckte Turtle wieder sichtbar.
setpc( color ) Setzt die Farbe, in welcher die Turtle zeichnet. Um diesen
Befehl, in einem eigenen Programm zu verwenden, muß zum
Beginn des Programms der Befehl
Wie man Farben verwendet, ist beim Befehl setpc und im unten
stehenden Beispiel beschrieben.
Befehle zur Fehlersuche:
debug=false
angestellt. Sobald der Debug-Modus angestellt ist, gibt die
Turtle bei jedem Befehl aus, was sie gerade tut.
Der Debug-Modus kann durch den Befehl
t.debug=false;
wieder ausgestellt werden.
setName( name ) Wenn Sie mit mehreren Turtles arbeiten, macht es Sinn,
jeder einen eigenen Namen zu geben. Dadurch können Sie
im Debug–Modus erkennen, welche der Turtles die Debug–
Meldung ausgegeben hat.
Der Befehl
t.setName("Tina Turtle");
report()
25
Um Ihnen bei der Fehlersuche in Ihren Programmen zu helfen, hat die Turtle einen Debug-Modus (Fehlersuchmodus).
Der Debug-Modus wird in einer Turtle t durch den Befehl
t.debug=true;
import java.awt.Color;
stehen. Gültige Farben sind:
Color.black, Color.blue, Color.cyan, Color.darkGray, Color.gray,
Color.green, Color.lightGray, Color.magenta, Color.orange,
Color.pink, Color.red, Color.white, Color.yellow
Sie können auch eigene Farben kreieren: Jede Farbe hat einen
Rot–, einen Grün– und einen Blauanteil zwischen 0 und 255.
Sie können eigene Farben erzeugen, indem Sie die Farbe
Blau
Schwarz
in Rot
in Blaugrau
import java.awt.Color;
debug=true
backward“ Die Turtle bewegt sich n Schritte rückwärts. Dabei
”
ist n eine reelle Zahl.
zeichnet in
zeichnet in
// zeichnet
// zeichnet
Weiter unten finden Sie ein Beispiel, das die Verwendung von
Farben demonstriert.
clearScreen( color ) Die Zeichenfläche der Turtle wird in der angegebenen
Farbe gelöscht. Um diesen Befehl, in einem eigenen Programm
zu verwenden, muß zum Beginn des Programms der Befehl
dreieinhalb Schritte vorwärts.
bk( n )
Color.blue );
// Turtle
Color.black ); // Turtle
new Color(255,0,0) );
new Color(100,100,255) );
bewirkt, daß die Turtle t jeder Debug–Ausgabe den Namen
Tina Turlte“ voranstellt.
”
Gibt die Position und Blickrichtung der Turtle aus.
Das folgende Beispielprogramm verwendet all die oben genannten Befehle:
Demo1.javaa
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapFirst/Demo1.java
26
Verbotene Befehle:
5
Die folgenden Befehle dürfen Sie in den ersten Hausaufgaben nicht benutzen.
Sie durchbrechen den Turtle–Gedanken, der vorsieht, daß die Turtle nur lokal,
d.h. in ihrem eigenen Koordinatensytem, arbeitet.
Es sollen nun einige Grundregeln besprechen, die in jeder Java-Programmdatei
berücksichtigt werden müssen.
setPosition( x, y) Setzt die Position der Turtle auf dem Zeichenfeld. x und
y sind dabei reelle Zahlen. Wenn der Stift unten ist, wird bei
der Bewegung eine Linie gezeichnet.
Beispielsweise bewegt sich die Turtle t durch den Befehl
t.setPosition( 10, 10 );
auf die Position mit den Koordinaten (10,10).
double getX()
Liefert die horizontale Koordinate der Turtle auf dem Zeichenfeld. Das Ergebnis ist eine reelle Zahl:
Zum Beispiel speichert
double x = t.getX();
die horizontale Koordinate der Turtle t in der Variablen x.
double getY()
Liefert die horizontale Koordinate der Turtle auf dem Zeichenfeld zurück.
setHeading( d ) Setzt die Richtung, in welche die Turtle schaut. Dabei schaut
die Turtle genau nach oben, wenn d == 0 ist. d ist eine reelle
Zahl.
Zum Beispiel läßt der Befehl
t.setHeading(90);
die Turtle genau nach rechts schauen.
double getHeading() Ermittelt die Blickrichtung der Turtle.
Zum Beispiel speichert der Befehl
5.1
Grundlagen der Java-Syntax
Grundsätzliches zur Syntax von Java–Programmen
Zunächst sollten Sie wissen, daß der Compiler sich nicht um die Zeilenstruktur
Ihres Programms kümmert — für ihn gibt es zwischen Leerzeichen und Zeilenumbrüchen keinen besonderen Unterschied.
Wir hätten das Beispiel Kreuz.java aus dem letzten Kapitel auch so schreiben
können:
/*
* Benutzt die Turtle, um ein Kreuz zu zeichnen.
*/import
eip.TurtleScreen;import eip.Turtle;
class Kreuz {public static void main( String[]
args ) {TurtleScreen ts = new
TurtleScreen(); Turtle t = new Turtle( ts );
t.pd();
t.fd(
200 ); t.bk( 100 );
t.rt( 90
);t.fd( 100 );t.bk( 200 );}}
Dem Compiler ist es egal, wie das Programm formatiert ist. Für uns Menschen
ist aber dieses Programm sehr viel schlechter zu lesen als das ursprüngliche.
Da er nicht die Zeilenstruktur des Programmes verwendet, muß der Compiler
irgendwie anders erkennen, wann ein Befehl im Programm endet und der nächste
Befehl beginnt. Darum muß in Java jede Anweisung mit einem Semikolon enden.
Das gilt aber nicht für die Definition einer Klasse oder Methode.
Wenn der Compiler eine Datei bearbeitet, sieht er zunächst nur einen Strom
von Zeichen. Diese Zeichen faßt er zu größeren Einheiten zusammen. Um etwas
für den Compiler verständliches zu programmieren, müssen Sie wissen, was für
Einheiten der Compiler versteht.
Java identifiziert in seinem Eingabestrom die folgenden Einheiten:
double d = t.getHeading();
die Blickrichtung der Turtle t in der Variable d.
boolean isShown() gibt zurück, ob die Turtle momentan angezeigt wird.
boolean penIsDown() gibt zurück, ob der Stift der Turtle abgesetzt ist oder
nicht.
Das folgende Programm verwendet einige dieser verbotenen Befehle, um ein
Rechteck zu zeichnen:
Tabu.javaa
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapFirst/Tabu.java
27
Schlüsselwörter — Ein Schlüsselwort ist ein Wort, welches innerhalb der Programmiersprache eine genau festgelegte Bedeutung hat. In Java sind folgende Wörter als Schlüsselwörter reserviert (das brauchen Sie sich nicht
zu merken):
abstract
catch
default
false
goto
int
package
short
this
try
boolean
char
do
final
if
interface
private
static
true
void
break
class
double
finally
implements
long
protected
super
throw
volatile
28
byte
const
else
float
import
native
public
switch
throws
while
case
continue
extends
for
instanceof
new
return
synchronized
transient
Jedes dieser Wörter hat für Java eine ganz spezielle Bedeutung. Wannimmer eines im Programmtext auftaucht, muß es in genau der vorgesehenen
Art und Weise benutzt werden.
Neben den Schlüsselwörtern kennt Java noch einige Symbole, die beispielsweise beim Rechnen mit Zahlen benutzt werden:
=
==
-^
*=
>>=
>
<=
+
%
/=
>>>=
<
>=
<<
&=
!
!=
*
>>
|=
~
&&
/
>>>
^=
?
||
&
+=
%=
:
++
|
-=
<<=
Bezeichner — Bezeichner werden verwendet, um Objekten, Klassen, Attributen, Methoden und anderen Dingen im Java-Programm Namen zu geben.
Namen sind sehr wichtig; beispielsweise können Sie ein Objekt nur verwenden, wenn Sie das Objekt unter einem gewissen Namen kennen.
Beispiel: In der Beispielklasse Kreuz.java auf Seite ?? wurden die
Schlüsselwörter import, class, public, static, void, public und new
verwendet.
Es wurden die Bezeichner eip.TurtleScreen, eip.Turtle, Kreuz, main,
args, String, TurtleScreen, ts, Turtle, t, pd, fd, bk und rt benutzt.
Bei der Wahl von Bezeichnern dürfen Sie Ihrer Phantasie fast freien Lauf
lassen. Allerdings sollten Sie dafür sorgen, daß die von Ihnen gewählten
Bezeichner aussagekräftig sind und das bezeichnete Objekt gut charakterisieren. Java ist es egal, ob Sie wir die Turtle mit t oder mit ruebe. Einen
menschlichen Leser würden Sie dadurch aber verwirren.
Ein Bezeichner darf beliebig lang werden, und bei der Wahl eines Bezeichners werden Sie lediglich durch folgende Bedingungen eingeschränkt:
Beispiel: Hier eine Liste gültiger Bezeichner:
i3 String
MAX VALUE Lupo1234 392
i
mEiNeKlAsSe meineKlasse
mein segel boot
Nun folgt eine Liste ungültiger Bezeichner:
1haus
Ungültig: beginnt mit Ziffer.
class
Ungültig: class ist ein Schlüsselwort.
ab-c
Ungültig, weil ein Minus nicht in einem Bezeichner
enthalten sein darf. Java würde denken, daß Sie hier
das durch c bezeichnete Objekt vom mit ab bezeichneten Objekt substrahieren wollen.
#bdd
Ungültig: enthält ein nicht erlaubtes Sonderzeichen.
ein Objekt
Ungültig: enthält ein Leerzeichen.
Und schließlich eine Liste von Bezeichnern, die zwar erlaubt sind, die
Sie aber dennoch nicht verwenden sollten.
Meine$Klasse Das Symbol $ sollten Sie nicht verwenden. Die JavaUmgebung benutzt es nämlich auf eine ganz spezielle
Weise.
Class
Java unterscheidet zwischen Groß- und Kleinschreibung und wird diesen Bezeichner daher nicht mit
dem Schlüsselwort class in Verbindung bringen. Ein
menschlicher Leser könnte dadurch aber verwirrt werden.
Zahlenkonstanten — Natürlich dürfen in einem Java-Programm auch Zahlen
vorkommen. Java kennt ganze oder reelle Zahlen. Wie Zahlen in einem
Programm genau aussehen dürfen, beschreiben wir erst später. Vorerst sei
gesagt, daß man beim Angeben von Zahlen eigentlich nicht allzuviel falsch
machen kann.
Beispiel: Beispiele für ganze Zahlen sind:
• Ein Bezeichner darf groß- und kleingeschriebene Buchstaben13 , die
Ziffern 0-9 und die Sonderzeichen _ und $ enthalten. Dabei sollten
Sie von der Verwendung des Zeichens $ aber absehen — es ist für
vom Compiler automatisch generierte Bezeichner vorgesehen.
• Ein Bezeichner darf nicht mit einer Ziffer anfangen.
• Schlüsselwort dürfen Sie nicht als Bezeichner verwenden.
Wichtig zu bemerken ist noch, daß Java großgeschriebene und kleingeschriebene Buchstaben streng unterscheidet — für Java sind einBezeichner
und EinBezeichner zwei völlig verschiedene Dinge.
Wenn Sie Bezeichner wählen, sollten Sie diese Eigenschaft von Java aber
nicht mißbrauchen — ein menschlicher Leser Ihres Programm könnte möglicherweise durcheinanderkommen. Wenn Sie für verschiedene Dinge Bezeichner verwenden, die sich nur durch die Groß- Kleinschreibung unterscheiden, wird es einem Menschen sicher schwerfallen, sich zu merken,
wofür welcher Bezeichner steht. Vermeiden Sie daher die Verwendung von
Bezeichnern, die sich nur durch die Groß- Kleinschreibung unterscheiden.
10, -30, +1043, 1334, 0123, 0xFF
Bei den letzten Zahlen des Beispiels ist eine Bemerkung angebracht
— wenn eine mehrstellige Zahl mit einer Null anfängt, faßt Java Sie
als Zahl in oktaler Darstellung auf. Wenn eine Zahl mit den Zeichen
0x beginnt, faßt Java sie als hexadezimale Zahl auf. Die oktale Zahl
0123 entspricht der dezimalen Zahl 83, und die hexadezimale Zahl
0xFF entspricht der dezimalen Zahl 255. Später gehen wir darauf
nochmal ein.
Beispiele für reelle Zahlen sind:
3.141, 493., .5, -503, 120e-9, 140.5E120
Sie sehen, daß in Java als Dezimalpunkt tatsächlich ein Punkt und
nicht ein Komma verwendet wird. Das e bzw. das E in den letzten
beiden Zahlen steht für “Exponent”. Die Zahl 120e − 9 entspricht der
Zahl 120 · 10−9 , und genauso steht die Zahl 140.5E120 für die Zahl
120 · 10120 . Ob Sie bei dieser Schreibweise lieber ein kleines e oder
ein großes E verwenden, ist Ihnen überlassen — beide Schreibweisen
sind erlaubt und haben die gleiche Wirkung.
13 Es ist sogar möglich, chinesische oder russische Buchstaben zu verwenden — wie das geht,
werden wir Ihnen aber nicht erzählen.
29
30
Zeichenketten — Eine Zeichenkette ist ein in doppelten Anführungszeichen
stehender Text. In der Zeichenkette ist jedes Zeichen erlaubt. Es gibt allerdings einige Zeichen, bei denen man sich etwas anstrengen muß, um Sie
in eine Zeichenkette aufzunehmen. Darauf wird später noch eingegangen.
Ein mehrzeiliger Kommentar wird durch /* begonnen und endet mit */.
Alles zwischen /* und */ wird vom Compiler ignoriert. Unser Beispiel
könnten wir auch so dokumentieren:
/*
* Die Klasse HalloWelt gibt auf dem Bildschirm den Text
* "Hallo, Welt" aus.
*/
class HalloWelt {
Beispiel: Hier ein paar Beispiele für gültige Zeichenketten:
"Dies ist eine Zeichenkette"
"Sonderzeichen {}!#/-"
"class"
"510"
/***********************************************************
* diese Methode wird beim ausführen der Klasse ausgeführt:
*/
public static void main( String[] args )
{
System.out.println("Hallo, Welt //");
}
Die mittlere Zeichenkette enthält den Text class. Da der Text in einer
Zeichenkette steht, hat er für Java nichts mit dem Schlüsselwort class
der Sprache Java zu tun.
Die letzte Zeichenkette enthält den Text 510. Auch hier gilt: Aufgrund der Anführungszeichen interpretiert Java dies nicht als die Zahl
510 sondern als Text.
Schließlich noch ein Beispiel für eine ungültige Zeichenkette:
}
"Sein Name war "Hans". "
Schließlich noch ein Beispiel für einen ungültigen Kommentar:
Das erste Anführungszeichen beendet die Zeichenkette. Java liest dies
als Zeichenkette mit Inhalt “Sein Name war“ gefolgt vom Bezeichner
Hans gefolgt von der Zeichenkette “. ”. Auf diese Art kann man keine Zeichenkette erzeugen, die ein Anführungszeichen enthält. Später
erfahren Sie, wie das geht.
/* Ein Kommentar /* in einem Kommentar */ ist nicht erlaubt */
Es ist nicht möglich, einen durch /*...*/ begrenzten Kommentar zu
schreiben, in welchem ein weiterer solcher Kommentar enthalten ist. Der
Compiler würde hier beim ersten */ denken, der Kommentar sei beendet.
Kommentare — schließlich können Sie in ein Java-Programm Kommentare
aufnehmen. Kommentare dienen dazu, den Programmtext zu kommentieren. Dazu gehört insbesondere die Dokumentation der Klassen, ihrer Attribute und ihrer Methoden. Alles, was in einem Kommentar steht, wird
vom Java-Compiler völlig ignoriert. Sie können in einen Kommentar also
beliebige Texte schreiben.
Es ist jedoch möglich, das //-Zeichen innerhalb eines solchen Kommentars
zu verwenden:
/* Ein einzeiliger Kommentar // in einem Kommentar ist erlaubt. */
Java unterscheidet mehrere Arten von Kommentaren. Ein einzeiliger Kommentar wird durch das Zeichen // eingeleitet. Wenn diese Zeichen in einer
Zeile (außerhalb einer Zeichenkette) stehen, ignoriert Java den gesamten
Rest der Zeile. Unser kleines Beispielprogramm von vorhin könnten wir
mit einzeiligen Kommentaren wie folgt dokumentieren:
class HalloWelt {
Sie sollten Kommentare verwenden, um Ihr Programm verständlicher zu
machen. Zur Verständlichkeit eines Programms gehört aber nicht nur die
Formulierung hilfreicher Kommentare sondern auch die Verwendung aussagekräftiger Bezeichner und das Einhalten einer gut lesbaren Programmstruktur. Wenn Sie aussagekräftige Bezeichner verwenden, können Sie sich
so manchen Kommentar sparen.
// gebe den Text "Hallo, Welt" aus.
// diese Methode wird beim ausführen der Klasse ausgeführt:
public static void main( String[] args )
{
System.out.println("Hallo, Welt //");
}
5.2
Zusammenfassung
Nachdem Sie dies Kapitel gelesen haben, sollten Sie folgende Fragen beantworten
können:
B Welchen Zweck hat die Zeilenstruktur eines Programms ?
}
B Wozu dient ein Semikolon in Java ?
Zu Demonstrationszwecken haben wir auch in die Zeichenkette "Hallo, Welt"
das Zeichen // eingefügt. An der Stelle bewirkt es keinen Kommentar, da
es sich innerhalb einer Zeichenkette befindet.
31
B Geben Sie Beispiele für Bezeichner, die zwar erlaubt sind, aber dennoch nicht benutzt werden sollten !
B Was ist eine Zeichenkette ?
32
6
Variablen und Datentypen
Die Programme, die wir bisher gesehen haben, sind ziemlich langweilig — sie
arbeiten eine vorgegebene Folge von Befehlen ab und sind überhaupt nicht flexibel. Für flexible Programme, die bei jedem Aufruf etwas anderes tun, benötigt
man Variablen“, etwas das bei jedem Programmablauf einen anderen Wert
”
haben kann.
6.1
Bevor eine Variable in Java das erste Mal verwendet wird, muß man Java daher
Informationen darüber zukommen lassen, welchen Typ diese Variable haben soll.
In Java geschieht dies, indem man eine Anweisung des Aufbaus
TYP variablenname;
verwendet. Sobald Java eine solche Anweisung gefunden wird, merkt sich Java:
Aha, hier ist jetzt eine Variable namens variablenname definiert worden, und
diese Variable darf nur Werte des Typs TYP aufnehmen.
Beispiel:
Variablen und ihr Typ
DemoVars.javaa
Wir verwenden Variablen, wenn wir Objekten einen Namen geben wollen, oder
wenn wir uns etwas merken möchten. Variablen sind Platzhalter für Zahlen,
Zeichenketten, Turtles oder sonstirgendwelche Dinge. Auf der Hardwareebene
entspricht jeder Variable ein gewisser Platz im Hauptspeicher des Computers.
Jede Variable hat einen Namen, und dieser Name muß den Vorschriften für
Bezeichner genügen.
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapVariablen/DemoVars.java
In Zeile 6 wird eine Variable namens zaehler als int definiert. Von dieser
Zeile an weiß Java, daß der Bezeichner zaehler für eine Variable steht
und nur ganze Zahlen speichern kann.
Beispiel: Angenommen, wir wollen in einem Programm einen Bruttopreis berechnen. Wenn wird dies für einen Preis von 10, − DM tun wollen,
könnten wir den Bruttopreis als
In Zeile 7 wird der Variable zaehler der Wert 10 zugewiesen. Vorher hatte
zaehler keinen definierten Wert.
15% · 10, − + 10, −
In Zeile 8 wird eine weitere Variable namens inversZaehler definiert, die
reelle Zahlen speichern kann. Außerdem wird dieser Variable gleich der
inverse Wert von zaehler zugewiesen.
berechnen.
Der Nachteil der obigen Formel ist, daß sie nur für einen Nettopreis von
10,- DM korrekt ist. Wenn wir in unserem Programm auch mit anderen
Preisen als 10,- DM rechnen wollen, würden wir daher lieber einen Platzhalter — eine Variable — für den Nettopreis verwenden. Möglicherweise
würden wir schreiben:
bruttopreis = 0.15 * nettopreis + nettopreis
Diese Formel wäre für jeden Preis anwendbar. Dazu müsste der Platzhalter
nettopreis den jeweils zu verwendenden Nettopreis enthalten. Das Ergebnis würden wir dann in einem anderen Platzhalter namens bruttopreis
speichern.
Wir können Variablen überall dort einsetzen, wo wir Werte hinschreiben würden.
Natürlich müssen wir dabei ein bißchen aufpassen — es wäre sicher nicht sinnvoll, einen Platzhalter, der eine reelle Zahl enthält, an einer Stelle zu verwenden,
an der nur Zeichenketten hinpassen.
Damit man nicht ausversehen eine Variable an einer Stelle verwendet, wo sie
keinen Sinn macht, hat in Java jede Variable einen Typ.
Beispiel: Beispielsweise gibt es in Java den Datentyp int. Variablen
dieses Typs können ganze Zahlen speichern.
Variablen des Datentyps double Typs können reelle Zahlen speichern.
Wenn Sie eine Variable des Typs double an einer Stelle verwenden, wo
man nur ganze Zahlen verwenden darf, zeigt der Compiler bei der Übersetzung ihres Programms einen Fehler an.
33
In Zeile 9 und 10 werden beide Variablen ausgegeben.
6.1.1
Ganze Zahlen
Java kennt mehrere ganzzahlige und mehrere reellwertige Datentypen. Der Grund
hierfür ist folgender: Jede Variable belegt einen gewisse Anzahl von Bytes im
Speicher des Computers. Aus Kapitel 2 wissen Sie, daß man mit n Bytes nur
28·n verschiedene Werte darstellen kann.
Um den Typ einer Variable festzulegen, muß man sich darum vorher Gedanken
machen, wieviele verschiedene Werte sie annehmen können soll und davon ausgehend, wieviele Bytes man im Computerspeicher dafür verwenden möchte. Da
man normalerweise nicht mehr Speicherplatz als nötig verschwenden will, bietet Java ganzzahlige und reellwerige Datentypen verschiedener Längen an (die
Länge des Datentyps gibt an, wieviele Bytes seine Variablen belegen).
Java kennt die ganzzahligen Datentypen byte, short, int und long. Am häufigsten verwendet man den Datentyp int.
Typ
byte
short
int
long
Länge
1
2
4
8
Wertebereich
−27 , . . . , 27 − 1
−215 , . . . , 215 − 1
−231 , . . . , 231 − 1
−263 , . . . , 263 − 1
Das folgende Programm demonstriert die Verwendung von ganzen Zahlen:
34
GanzZahl.javaa
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapVariablen/GanzZahl.java
speichern. Sie können auch benutzt werden, wenn eine Variable nur zwei Werte
annehmen können soll.
Das folgende Beispiel demonstriert die Verwendung von boolean:
DemoBoolean.javaa
Was passiert, wenn eine Variable einen zu großen oder kleinen Wert enthält ?
Um das zu demonstrieren, haben wir ein Programm geschrieben, das eine Zahl
vom Benutzer einliest und anschließend ausgibt:
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapVariablen/DemoBoolean.java
GanzZahlInput.javaa
6.1.4
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapVariablen/GanzZahlInput.java
Wenn Sie das Programm kompilieren und starten, werden Sie aufgefordert, eine
Zahl einzugeben. Die eingegebene Zahl wird dann der int–Variable i zugewiesen.
Probieren Sie es bitte selbst aus ! Wenn Sie die Zahl 231 − 1 eingeben (das
ist die Zahl 2147483647), gibt das Programm sie korrekt wieder aus. Wenn Sie
jedoch größere Zahlen eingeben, kommt es zu komischen Resultaten: statt der
von Ihnen eingegebenen Zahl werden negative Zahlen ausgegeben. Zum Beispiel
macht das Programm bei mir aus der Zahl 123456789012 die Zahl −1097262572.
Diesen Effekt nennt man Overflow — eine Zahl läuft über, wenn man ihr
einen zu großen oder einen zu kleinen Wert zuweist. Der Wert, den die Zahl
dann enthält, ist nicht brauchbar.
Sie müssen also immer darauf achten, daß der ausgewählte Datentyp zu den
Daten passt, die Sie verarbeiten wollen.
6.1.2
Fließkommazahlen
Java kennt die beiden reellwertige Datentypen float und double. float–Zahlen
belegen 4 Byte und double–Zahlen belegen 8 Byte im Speicher.
Sie sollten vorerst immer double–Variablen verwenden, da hier nicht nur der
Wertebereich sondern auch die Anzahl der geführten Nachkommastellen größer
ist als für float–Variablen.
Das folgende Programm demonstriert die Verwendung von reellen Zahlen:
Zeichen und Zeichenketten
Einzelne Zeichen sind in Java vom Typ char. Zeichenketten sind vom Typ
String.
Um ein Zeichen in einem Java–Programm anzugeben, muß man es in einfache Anführungszeichen schreiben. Eine Zeichenkette schreibt man in doppelte
Anführungszeichen.
Wenn man zwei Zeichenketten mit + verknüpft, so entsteht eine Zeichenkette,
die den hintereinander gehängten Text beider Zeichenketten enthält.
Beispiel:
DemoString.javaa
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapVariablen/DemoString.java
Auf Zeile 4 wird eine char–Variable namens b definiert, welcher das Zeichen z“ zugewiesen wird. Der Inhalt der Variable hat mit dem Namen
”
der Variable nichts zu tun.
In Zeile 8 wird die Variable name als String definiert. Ihr Inhalt entsteht
durch Hintereinanderhängen anderer Variablen.
In Zeile 9 wird die Variable sequenz als String definiert. Wir bilden den
Inhalt, indem wir hinter den leeren String "" mit Hilfe des +–Operators
die drei Zeichenvariablen anfügen. Der Leerstring wird hier dazu benutzt,
damit + überhaupt als das Hintereinanderhängen von Zeichenketten interpretiert wird.
ReellZahl.javaa
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapVariablen/ReellZahl.java
6.1.3
Logischer Datentyp
Der Datentyp boolean repräsentiert logische Werte. Ein logischer Wert ist entweder wahr (true) oder unwahr (false).
boolean–Variablen können benutzt werden, um die Resultate von Vergleichen zu
35
36
7
Ausdrücke
Die System.out.println–Methode darf man auf all die durch uns demonstrierten
Arten verwenden, da sie sowohl Ausdrücke vom Typ int als auch Ausdrücke vom
Typ float als auch Ausdrücke vom Datentyp String verarbeiten kann. Sie kann
auch Ausdrücke aller anderen Datentypen verarbeiten und ist damit ziemlich
einzigartig.
In diesem Kapitel geben wir Ihnen ergänzende Informationen zu Goto Java 2,
Kapitel 5, die Sie ergänzend zu Hausaufgabe 3 lesen sollten.
7.1
Was ist ein Ausdruck ?
Beispiel: Hier ein paar Beispiele für Ausdrücke. Es seien folgende Variablen definiert:
Was ein Ausdruck ist, erklären wir Ihnen am einfachsten an einem Beispiel.
Schauen Sie sich das folgende Beispielprogramm an:
int i = 5;
float f = 5;
String a = "Hallo";
01 public class JavaDemo {
02 public static void main( String[] args ) {
03
int
i = 5;
04
float f = 5.0f;
05
System.out.println( 5 );
06
System.out.println("5");
07
System.out.println( i );
08
System.out.println( f );
9
System.out.println( 5 * (i - 3 * f + 1.3 ) );
10 }
11 }
Das Programm gibt einige Werte auf den Bildschirm aus, wobei wir wieder die
bereits bekannte Methode System.out.println verwenden. Auf den ersten Blick
scheint dies ein ganz triviales Programm zu sein.
Aber beachten Sie, auf wie viele unterschiedliche Arten wir die Ausgaberoutine
verwenden: In Zeile 5 geben wir eine Zahl aus. In Zeile 6 geben wir einen String
aus. In Zeile 7 wird der Inhalt einer int–Variable ausgegeben, während in Zeile 8
der Inhalt einer float–Variable ausgegeben wird. Schließlich wird in Zeile 9 noch
vor der Ausgabe eine Rechnung durchgeführt und erst dann der berechnete Wert
ausgegeben.
All diese unterschiedlichen Daten müssen von Java auch unterschiedlich behandelt werden — mit Strings muß ein Computer ganz anders umgehen als mit
Zahlen, und mit ganzen Zahlen vom Typ int muß der Computer ganz anders
umgehen als mit reellen Zahlen vom Typ float. Auch muß die Rechnung in Zeile
09 erst vom Computer durchgeführt werden, bevor das Ergebnis ausgegeben
werden kann.
Ähnlich wie bei im obigen Beispiel bei der Verwendung von System.out.println
kann in einem Java–Programm an jeder Stelle, wo irgendein Wert stehen kann,
auch eine Rechnung oder eine Variable oder sonstetwas stehen, das man auswerten kann. Dabei darf die Auswertung nur Werte der jeweils erlaubten Datentypen ergeben.
Definition: Ausdruck
Ein Ausdruck ist etwas, das man auswerten kann. Die Auswertung
eines Ausdruckes ergibt einen Wert. Der Datentyp dieses Wertes
ergibt sich aus dem Aufbau des Ausdrucks. An jeder Stelle, an der ein
Wert eines gewissen Datentyps stehen darf, darf auch ein Ausdruck
dieses Datentyps stehen.
37
2
Die Zahl 2 ist ein Zahlenliteral. Jedes Literal ist ein Ausdruck,
dessen Datentyp gleich dem Datentyp des Literals ist. Das ganzzahlige Literal 2 ist somit ein Ausdruck mit Wert 2 und Datentyp
int
“5”
Das String–Literal "5" ist ein Ausdruck mit Wert "5" und Datentyp String
i
Auch jede Variable ist ein Ausdruck, deren Wert sich aus dem
Inhalt der Variable ergibt. Mit den obigen Definitionen ist dies
ein Ausdruck vom Typ int mit Wert 5.
f
Die Variable f ist hier ein Ausdruck vom Typ float mit Wert 5.0.
i+2
In Ausdrücken können Rechnungen vorkommen . Der Wert einer
Rechnung ergibt sich natürlich als Resultat der Rechnung. Dabei sind die Operanden einer Rechnung selbst wieder Ausdrücke.
Der Wert der Rechnung i+2 ergibt sich durch Auswerten des
Ausdrucks links vom +–Zeichen (int mit Wert 5), durch Auswerten des Teils rechts vom +–Zeichen (int mit Wert 2) und durch
Addition der so ermittelten Werte.
Der Datentyp einer Rechnung ergibt sich aus den an der Rechnung beteiligten Datentypen (dazu sagen wir im Kapitel über
Typwandlungen mehr). Dieser Ausdruck würde zum Wert 7 ausgewertet und hätte den Typ int, da in der Rechnung nur Ausdrücke vom Typ int vorkommen.
a + “ Welt” Auch dies ist ein Ausdruck. Der String a und der String
" Welt" werden zusammengehängt. Ergebnis ist ein Ausdruck
vom Typ String mit Inhalt "Hallo Welt".
i=5
Ausdruck
Auch die Zuweisung eines Wertes an eine Variable ist ein Ausdruck. Zwar ist der eigentliche Zweck der Zuweisung, der Variable
auf der linken Seite des =–Zeichen Variable den Wert des Ausdrucks auf der rechten Seite zuzuweisen. Darüberhinaus ist die
Zuweisung in Java aber auch ein Ausdruck, dessen Auswertung
den Wert auf der rechten Seite des =–Zeichens ergibt (dazu gleich
mehr).
Beispielsweise gibt das folgende Java–Programm den Wert 5 auf
den Bildschirm aus und weist der Variable i den Wert 5 zu:
public class DemoAssign {
public static void main( String[] args ) {
int i = 0;
System.out.println( i = 5 );
38
(die Buchstaben dürfen dabei klein oder groß geschrieben werden). Der Wert
eines hexadezimalen Literals ergibt sich durch Umrechnung der hexadezimalen
Zahl.
System.out.println( i );
}
}
7.2
Beispiel: Im hexadezimalen Zahlensystem gibt es nicht wie im dezima-
Literal–Ausdrücke
len Zahlensystem 10 sondern ganze 16 Ziffern (die Ziffern 0-9 und die
Buchstaben A-F). Wenn man im hexadezimalen Zahlensystem von 0 bis
18 zählt, sieht das so aus: 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9,
0xA, 0xB, 0xC, 0xD, 0xE, 0xF, 0x10, 0x11, 0x12
Die wohl einfachsten Ausdrücke sind Literale. Ein Literal ist eine konkrete Zahl
oder ein konkreter String, der in einem Programmtext auftaucht. Jedes Literal
hat einen eindeutig bestimmten Datentyp.
Die nächsten Seiten sollen Ihnen eine gewisse Vorstellung davon vermitteln,
wie Literale geschrieben werden und welchen Datentyp Java welchen Literalen
zuweist.
Die hexadezimale Zahl 0xB entspricht also der dezimalen Zahl 11. Die
hexadezimale 0xff entspricht der dezimalen Zahl 255. Die hexadizimale
Zahl 0x100 entspricht der dezimalen Zahl 256.
Weitere Beispiele für hexadezimale Zahlen: 0xaf, 0X1AfAF, -0xff, -0xfF
7.2.1
Ganzzahlige Literale
Es gibt drei Typen von ganzzahligen Literalen: dezimale, oktale und hexadezimale. Sie werden zwar in dieser Veranstaltung weder oktale noch hexadezimale
Literale verwenden, es ist aber wichtig, daß Sie wissen, wie man diese Literale
schreibt. Es ist nämlich sehr leicht möglich, eine Zahl ausversehen als oktales
Literal zu schreiben. Für diese Zahl könnte sich dann ein unerwarteter Wert
ergeben.
Ein dezimales Literal ist eine Zahl in üblicher dezimaler Darstellung. Ein dezimales Literal darf mit einem Vorzeichen (+ oder −) beginnen und die Ziffern 0
bis 9 enthalten. Der Wert eines dezimalen Literals ist der Wert der angegebenen
Zahl.
Dezimales
Literal
Ein ganzzahliges Literales ist immer vom Typ int, es sei denn, man hängt den
Buchstaben L an. In diesem Fall erhält es den Datentyp long.
Es stellt sich natürlich die Frage, warum man überhaupt ganzzahlige Literale
vom Typ int und Typ long unterscheidet. Der Datentyp long umfaßt doch den
Datentyp int, und daher sollte doch eigentlich der Datentyp long ausreichen,
um alle ganzen Zahlen zu repräsentieren.
Der Grund, warum es dennoch den Datentyp int gibt, wird im nächsten Kapitel
über Typkonvertierungen klar werden. Hier sei nur gesagt, daß Sie dort erfahren werden, daß es zwar gestattet ist, einer long–Variable einen Ausdruck vom
Typ int zuzuweisen, daß es jedoch nicht gestattet ist, einer int–Variable einen
Ausdruck des Typs long zuzuweisen. Das folgende Programmfragment enthält
daher auf Zeile 3 und 4 Fehler:
Beispiel: Die folgenden Werte sind dezimale Literale: 1, 2, 3, +4, -5,
+100, -984235, +239048
Eine ganze Zahl wird in einem Java–Programmtext immer dann als oktales
Literal interpretiert, wenn nach dem optionalen Vorzeichen eine führende Null
steht. Nach der führenden Null darf ein oktales Literal nur die Ziffern 0 bis 7
enthalten. Der Wert eines oktalen Literals ergibt sich, indem die oktale Zahl
umgerechnet wird.
oktales Literal
int
long
int
int
i
m
j
k
=
=
=
=
5;
i;
5L;
m;
// Fehler !
// Fehler !
Würde Java nun auch die Zahlen, hinter denen kein “L” steht, als long–Literale
interpretieren, so wäre auch die erste Zeile des obigen Programmfragmentes
ungültig, und um dies zu vermeiden, gibt es für ganzzahlige Literale diese Unterscheidung in die zwei Datentypen int und long.
Beispiel: Im oktalen Zahlensystem gibt es nicht wie im dezimalen Zahlensystem 10 sondern nur 8 Ziffern. Wenn man im oktalen Zahlensystem
von 0 bis 16 zählt, sieht das so aus: 00, 01, 02, 03, 04, 05, 06, 07, 010, 011,
012, 013, 014, 015, 016, 017, 020
Beispiel: Beispiele für Literale:
123
Die oktale Zahl 010 entspricht also der dezimalen Zahl 8. Die oktale Zahl
0123 entspricht der dezimalen Zahl 83.
Dezimales Literal, Wert 123, Typ int
123L Dezimales Literal, Wert 123, Typ long
Weitere Beispiele für oktale Zahlen sind: -033, +071, 01237
0123 Oktales Literal, Wert 83, Typ int
Da in einer oktalen Zahl keine Ziffern außer 0 bis 7 vorkommen dürfen,
ergibt die folgende Zeile einen Fehler beim kompilieren:
0123L Oktales Literal, Wert 83, Typ long
0xFF Hexadezimales Literal, Wert 255, Typ int
int i = 0129; // Fehler
Wenn eine ganze Zahl nach dem optionalen Vorzeichen mit dem Text “0x” oder
“0X” beginnt, wird sie von Java als hexadezimales Literal interpretiert. Ein
hexadezimales Literal darf die Ziffern 0–9 und die Buchstaben A bis F enthalten
39
hexadez. Literal
7.2.2
Reellwertige Literale
Alle in einem Java–Programm auftretenden Zahlen mit Dezimalpunkt oder Zehnerexponenten sind rellwertige Literale.
40
Datentyp
ganzzahliger
Literale
Ein reellwertiges Literal besteht aus dem ganzzahligen Teil vor dem Dezimalpunkt, dem Nachkommateil und einem optionalen Zehnerexponenten. Der Zehnerexponent wird durch den Buchstaben “E” oder “e” eingeleitet. Der Exponent
darf negativ sein.
Beachten Sie bitte, daß in Java der Dezimalpunkt nicht wie in Deutschland
üblich ein Komma ist, sondern ein Punkt ist.
Reelle Zahlen haben in Java normalerweise den Datentyp double. Wenn Sie
hinter die Zahl den Buchstaben f oder F anhängen, erhält das Literal den Typ
float. Optional dürfen Sie auch ein d oder D anhängen, aber auch dann erhält
die Zahl den Datentyp double.
Das Literal true steht für logisch wahre Werte und das Literal false steht für
logisch falsche Werte.
Beispiel: Hier ein paar Beispiele für Ausdrucke, die in der Auswertung
true oder false ergeben:
1
2
2
2
<
<
<=
>
2
1
2
2
//
//
//
//
Ausdruck
Ausdruck
Ausdruck
Ausdruck
vom
vom
vom
vom
Typ
Typ
Typ
Typ
boolean,
boolean,
boolean,
boolean,
Wert
Wert
Wert
Wert
:
:
:
:
true
false
true
false
Beispiel: Beispiele für reellwertige Literale
7.2.4
Zeichenliterale
1.
Die Zahl 1.0, Datentyp double
1.f
Die Zahl 1.0, Datentyp float
.1D
Die Zahl 0.1, Datentyp double
1.0E0
Die Zahl 1.0, Datentyp double
Zeichenliterale bestehen aus einem einzelnen Zeichen in einfachen Hochkommata. Der Datentyp eines Zeichenliterals ist char, und der Wert des Zeichenliterals
ist eine Zahl zwischen 0 und 65535, welche sich aus dem Unicode–Zeichensatz
ergibt.
1e5
Die Zahl 1 · 105 , Datentyp double
1e5f
Die Zahl 1 · 105 , Datentyp float
Beispiel: Beispiele für char–Literale sind ’a’, ’B’, ’#’, ’+’, ’1’.
Folgende Texte sind keine gültigen Zeichenliterale, da sie nicht genau ein
Zeichen enthalten: ’’, ’aa’, ’12’.
+3.14159 Die Zahl +3.14159, Datentyp double
4.10E-10 Die Zahl 4.10 · 10−10 , Datentyp double
Unicode
4.10E-10f Die Zahl 4.10 · 10−10 , Datentyp float
Beachten Sie bitte, daß Sie an einer Stelle im Programmtext, wo ein Ausdruck
vom Typ double erwartet wird, zwar einen Ausdruck vom Typ float verwenden
dürfen. Sie dürfen jedoch an einer Stelle, wo ein Ausdruck vom Typ float erwartet wird, keinen Ausdruck vom Typ double verwenden. Warum das so ist,
erklären wir im nächsten Kapitel über Typwandlungen.
Beispiel: Das folgende Programmfragment enthält daher auf Zeilen 3
und 4 Fehler.
double
double
float
float
float
7.2.3
d1
d2
f1
f2
f3
=
=
=
=
=
3.14153; //
2.1f;
//
d1;
//
3.14153; //
3.14153f;//
erlaubt:
erlaubt:
Fehler:
Fehler:
erlaubt:
Zuweisung
Zuweisung
Zuweisung
Zuweisung
Zuweisung
double an double
float an double
double an float
double an float
float an float
Litarale vom Typ boolean
Es gibt zwei boolsche Literale, nämlich true und false. Beide haben den Datentyp boolean.
Beispiel: Ein Beispiel zu Ihrer Verwendung:
public class DemoBoole {
public static void main( String[] args ) {
boolean b1 = true;
boolean b2 = false;
}
}
41
Unicode ist ein Zeichensatz, in dem jedes Zeichen durch eine 16–Bit–Zahl dargestellt wird. Es können also maximal 65536 verschiedene Zeichen dargestellt
werden können. Jedem Zeichen wird dabei eine eindeutige Zahl zwischen 0 und
65535 zugeordnet. Zum Beispiel ist dem Buchstaben “a” die Zahl 97, dem Buchstaben “A” die Zahl 65 und der Ziffer “1” die Zahl 49 zugeordnet. Zeichen im
Unicode–Zeichensatz sind Buchstaben, Zahlen und alle anderen Sonderzeichen,
die der Computer darstellen kann sowie einige Zeichen mit besonderer Bedeutung wie Tabulator, Zeilenumbruch oder Rückschritt (Backspace). In sind Unicode auch Buchstaben anderer Länder (etwa japanische Schriftzeichen) oder
sonstige normalerweise nicht verwendete Zeichen vorgesehen.
Beispiel: Folgendes Programm gibt die Zeichen ’a’, ’B’ und ’#’ und die
diesen zugeordneten Zahlenwerte aus.
Um die Unicode–Zahlenwerte der Zeichen auszugeben, ist es nötig, die Zeichen in einen anderen Datentyp als char umzuwandeln (hier int). Die Ausgaberoutine System.out.println gibt nämlich Werte des Datentyps char
nicht als Zahl sondern als Zeichen aus.
public class DemoChar {
public static void main( String[] args ) {
char a = ’a’; // ’a’ ist ein char-Literal mit Wert 97
char b = ’B’; // ’b’ ist ein char-Literal mit Wert 66
char x = ’#’; // ’#’ ist ein char-Literal mit Wert 35
int ia = a;
// Umwandlung des Datentyps
int ib = b;
int ix = x;
System.out.println( a ); // Ausgabe des Zeichens
System.out.println( ia );// Ausgabe seines Zahlenwertes
System.out.println( b );
42
System.out.println( ib );
System.out.println( x );
System.out.println( ix );
public static void main( String[] args ) {
String hacker = "Neo";
System.out.println( hacker );
System.out.println("Ein Backslash: \\");
System.out.println("Neue\nZeile\nund");
System.out.println("Ein Anführungszeichen: \"");
}
}
}
Es gibt einige besondere Zeichen, die man mit der Tastatur nicht so einfach angeben kann. Dazu gehört beispielsweise der Zeilenumbruch. Diese Sonderzeichen
kann man eingeben, indem man eine sogenannte Escape–Sequenz verwendet. Eine Escape–Sequenz wird durch das Zeichen \, den Backslash, eingeleitet. Immer
wenn ein Zeichenliteral mit einem Backslash beginnt, werden die auf den Backslash folgenden Zeichen interpretiert, um den Wert des Zeichens zu ermitteln.
Welche Escape–Sequenzen es gibt, ist in Go To Java 2 in Tabelle 4.2 beschrieben. Den Backslash selbst ist durch ’\\’ gegeben.
}
Eine Zeichenkette muß in der Zeile beendet werden, in der sie begonnen wurde. Will man eine Zeichenkette konstruieren, die länger ist, so kann den +–
Operator verwenden. Immer wenn zwischen zwei Zeichenketten ein + steht,
entsteht durch Aneinanderhängen der beiden ursprünglichen Zeichenketten eine
längere Zeichenkette.
Beispiel: So kann man eine längere Zeichenkette bauen:
Beispiel: Die folgenden Ausdrücke sind Zeichenliterale. Obwohl wir zur
public class DemoString2 {
public static void main( String[] args ) {
System.out.println("Hallo, " + "Welt");
System.out.println( "Um eine längere Zeichenkette" +
" zu bauen,\n kann man den +-Operator" +
" benutzen. Man darf Zeichenketten \n" +
" fast beliebig lang machen.");
}
}
Angabe des Zeichens mehr als ein Zeichen benötigen, wird das Literal
nur als ein Zeichen interpretiert: ’\n’ (Zeilenumbruch), ’\t’ (Tabulator),
’\\’ (der Backslash \), ’\u0020’ (Leerzeichen).
Beispiel: Das folgende Programm verwendet Escape–Sequenzen, um das
Zeichen “a”, zwei Leerzeilen (eine Leerzeile entsteht durch das Zeichen
’\n’ und eine entsteht dadurch, daß die Ausgaberoutine selbst immer
noch einen Zeilenumbruch einfügt) und danach den Backslash darzustellen.
Beispiel: Dies Programm enthält einen Fehler, da eine Zeichenkette nicht
public class DemoEscape {
public static void main( String[] args ) {
System.out.println(’a’);
System.out.println(’\n’); // zwei Leerzeilen
System.out.println(’\\’); // Ausgabe des Backslash
}
}
7.2.5
in der Zeile beendet wird, in der sie begonnen wurde:
public class DemoString3 {
public static void main( String[] args ) {
System.out.println("Hallo,
Welt");
// Fehler !
}
}
Zeichenketten
7.3
Als letzte Art von Literalen sind sind schließlich noch die Zeichenketten zu
erwähnen. Eine Zeichenkette ist ein Text in doppelten Hochkommata. Eine Zeichenkette hat den Datentyp String, und ihr Wert ist die Zeichenfolge zwischen
den doppelten Hochkommata.
Zwischen den doppelten Hochkommata ist jedes Zeichen erlaubt, das auch in
einem Zeichenliteral verwendet werden könnte. Insbesondere können in einer
Zeichenkette auch die Escape–Sequenzen verwendet werden, die bei Zeichenliteralen eingesetzt werden konnten.
Zeichenketten unterscheiden sich deutlich von allen anderen bisher behandelten
Literalen. Alle Literale waren bisher einfache Zahlen. Eine Zeichenkette ist aber
eine Folge von Zahlen.
Beispiel: Einige Beispiele zur Verwendung von Zeichenketten:
public class DemoString1 {
43
Verwendung von Variablen
Nachdem Sie nun die allereinfachste Art von Ausdrücken – nämlich die Literale –
kennengelernt haben, soll die nächsteinfache Klasse von Ausdrücken besprochen
werden, nämlich die Variablen.
Sie erinnern sich — eine Variable ist ein Platzhalter für irgendeinen Wert. Wenn
eine Variable in einem Ausdruck auftaucht, wird bei der Auswertung des Ausdrucks für die Variable ihr Inhalt eingesetzt. Selbstredend ist der Datentyp eines
Variablen–Ausdrucks der Datentyp der Variable.
Beispiel: Im folgenden Programm wird in Zeile 03 eine Variable definiert,
und ihr wird der Wert 1 zugewiesen. In Zeile 04 wird die Ausgaberoutine
System.out.println aufgerufen.
Als auszugebender Wert wird ihr der Ausdruck i + 1 übergeben. Dieser
Ausdruck hat den Datentyp int, da hier eine int-Variable zu einem int–
Literal addiert wird. Der Wert des Ausdrucks ist der Wert der Variable i
(also 1) plus dem Wert des Integerliterals “1”.
44
01 public class DemoVar1 {
02
public static void main( String[] args ) {
03
int i = 1;
04
System.out.println( i + 1 );
05
}
06 }
public static void main(String[] args)
{
int wert;
int ergebnis = wert * 3; // Fehler
}
Initialisierung
Der erstmaligen Wertzuweisung einer Variable nach ihrer Definition kommt eine
besondere Bedeutung zu, und gibt es dafür einen besonderen Namen: Initialisierung. Die Bedeutung der Initialisierung liegt darin, daß eine Variable bis
zur Initialisierung einen unbestimmten Wert enthält.
Natürlich enthält eine Variable von dem Moment an, in dem sie definiert wurde,
immer irgendeinen Wert. Mit einer Variable ist ja immer ein gewisser Teil des
Arbeitsspeichers assoziiert, und der Wert der Variablen ergibt aus diesem Teil
des Arbeitsspeichers. Man hat aber keinerlei Kontrolle darüber, welchen Wert
der Arbeitsspeicher einer neu definierten Variable enthält. Es geht somit nicht
aus dem Programmtext hervor, welchen Wert eine Variable bei ihrer Definition
erhält, und daher nennt man Variablen, denen noch kein Wert zugewiesen wurde,
nicht initialisiert oder sagt, sie hätten einen unbestimmten Wert.
Da man einer Variable nur dann einen Wert zuweisen darf, wenn dem Compiler der Datentyp der Variable klar ist, darf man eine Variable nur nach oder
während ihrer Definition initialisieren.
Beispiel: Im folgenden Beispiel wird eine Variable als int definiert. In
der nächsten Zeile wird sie zu 2 initialisiert:
int einInt;
einInt = 2;
Man kann Definition und Initialisierung auch mit einem Befehl erledigen:
In Go To Java, Kapitel 5.1 ist das genauer ausgeführt.
7.4
Ausdrücke mit Operatoren
Neben der Verwendung von Literalen und Variablen gibt es in einem Java–
Programm auch komplexer aufgebaute Ausdrücke — man kann mit Variablen
oder Literalen rechnen, Variablen oder Literale miteinander vergleichen. Da sich
bei einer solchen Rechnung oder einem Vergleich wieder irgendein Wert ergibt,
sind auch Rechnungen und Vergleiche Ausdrücke. Auch Zuweisungen an Variablen sind Ausdrücke, da in Java auch die Zuweisung einen Wert ergibt.
Jeder komplexe Ausdruck kombiniert mit Hilfe von Rechenoperatoren, Vergleichsoperatoren oder Zuweisungsoperatoren andere Ausdrücke zu einem neuen
Wert. Es gibt Operatoren, die nur auf einen einzigen Ausdruck operieren, es gibt
aber auch Operatoren, die zwei Ausdrücke zu einem neuen Resultat verbinden.
Es gibt sogar einen Operator, der drei Ausdrücke kombiniert.
Die Anzahl der Ausdrücke, auf die ein Operator angewendet wird, um ein Ergebnis zu liefern, nennt man die Stelligkeit des Operators.
Beispiel: Hier einige Beispiele für 1–stellige Operatoren.
Aus der Mathematik kennen Sie den Fakultät–Operator und den Quadrierungsoperator — es gibt beide nicht in Java, aber da Sie Ihnen vertraut
sind, verwenden wir sie in diesem Beispiel. Beide Operatoren kann an auf
einen einzigen Ausdruck anwenden. Dabei stehen diese Operatoren hinter
dem Ausdruck, auf den sie angewendet werden.
Die folgenden Ausdrücke sind Beispiele für die Verwendung eines einstelligen Operators, der hinter dem Ausdruck steht:
int einInt = 2;
Hingegen ist die folgende Anweisungen kein gültiger Java–Code, da eine
Variable nicht vor ihrer Definition initialisiert werden darf:
{
einInt = 2;
int einInt;
5!, 52 , (1 + 2)!, (1 + 2!)2
Sie kennen außerdem das 1–stellige Minus, welches das Vorzeichen eines
Ausdrucks umdreht. Es steht vor dem Ausdruck, auf das es angewandt
wird — zum Beispiel
−5, −(−3 + 3), −(3 − 2)2
}
Beispiel: Am häufigsten werden 2–stellige Operatoren verwendet.
Da eine Variable vor ihrer Initialisierung einen undefinierten Wert enthält und
da die Verwendung undefinierter Werte normalerweise ein Fehler ist, kontrolliert
der Java–Compiler bei jeder Verwendung einer Variable, ob sie bereits initialisiert sein kann. Falls der Compiler die Verwendung einer nichtinitialisierten
Variable erkennt, meldet er einen Fehler und schützt so den Programmierer vor
der Verwendung undefinierter Werten.
Zweistellige Operatoren kombinieren zwei Ausdrücke zu einem neuen Wert
und stehen normalerweise zwischen den beiden zu verwendenden Ausdrücken.
Hier ein paar Beispiele, in denen nur zweistellige Operatoren auftauchen:
5 − 3, (3 + 2) · (3 + 1), 2 + 3
Beispiel: Der Compiler würde im folgenden Programm erkennen, daß bei
Beachten Sie, daß es zwei Minus–Operatoren gibt: Das 1–stellige Minus,
das den folgenden Ausdruck negiert sowie das 2–stellige Minus, das zwei
Ausdrücke voneinander substrahiert.
der Initialisierung der Variable ergebnis die uninitialisierte Variable wert
verwendet wird. Daher würde er das folgende Programm nicht akzeptieren:
Jeder komplexe Ausdruck mit einem 1–stelligen Operator hat entweder die Form
45
46
Stelligkeit
Ausdruck Operator
Derartige Operatoren nennt man auch “Postfix”–Operatoren,
da sie hinter dem Ausdruck stehen, auf den sie angewandt werden. Beispiele für Einstellige Postfix–Operatoren
sind der Quadrat–Operator oder der Fakultät–Operator.
Operator Ausdruck
Einen Operator, der vor dem Ausdruck steht, auf den er
angewendet wird, nennt man auch “Präfix”–Operatoren.
Beispiele für 1–stellige Präfix–Operatoren sind das 1–
stellige Minus oder der Wurzeloperator.
Ausdrücke mit 2–stelligen Operatoren haben immer die Form
Ausdruck1 Operator Ausdruck2
Da hier der Operator zwischen den Ausdrücken steht, nennt man derartige Operatoren auch “Infix”–Operatoren. Beispiele für zweistellige Infix–Operatoren sind
+, −, ∗, /.
Sie kennen nun Ausdrücke, die aus einem Literal bestehen, Ausdrücke, die aus
einer Variable bestehen und Ausdrücke, in denen einstellige und zweistellige
Operatoren auftauchen. Durch diese Möglichkeiten, Ausdrücke aufzubauen, sind
bereits fast alle erdenklichen Rechnungen in Java formulierbar.
Wir haben die Operator–Ausdrücke nämlich rekursiv, das heißt selbstbezüglich,
definiert. So hat ja ein zweistelliger–Ausdruck die Form
Ausdruck1 Operator Ausdruck2
Die beiden Ausdrücke Ausdruck1 und Ausdruck2 können nun selbst wieder beliebige Ausdrücke sein. Beispielsweise könnte Ausdruck1 ein zweistelliger Operator–
Ausdruck mit einem anderen Operator sein, und Ausdruck2 könnte ein einstelliger Präfix–Ausdruck sein. Wir haben also schon Ausdrücke der Form
Beispiel:
Operator *
Operator −
Präfixopt −
Postfixopt. !
int−Literal 5
Variable a
Variable b
Die Rechnung (−5) ∗ (a! − b) läßt
sich nur auf eine Art als Ausdruck
interpretieren. Die graphische Darstellung der einzig möglichen Interpretation sehen Sie links.
Die obenstehenden Beispiele zeigen, daß man einen Ausdruck manchmal auf
mehrere Arten aus kleineren Ausdrücke zusammensetzen kann. Dabei entspricht
jede Art, den Ausdruck zusammenzusetzen, einer unterschiedlichen Klammerung. Selbstverständlich entspricht nicht jede Art und Weise, den Ausdruck in
kleinere Einheiten aufzubrechen der mathematischen Gewohnheit.
Beispiel: Es macht für die Rechnung zwar keinen Unterschied, ob der
Ausdruck a + 5 + 6 als a + (5 + 6) oder als (a + 5) + 6 interpretiert wird.
Es macht aber sehr wohl einen Unterschied, ob der Ausdruck a ∗ 5 + 6 als
a ∗ (5 + 6) oder als (a ∗ 5) + 6 interpretiert wird. Genauso macht es einen
Unterschied, ob der Ausdruck a − 5 + 6 als a − (5 + 6) oder als (a − 5) + 6
interpretiert wird.
Um jedem Ausdruck einen eindeutigen Wert zuzuteilen, hat man in der Mathematik vereinbart, daß man Ausdrücke von links nach rechts lesen soll — der
Ausdruck a − 5 − 6 wird als (a − 5) − 6 interpretiert. Außerdem hat man Rechenregeln wie Punkt– vor Strichrechnung eingeführt. Es ist in der Mathematik
auch üblich, daß Einstellige Postfixoperatoren zweistelligen Operatoren vorgehen — der Ausdruck a + 5! wird deshalb nicht als (a + 5)! sondern als a + (5!)
interpretiert.
Auch in Java werden die üblichen Rechenregeln beachtet. In Java haben die
einzelnen Operatoren unterschiedliche Bindungskraft. Wenn in einem Ausdruck
ein Operator mit höherer Bindungskraft neben einem mit niedrigerer Bindungskraft steht, so zieht der Operator mit der höheren Bindungskraft die daneben
stehenden Ausdrücke an sich.
(Ausdruck1,1 Operator Ausdruck1,2 ) Operator P ref ix Ausdruck2,1
beschrieben. Analog kann man beliebig komplizierte Rechnungen durch wiederholtes Anwenden der Operator–Ausdruck–Regeln als Ausdruck beschreiben.
Beispiel: Zum Beispiel kann die Rechnung a+5+6 auf zwei verschiedene
Arten als Ausdruck interpretiert werden. Beide Arten der Interpretation
lassen sich durch Graphiken interpretieren lassen, die einem auf den Kopf
gestellten Baum ähneln:
Zum einen ist die Rechnung als
Ausdruck a + (5 + 6) interpretier+
bar, also als Ausdruck, in welchem
+
durch den Plus–Operator der AusVariable a
int−Literal 5
int−Literal 6
druck a und der Ausdruck 5 + 6 addiert werden.
+
+
Variable a
int−Literal 5
int−Literal 6
Alternativ könnte sie als Ausdruck
(a+5)+6 interpretiert werden, also
als Ausdruck in welchem durch den
Plus–Operator der Ausdruck a + 5
und der Ausdruck 6 addiert werden.
47
Beispiel: Beispielsweise hat der Multiplikationsoperator eine höhere Bindungskraft als der Additionsoperator. Daher wird durch Java der Ausdruck a + 5 ∗ 6 nicht als (a + 5) ∗ 6 sondern als a + (5 ∗ 6) interpretiert —
auch in Java geht also die Multiplikation der Addition vor.
Generell gilt, daß Einstellige Operatoren eine höhere Bindungskraft haben als
zweistellige Operatoren.
Beispiel: Das einstellige Minus hat eine höhere Bindungskraft als der
zweistellige Multiplikationsoperator. Daher wird der Ausdruck −2+5 nicht
als −(2 + 5) sondern als (−2) + 5 interpretiert.
Eine Tabelle, in der alle Java–Operatoren nach Bindungskraft geordnet aufgeführt sind, finden Sie in Go To Java in Kapitel 5.8 (Operator–Vorrangregeln).
Es empfiehlt sich, diese Tabelle auszudrucken — Sie werden sie in der 4. Hausaufgabe benötigen. Jeder in der Tabelle stehende Operator hat höhere Bindungskraft als die später in der Tabelle stehenden Operatoren.
Ein Verständnis der Vorrangsregeln ist sehr wichtig — wenn Sie sich allerdings
irgendwann mal nicht sicher sind, wie die Auswertereihenfolge eines Ausdrucks
48
ist, können Sie ganz einfach Klammern verwenden, um die Ausdrücke zusammenzufassen:
Beispiel: Wenn Sie sich nicht sicher sind, ob die Vergleichsoperatoren
höhreren Vorrang als die Logik–Operatoren haben, könnten Sie statt
boolean w = 1 < 2 && 2 < 3 && 4 < 5;
boolean w = (1 < 2) && (2 < 3) && (4 < 5);
Arithmetische Operatoren
Die arithmetischen Operatoren Javas sind in Go To Java 2 in Kapitel 5.2 angeführt. Zu den Operatoren ++ und -- sagen wir gleich mehr, zu den anderen
Operatoren in Kapitel 5.2 gibt es nichts hinzuzufügen außer einem Beispiel:
Beispiel: Verwendung der arithmetischen Operatoren:
01 public class DemoArith {
02
public static void main( String[] args ) {
03
System.out.println( -3 + +5 );
04
System.out.println( 2.0 / 5.0 - 3.0 * 7.1 );
05
System.out.println("7 / 3 = " + 7 / 3 + ", Rest: " + 7 % 3 );
06
System.out.println( 7.2 % 3 );
07
}
08 }
In Zeile 03 wird das einstellige Minus, das (eigentlich überflüssige) einstellige Plus und das zweistellige Minus verwendet.
In Zeile 04 werden der Multiplikations und Divisionsoperator verwendet.
In Zeile 05 werden zwei Integerzahlen dividiert (7/3 == 2). Dabei bleibt
ein Rest von 1 übrig. Auch der Rest der Division wird ausgegeben. Der
“Rest bei ganzzahliger Division”–Operator heißt %.
In Zeile 06 wird demonstriert, daß man den Restwert–Operator in Java
auch auf reelle Zahlen anwenden kann.
7.4.2
int einInt = 5;
++einInt;
so heißt er Präinkrement–Operator
• Steht ++ hinter einer Variable wie in
auch schreiben
7.4.1
• Steht ++ vor einer Variable, wie in
Inkrement und Dekrement–Operatoren
Die üblichen Rechenoperatoren wie +,-,*,/,% bedürfen sicher keiner weiteren
Erläuterung. Hingegen wird auf die Inkrement– und Dekrement–Operatoren von
Java im Text “Go To Java 2” leider nur mangelhaft eingegangen.
Der Operator ++ wird Inkrement–Operator, der Operator -- wird Dekrement–
Operator genannt. Sie unterscheiden sich deutlich von den anderen arithmetischen Operatoren, da sie nicht nur einen Wert berechnen, sondern gleichzeitig
als Nebeneffekt auch eine Variable verändern.
Sie können den Wert einer Variable um eins erhöhen, indem Sie entweder vor
oder hinter die Variable den Operator ++ setzen. Analog können Sie durch Verwendung des Operators -- den Wert einer Variable um eins verminden.
Inkrement– und Dekrement–Operator existieren in jeweils zwei verschiedenen
Versionen: einmal als Präfix– und einmal als Postfix–Operator.
49
double einDouble = 5.321948;
einDouble++;
so heißt er Postinkrement–Operator
• Analog heisst der -- Operator entweder Prädekrement bzw. Postdekrement–
Operator, wenn er vor bzw. hinter einer Variable steht.
Inkrement– und Dekrement–Operatoren verändern den Wert einer Variable,
selbst wenn überhaupt keine Zuweisung verwendet wird. Dabei liefern sie wie
alle Ausdrücke gleichzeitig einen Wert.
Im folgenden reden wir nur noch vom Inkrement–Operator. Für den Dekrement–
Operator gilt alles analog.
Beispiel: Zum Beispiel wird in folgendem Beispiel der Wert der Variable
einInt zweimal erhöht, wobei einmal der Postinkrement- und einmal der
Präinkrement-Operator verwendet wird. Der Wert der Ausdrücke wird
dabei nicht verwendet.
int einInt = 5;
einInt++;
++einInt;
Der Postinkrement–Operator und der Präinkrement–Operator erhöhen beide die
Variable und liefern als Wert den Wert der Variable zurück. Dabei unterscheiden
sie sich dadurch, wann die Variable inkrementiert wird.
Wird der Postinkrement–Operator verwendet, so wird zuerst der Wert der Variable ausgewertet und anschließend die Variable inkrementiert.
Wenn hingegen der Präinkrement–Operator benutzt wird, wird zuerst die Variable inkrementiert und anschließend die nun inkrementierte Variable ausgewertet.
Beispiel: Zum Beispiel hat nach Ausführung des folgenden Programmtextes die Variable wert den Wert 7, da sie zweimal inkrementiert wurde.
public class DemoInc1 {
public static void main( String[] args ) {
int wert = 5;
int ergebnis1 = wert++;
int ergebnis2 = ++wert;
}
}
50
Aber welchen Wert haben ergebnis1 und ergebnis2 ? Entscheidend hierfür
ist, ob zuerst die Zuweisung oder zuerst das Inkrementiern stattfindet.
Nach unserer Beschreibung des Prä– und Postinkrementoperators ist das
obige Programm gleichwertig zu folgendem Programmfragment:
einFurchtbarLangerVariablenName=einFurchtbarLangerVariablenName+1;
Schließlich sei noch erwähnt, daß die Inkrement– und Dekrementoperatoren ausschließlich auf Variablen anwendbar sind. Das sollte eigentlich klar sein, da man
auch nur Variablen einen Wert zuweisen kann.
public class DemoInc2 {
public static void main( String[] args ) {
int wert = 5;
int ergebnis1 = wert;
wert = wert + 1;
// Ausführung des Postinkrementoperators
wert = wert + 1;
// Ausführung des Präinkrementoperators
int ergebnis2 = wert;
}
}
Nach Ausführung des vorigen Beispiels haben also die einzelnen Variablen
folgende Werte:
wert
== 5
ergebnis1 == 5
ergebnis2 == 7
Es sei hier erwähnt, daß Sie die Verwendung der Postinkrement– und Präinkrementoperatoren in komplizierten Ausdrücken vermeiden sollten, da die durch
sie bewirkten Nebeneffekte oft nur schwer zu verstehen sind.
Beispiel: Die folgende Anweisungsfolge ist ungültig:
int a=5;
int b=(a*2)++;
// Fehler: Zwischenergebnisse kann man nicht verändern
Auch die folgende Anweisungsfolge ist ungültig:
int a=5++;
7.4.3
// Fehler: Literale kann man nicht verändern
Relationale Operatoren
Kapitel 5.3 in Go To Java bedarf m.E. keiner weiteren Erklärung — es sei nur
gesagt, daß Sie alles, was mit Referenztypen zu tun hat, noch nicht verstehen
können und auch nicht verstehen müssen.
Relationale Operatoren vergleichen zwei Werte. Ein relationaler Ausdruck hat
immer den Datentyp boolean, liefert als entweder den Wert true oder false
zurück.
Beispiel: Hier ein Beispiel zur Verwendung relationaler Operatoren:
Beispiel: Erkennen Sie zum Beispiel, welche Werte die Variablen im
folgenden Programm erhalten ?
int i1 = 3;
int i2 = 4;
int ergebnis = ++i1 + --i2 +
public class DemoRelational {
public static void main( String[] args )
{
double w1 = 5;
double w2 = 6;
System.out.println( w1 < w2 );
//
System.out.println( w1 == w2 );
//
System.out.println( w1 != w2 );
//
System.out.println( w1 == w2 - 1);
//
System.out.println( w1 * 5 >= w2 - 1);//
}
}
i1-- * --i2;
Ich glaube, einfacher zu verstehen ist die äquivalente Fassung:
int i1 = 3;
int i2 = 4;
i1--;
i2--;
ergebnis = i1 + i2 + i1 * i2;
i1++;
i2--;
7.4.4
Die Verwendung der Dekrement– und Inkrementoperatoren empfiehlt sich, wenn
Sie eine Variable dekrementieren oder inkrementieren möchten. Insbesondere
wenn Ihre Variablennamen lang sind, sparen Sie sich so Schreibarbeit und Fehlerquellen und machen Ihr Programm übersichtlicher.
Beispiel: Ich hoffe, Sie stimmen mir zu, daß der Programmtext
Auch zu Kapitel 5.4 über logischen Operatoren ist nicht viel hinzuzufügen.
Logische Operatoren kombinieren zwei Ausdrücke vom Typ boolean zu einem
neuen Wert des Datentyps boolean. Sie dienen dazu, Wahrheitswerte zu vergleichen und kombinieren.
Beispiel: Hier noch ein Beispiel zur Verwendung der logischen Operatoren:
51
true
false
true
true
true
Logische Operatoren
einFurchtbarLangerVariablenName++;
besser zu lesen ist, als der Programmtext
ergibt
ergibt
ergibt
ergibt
ergibt
public class DemoLogic1 {
public static void main(String[] args)
52
7.4.6
{
System.out.println(
System.out.println(
System.out.println(
System.out.println(
System.out.println(
System.out.println(
true && true );
false & true );
false || true );
false | false );
! false );
! true );
//
//
//
//
//
//
true
false
true
false
true
false
}
}
Beispiel: Noch ein Beispiel zur Verwendung der logischen Operatoren:
public class DemoLogic2 {
public static void main(String[] args)
{
long a = 3;
long b = 4;
boolean w1 = a >= 3 && a < 5;
//
boolean w2 = a == 4 || b == 4;
//
boolean w3 = a >= 3 && ( a==4 || b == 4); //
boolean w4 = !(a == 3);
//
}
}
Zuweisungsoperatoren
Auch Kapitel 5.6 in Go To Java 2 benötigt m.E. kaum weitere Erläuterungen.
Eine Besonderheit von Java ist, daß Zuweisungen einen Wert zurückliefern. Der
Zuweisungsoperator ist in Java ein Operator, der prinzipiell überall dort eingesetzt werden kann, wo Sie auch eine Addition oder Multiplikation durchführen
würden. Nur haben Zuweisungsoperatoren einen Nebeneffekt, nämlich die Zuweisung eines Wertes an eine Variable.
Beispiel: Es ist möglich, mehrere Zuweisungen in einem Befehl durchzuführen. Zum Beispiel wird hier den Variablen a und b der Wert 5 zugewiesen:
int a;
int b = a = 5;
true
true
true
false
Normalerweise sollten Sie die Short–Circuit–Operatoren (siehe Go To Java, Kap.
5.4) verwenden. Problematisch kann das werden, wenn in einem logischen Ausdruck Nebeneffekte (d.h. Veränderungen von Variablen) auftreten.
Beispiel: Hier ein warnendes Beispiel zur Short–Circuit–Evaluation.
public class DemoShortCircuit {
public static void main(String[] args)
{
long a = 3;
System.out.println( a > 4 && a++ < 5 );
System.out.println(a);
}
}
In der Auswertung a > 4 && a++ < 5 wird der Teil hinter der logischen
Und–Verknüpfung nicht ausgeführt, weil das Ergebnis des gesamten Ausdrucks (false) nach Auswertung von a > 4 klar ist (false && irgendwas ist
immer false).
Daher wird aber auch der Postinkrement–Operator nicht ausgeführt. Der
Wert von a ändert sich daher im obigen Beispiel nicht.
Üblicherweise verwendet man immer die Short-Circuit–Operatoren.
Gewöhnen Sie sich daher an, niemals Operatoren mit Nebeneffekten in
logischen Ausdrücken zu verwenden !
Das funktioniert so: Der Compiler erkennt, daß der Variable b der Wert
zugewiesen wird, der rechts vom ersten Gleichheitszeichen steht. Zunächst
wird der Ausdruck daher als
int b = (a = 5);
interpretiert. Dann wertet Java den Ausdruck (a = 5) aus, weist dabei
der Variable a den Wert 5 zu und liefert als Ergebnis des Ausdrucks a = 5
den Wert 5. Dieser wird dann der Variablen b zugewiesen.
Sie können innerhalb jeder Rechnung Zuweisungen vornehmen. Achten Sie dabei
darauf, daß Ihre Programme lesbar bleiben.
Beispiel: Finden Sie den folgenden Programmtext übersichtlich ?
int a;
int b;
int c = 5 * (b = 6 - (a = 5) * 20);
Nur, weil diese Anweisungen erlaubt sind, sollten Sie sie nicht verwenden.
Übersichtlicher hätte man dieses Programmfragment schreiben können als
int a = 5;
int b = 6 - a * 20;
int c = 5 * b;
Sehr hilfreich sind die Zuweisungsoperatoren, die bei der Zuweisung noch rechnen.
Beispiel: Zum Beispiel kann man statt
einRelativLangerVariablenName=einRelativLangerVariablenName+5;
7.4.5
Bitweise Operatoren
auch schreiben
Kapitel 5.5 in Go To Java 2 bedarf m.E. keiner weiteren Erläuterung, wenn Sie
sich mit Binärzahlen auskennen.
53
einRelativLangerVariablenName += 5;
54
Die zweite Schreibweise ist besser lesbar und weniger fehleranfällig. Analog
können Sie die Operatoren *=,-=,/= und die übrigen Zuweisungsoperatoren verwenden.
Auch die rechnenden Zuweisungsoperatoren können — genau wie die Inkrement–
, Dekrement– und Zuweisungsoperatoren in jedem Ausdruck verwendet werden.
7.5
Zusammenfassung
Sie müssten nun die folgenden Fragen beantworten können:
B Was ist ein Ausdruck ?
B Welches sind die relevanten Eigenschaften eines Ausdrucks ?
B Was für Arten von Ausdrücken kennen Sie ?
Beispiel: Zum Beispiel:
B Was ist ein Literal ?
int a = 5;
int b = 3;
int c = 6 * (a += 5) - (b *= 2);
B Welche ganzzahligen Literale kennen Sie ?
B Welchen Wert hat das Zahlenliteral 020 ?
B Welchen Wert hat das Zahlenliteral 0x10 ?
Auch hier gilt: Achten Sie primär auf gute Lesbarkeit Ihres Programms
und nicht auf ausgefallene oder trickreiche Verwendung dieser Operatoren.
7.4.7
B Wie kann man ein ganzzahliges long-Literal erzeugen ?
B Wie ist ein reellwertiges Literale aufgebaut ?
Beispiel: Hier noch ein Beispiel, in welchem Zuweisungsoperatoren miß-
B Wie kann man ein float–Literal erzeugen ?
braucht werden. Dies ist gültiger Java–Code, aber wer derartigen Code
verwendet, disqualifiziert sich als übler Hacker:
B Welche boolschen Literale gibt es ?
int a = 5;
int b = 3;
int c = 6 * (b += (a -= ((a += 5) - (b *= 2))));
B Beschreiben Sie die Regeln für Zeichenketten–Literale !
B Wie muß ein Zeichenliteral aussehen ?
B Was versteht man unter der Initialisierung einer Variable ?
B Warum müssen Variablen vor ihrer Verwendung initialisiert werden ?
B Was ist ein Operator ?
Weitere Operatoren
B Was ist die Stelligkeit eines Operators ?
Zu Kapitel 5.7 von Go To Java: Die Type–Cast–Operatoren hatten wir bereits
im vorigen Kapitel besprochen. Die Ausführungen zu Strings sollten Sie überfliegen. Die Ausführungen zu Referenzgleichheit und zu den anderen Operatoren
brauchen Sie noch nicht zu verstehen.
B Geben Sie Beispiele für 1–stellige und 2–stellige Operatoren !
B Gibt es in Java 3–stellige Operatoren ?
B Was versteht man unter Nebeneffekten ?
B Was sind Operator–Vorrangregeln ?
B Was verstehen wir unter der “Bindungskraft” eines Operators ?
B Warum sind Operatorvorrangregeln wichtig ?
B Was sind Inkrement– und Dekrement–Operatoren ?
B Wie unterscheiden sich Postinkrement– und Präinkrement–Operator ?
B In welchen Fällen sollte man die Inkrement– und Dekrement–
Operatoren vermeiden bzw. verwenden ?
B Welche relationalen Operatoren kennen Sie ?
B Welche Datentypen sind bei der Verwendung relationaler Operatoren
möglich ?
B Welche Gefahren bestehen bei Verwendung von Short–Circuit Logik–
Operatoren ?
B Welche Zuweisungsoperatoren gibt es in Java ?
B Warum kann man in Java in einem Befehl mehrere Variablenzuweisungen vornehmen ?
55
56
8
Typwandlungen
Hier geben wir Ihnen weitere Informationen zu Goto Java 2, die Sie ergänzend
zu Hausaufgabe 3 lesen sollten.
Sie sollten für die weiteren Ausführungen zunächst in Go To Java Kapitel 4.6
über “Typkonvertierunen” lesen. Dort wird besprochen, welche Typkonvertierungen der Java–Compiler automatisch vornehmen kann — leider werden keine
Beispiele für Typkonvertierungen gebracht, und es wird auch nicht erwähnt,
warum Typkonvertierungen wichtig sind.
Normalerweise enthalten Prozessoren keine Funktionen, die gleichzeitig mit verschiedenen Datentypen rechnen können. Will man also mit zwei Werten verschiedener Datentypen miteinander verrechnen, müssen erst beide Datentypen
in einen gemeinsamen Datentyp konvertiert werden. Danach kann die Rechnung
in diesem Datentyp stattfinden.
Beispiel: Prozessoren sind meist nicht dazu in der Lage, einen IntegerWert und einen Float oder einen Float und einen Double zu addieren.
Wenn Sie die Rechnung
i1 + f1;
8.1
Automatische Typkonvertierungen
Im vorigen Kapitel haben Sie gelernt, daß jeder Ausdruck in einem Java–Programm
einen Datentyp hat. Manchmal ist es notwendig, einen Ausdruck eines gewissen Datentyps in einen anderen Datentyp umzuwandeln. Teilweise werden diese
Umwandlungen durch den Java–Compiler automatisch vorgenommen, teilweise
muß man sie explizit befehlen.
Warum Typwandlungen überhaupt nötig sind, soll an einem Beispiel demonstriert werden. Es seien die folgenden Variablen definiert:
durchführen wollen, muß sie also vorher noch aufbereitet werden. Der
Prozessor kann entweder zwei Integer oder zwei Float addieren. Es bieten
sich daher zwei Möglichkeiten an, um die Rechnung mit den Funktionen
des Prozessors durchzuführen:
• Wandlung der Float-Variable zu einem Integer und Durchführung
der Addition als Integer-Addition:
i1 + (int)f1;
Dabei bedeutet der Ausdruck (int)f1: Wandele f1 in einen Integer–
Wert um. In der Regel geschieht eine solche Umwandlung durch
Wegwerfen aller Nachkommastellen.
Mit den oben angegebenen Werten würde diese Rechnung wie folgt
ausgeführt:
i1 + (int)f1 == 5 + (int)3.123 == 5 + 3 == 8
int i1 = 5;
int i2 = 3;
float f1 = 3.123f;
float f2 = 2.723f;
double d1 = 3.1234567890123456;
Jede Rechnung mit diesen verschiedenen Variablen muß irgendwie vom Prozessor ausgeführt werden. Besprechen wir das an den Beispielen der Addition und
der Multiplikation.
Übliche Prozessoren enthalten Funktionen, mit denen zwei Integer addiert oder
multipliziert werden können. Sie haben auch Funktionen, mit denen zwei Float
oder zwei sonstige Datentypen addiert oder multipliziert werden können. Das
Ergebnis dieser Funktionen hat dann normalerweise den gleichen Datentyp wie
die Operanden der Rechnung.
Beispiel: Wenn Sie mit zwei int–Variablen rechnen, kann der Prozessor
die Rechnung direkt vornehmen. Das Ergebnis ist dann immer wieder ein
Integer (überlegen Sie sich, warum das Ergebnis der Division nicht der
Erwartung entspricht !)
i1 + i2; // Ergebnis: int, 8
i1 / i2; // Ergebnis: int, 1
i1 * i2; // Ergebnis: int, 25
Genauso ist das Ergebnis beim Rechnen mit float–Variablen immer wieder ein Float:
f1 + f2; // Ergebnis: float, 5.846
f1 / f2; // Ergebnis: float, 1.1468968...
f1 * f2; // Erbebnis: float, 8.503929
57
• Wandlung des Integers zu einem Float und Durchführung der Addition als Float–Addition:
(float)i1 + f1;
Hier bedeutet der Ausdruck (float)i1: Wandle den Integer i1 in
einen Float–Wert um. Dies geschieht ohne Verlust von Information.
Mit den oben angegebenen Werten würde diese Rechnung so ausgeführt:
(float)i1 + f1 == (float)5 + 3.123 == 5.0 + 3.123 == 8.123
Die Antwort, welche der beiden Möglichkeiten gewählt wird, fällt leicht:
Wenn wir den Float–Wert zu einem Integer wandeln, verschenken wir
Rechengenauigkeit und kommen zu falschen Ergebnissen. Wenn wir den
Integer hingegen in einen Float wandeln, erhalten wir das erwartete Ergebnis.
Bei Typwandlungen, die der Compiler automatisch vornimmt, wird immer darauf geachtet, keine Genauigkeit zu zerstören. Datentypen werden in Rechnungen
darum nur zu genaueren Datentypen umgewandelt.
Abbildung 4.1 im Kapitel 4.6 von “Go To Java 2” zeigt genau dies — ein short,
der ja nur die ganzen Zahlen von −21 5 bis 21 5 − 1 darstellen kann, kann automatisch in die umfangreicheren Datentypen int, long oder float umgewandelt
werden. Hingegen wird der Datentyp double niemals automatisch in einen anderen Datentyp gewandelt, da dies der genaueste und umfangreichste Datentyp
der Sprache Java ist.
58
Typkonvertierungen treten immer auf, wenn ein Ausdruck eines gewissen Typs
erwartet wird, aber ein anderer Typ vorliegt. Es kommt des öfteren vor, daß in einem Ausdruck ein niedriger Genauigkeit benötigt wird, der zu benutzende Wert
aber eine hohe Genauigkeit hat. In solch einem Fall würde eine Typwandlung
Genauigkeit verschenken. Der Java–Compiler würde daher statt eine automatische Typwandlung vorzunehmen, das Programm als fehlerhaft bemäkeln.
Ein gutes Beispiel für Fälle, in denen eine Typkonvertierung zu ungenaueren Typen nötig ist, bieten die Zuweisungsoperatoren. Der einer Variable zugewiesene
Wert muß ja immer den Datentyp der Variable haben. Wird nun einer Variable
eines “ungenauen” Datentyps ein Wert eines genaueren Datentyps zugewiesen,
so erzeugt das einen Kompilationsfehler.
Beispiel: Zum Beispiel sind folgende Anweisungen erlaubt, da eine
Wandlung zu einem genaueren Typ stattfindet:
f1 = i1;
d1 = i1;
d1 = f1;
// bei Zuweisung: autom. Wandlung i1 zu float
// bei Zuweisung: autom. Wandlung i1 zu double
// bei Zuweisung: autom. Wandlung f1 zu double
Alle oben genannten Zuweisungen sind erlaubt, da hier bei den automatischen Typwandlungen keine Genauigkeit verlorengeht.
Hingegen sind die folgenden Anweisungen nicht erlaubt:
i1 = f1;
i1 = d1;
f1 = d1;
// verboten, da float genauer als int
// verboten, da double genauer als int
// verboten, da double genauer als float
8.2
Manuelle Typkonvertierungen
Oft will man trotzdem Werte höherer Genauigkeit an Stellen verwenden, an
denen eine niedrigere Genauigkeit benötigt wird. Wieder ist die Zuweisung eines
Wertes an eine Variable das beste Beispiel für derartige Fälle.
Wenn wir beispielsweise wissen, daß in einer float–Variable ein Wert ohne Nachkommastellen enthalten ist, sollten wir in der Lage sein, diesen als Integer aufzufassen.
Oftmals brauchen wir die höhere Genauigkeit auch nicht wirklich. Es ist zum
Beispiel üblich, die Zwischenschritte einer Rechnung in einer hohen Genauigkeit
durchzuführen und dann das Endergebnis der Rechnung nur in einer niedrigen
Genauigkeit zu verwenden.
Java nimmt ohne unser Zutun solche Typwandlungen nicht vor. Wir können
Java aber befehlen, eine Typwandlung vorzunehmen. Wir verwenden dazu einen
Typwandlungsoperator und signalisieren Java damit: An dieser Stelle ist es in
Ordnung, Genauigkeit zu verschenken, wir wissen schon was wir tun.
Definition: Type–cast
Eine manuelle Typwandlung nennt man type–cast.
Um einen Wert explizit in anderen Datentyp zu wandeln, schreibt man den
Datentyp, zu dem der Wert gewandelt werden soll, in runde Klammern und den
Wert dahinter:
(datentyp) wert
In jedem dieser Fälle würde Genauigkeit verlorengehen, und darum würde
der Compiler mit einer Fehlermeldung gegen jede der Anweisungen protestieren. Die Fehlermeldung könnte wie folgt aussehen:
Dies ist die Anweisung an den Compiler eine Typwandlung vorzunehmen.
Beispiel: Folgende Zuweisungen sind erlaubt, obwohl bei der Wandlung
Programmname.java:11: Incompatible type for =. Explicit cast
needed to convert float to int.
i1 = f1;
Beispiel: Sehr häufig kommen derartige Fehlermeldungen in Programmen vor, in denen man Float–Variablen einen Wert zuweist. Sie haben ja
im vorigen Kapitel gelernt, daß reellwertige Zahlenliterale den Datentyp
double erhalten, wenn sie nicht das Anhängsel “f” haben. Die Zuweisung
eines double–Literals an eine float–Variable bedingt einen Genauigkeitsverlust und führt daher zu einem Compiler–Fehler:
01
02
03
04
05
06
07
08
09
10
11
12
int
i;
i = 1;
i = 1L;
i = 3.141;
float f;
f = 1;
f = 3.141f;
f = 3.141;
double d;
d = 1l;
d = 3.141f;
d = 3.141;
// erlaubt: Zuweisung int-Literal an int
// Fehler: long-Literal, aber int erwartet
// Fehler: Zuweisung double-Literal an int
// erlaubt: Zuweisung int-Literal an float
// erlaubt: Zuweisung float-Literal an float
// Fehler: double-Literal, doch float nötig
// erlaubt: Zuweisung long-Literal an float;
// erlaubt: Zuweisung float-Literal an double
// erlaubt: Zuweisung double-Literal an double
59
Genauigkeit verloren geht:
i1 = (int)f1;
i2 = (int)d1;
f1 = (float)d1;
Mit den oben definierten Werten für die einzelnen Variablen ergeben sich
hier die folgenden Werte für i1 bis f1:
i1 == (int)f1 == (int)3.123 == 3
i2 == (int)d1 == (int)3.1982 == 3
f1 == (float)d1 == (float)3.1234567890123456 == 3.1234567
Ein Wert niedrigerer Genauigkeit ergibt sich dabei meist aus einem Wert
höherer Genauigkeit durch wegwerfen von Nachkommastellen.
Sie können bei jedem Ausdruck eine Typwandlung vornehmen. Sie dürfen Typwandlungen auch an Stellen vornehmen, an denen sie überflüssig sind.
Beispiel: Die folgenden Type–Casts sind zwar erlaubt aber überflüssig,
da Java hier einen automatischen Type–Cast vornehmen würde¿
60
Type–cast
9
f1 = (float)i1;
d1 = (double)f1;
Allerdings sind Typwandlungen nur dort gestattet, wo sie Sinn machen.
Beispiel: Beispielsweise kann man Zahlen nur untereinander umwandeln,
wobei der Datentyp char auch als Zahl zählt. Folgender Programmtext
führt zu einem Fehler:
int i1 = (int)"Ein Text"; // Fehler
Eine wichtige Besonderheit ist bei Typwandlungen noch zu erwähnen: Die einzelnen primitiven Datentypen sind nicht nur unterschiedlich genau. Auch der
Wertebereich unterscheidet sich. Auf diese Problematik wollen wir hier aber
nicht weiter eingehen — hier nur ein Beispiel dazu:
Beispiel: Wenn Sie einen zu großen Double–Wert in einen Float wandeln,
wird der Wert als Infinity dargestellt:
double d = 1.23e300; // ist nicht als float darstellbar
float f = (float) d; // jetzt enthält f den Wert Infinity
8.3
Anweisungen und Kontrollstrukturen
Hier beziehen wir uns auf Kapitel 6 von Go To Java 2.
Die Steuerung des Programmablaufs geschieht durch sogenannte Anweisungen.
Jede Anweisung bewirkt irgendwelche Aktionen des Prozessors. Einige Anweisungen haben Sie bereits kennengelernt, so ist z.B. die Verwendung der Ausgaberoutine eine Anweisung. Auch die Definition von Variablen oder die Verwendung
von Ausdrücken sind Anweisungen.
Jede Anweisung in einem Java–Programm muß mit einem Semikolon enden. Dies
ist nötig, da Zeilenumbrüche für den Java–Compiler keine Bedeutung haben und
er daher nicht anhand der Zeilenstruktur erkennen kann, wo eine Anweisung
zuende ist.
9.1
Leere Anweisung
Siehe auch Kapitel 6.1 in Go To Java.
Die einfachste Anweisung in einem Java–Programm ist die leere Anweisung.
Sie hat keine Wirkung. Daß die leere Anweisung erlaubt ist, bedeutet im wesentlichen, daß Sie beliebig viele Semikoli setzen dürfen — auch dort, wo nicht
unbedingt eines stehen muß.
Beispiel:
Zusammenfassung
public class DemoEmpty {
public static void main( String[] args )
{
; // Leere Anweisung
;; // Zwei leere Anweisungen
}
}
Sie müssten nun die folgenden Fragen beantworten können:
B Warum sind Typkonvertierungen nötig ?
B Welche Arten von Typkonvertierungen führt Java automatisch durch ?
B Geben Sie einige Beispiele, in denen Typkonvertierungen automatisch
durchgeführt werden !
B Warum führt Java manche Typkonvertierungen nicht automatisch
durch ?
9.2
B Geben Sie einige Beispiele, in denen statt einer automatischen Typkonvertierung ein Fehler ausgegeben wird !
Der Block gruppiert eine Gruppe von Anweisungen zu einer Einheit. Sie hat die
Form
B Wie kann man Java dazu zwingen, einen Wert in einen anderen Typ
zu wandeln ?
{
Blockanweisung
Anweisung1;
Anweisung2;
...
B Nennen Sie einige Beispiele für überflüssige Typwandlungen !
}
Sie sollten sich angewöhnen, den Inhalt eines Blockes durch Einrückung der im
Block enthaltenen Zeilen optisch kenntlich zu machen — in allen Beispielprogrammen machen wir Ihnen das auch so vor.
Beachten Sie, daß die Beschreibung der Blockanweisung rekursiv ist — der Block
ist eine Anweisung und in einem Block dürfen wieder Anweisungen stehen. Daher darf in einem Block auch ein weiterer Block enthalten sein.
61
62
Beispiel: Dies ist ein gültiges Java–Programm. Im Klassenkörper ist die
}
Methode main enthalten. In deren Methodenkörper sind zwei ineinander
verschachtelte Blöcke enthalten.
}
}
{ // Block A
String i1 = "Hallo, Welt";
}
System.out.println(i1); // Fehler !
Der Klassenkörper wird auch durch geschweifte Klammern abgegrenzt,
sieht also genauso aus wie ein Blöcke aus. Er ist aber dennoch kein Anweisungsblock, da er keine Anweisungen sondern nur Definitionen enthalten
darf.
public class DemoBlock { // hier startet der Klassenkörper
public static void main( String[] args )
{ // hier startet der Methodenkörper
; // Leere Anweisung
{ // hier startet Block 1
{ // und hier startet Block 2
System.out.println("Hallo, Welt !");
} // hier endet Block 2
} // hier endet Block 1
} // hier endet der Methodenkörper
} // hier endet der Klassenkörper
9.3
}
}
Sie dürfen in einem Block keine Variable zweimal definieren.
Beispiel: Das folgende Programm ist fehlerhaft, da die Variable i1 im
gleichen Block zweimal definiert wird:
public class DemoBlock2 {
public static void main( String[] args )
{
int i = 1;
double i = 3.5; //Fehler
}
}
Variablendefinitionen
Variablendefinitionen haben wir schon oft benutzt. Sie wissen bereits, daß man
Variablen nur verwenden kann, nachdem man sie definiert hat.
Zu beachten ist, daß eine Variablen Variablendefinition immer nur für den Block
gilt, in welchem sie definiert wurde. Sobald die Programmausführung einen
Block verläßt, haben die in diesem Block definierten Variablen keine Bedeutung
mehr. Man sagt auch: Variablendefinitionen gelten nur lokal im enthaltenden Block.
Wenn in einem Block ein weiterer Block enthalten ist, erbt dieser alle Variablendefinitionen des äußeren Blockes:
Leider dürfen sich in Java Variablen nicht gegenseitig verdecken — sie dürfen
Variablen auch dann nicht in einem Block definieren, wenn sie zuvor nur in
einem diesen Block umschließenden Block definiert wurden.
Beispiel: Im folgenden Beispiel wird in Block 1 eine int–Variable definiert. Block 2 erbt diese Definition, da er in Block 1 enthalten ist. Daher
darf in Block 2 i nicht nochmal definiert werden.
public class DemoBlock3 {
public static void main( String[] args )
{ // Block 1
int i = 1;
{ // Block 2
int i = -5; // Fehler
}
}
}
Beispiel: Im folgenden Beispiel wird im Block 2 die Variable i1 definiert
und initialisiert. Da Block 3 und Block 4 in Block 2 enthalten sind, kann
i1 auch aus Block 3 und 4 verwendet werden.
Auch in Block A wird die Variable i1 definiert. Diese Variable i1 hat
gar nichts mit der Variable i1 in Block 2 zu tun, da sie außerhalb Block
2 definiert wurde. Die Variablendefinitionen von Block 2 und Block A
beeinträchtigen sich überhaupt nicht gegenseitig.
In Block 1 ist die Variable i1 nicht bekannt, da sie weder in Block 1 noch in
einem Block 1 umschließenden Block definiert wurde. Die Verwendung der
Variable i1 in Block 1 führt daher zu einer Fehlermeldung des Compilers.
public class DemoBlock1 {
public static void main( String[] args )
{ // Block 1
{ // Block 2
int i1 = 5;
{ // Block 3
{ // Block 4
System.out.println(i1);
63
9.4
Ausdrucksanweisungen
Zu den Ausführungen über Ausdrucksanweisunge in Kapitel 6.1 von Go To Java
2 braucht nichts hinzuzugefügt zu werden außer einem Beispiel:
Beispiel: Hier ein Beispiel mit verschiedenen Ausdrucksanweisungen.
01 public class DemoVar1 {
02 public static void main( String[] args )
03 {
04
System.out.println("Hallo, Welt !");
64
05
06
07
08
09 }
10 }
int i = 5;
i = 6;
i++;
5 + 2;
// Variablendefinition und Initialisierung
// Ausdrucksanweisung: Zuweisung
// Ausdrucksanweisung: Inkrement
//
int temperatur = 30;
if ( temperatur > 22 ) {
System.out.println("Boah, ganz schön warm");
System.out.println("Stell doch mal einer die Klimaanlage an");
} else {
System.out.println("Schön --- zu heiß ist es nicht.");
}
}
In der Ausdrucksanweisung in Zeile 08 wird eine Addition durchgeführt.
Die Ausdrucksanweisung hat aber keine weitere Wirkung, da der Wert des
Ausdrucks weder ausgegeben noch sonstwie verwendet wird.
Die Ausdrücke in Zeile 06 und 07 haben dagegen eine Wirkung (nämlich
jeweils eine Veränderung der Variable i), da in ihnen Operatoren mit Nebeneffekten verwendet werden.
9.5
}
Das in Go To Java erwähnte Dangling else (“hängendes Else”) bedarf noch einer
weiteren Diskussion: Sie sollten Dangling else—Strukturen immer vermeiden.
Verwenden Sie in Fällen, wo ein Dangling else auftritt, immer Blöcke !
Beispiel: Hier tritt ein Dangling else auf — aufgrund der suggestiven
If–Anweisung
Einrückung ist nicht auf den ersten Blick klar, daß die else–Anweisung
nicht zur ersten sondern zur zweiten if –Anweisung gehört. Das Programm
arbeitet daher nicht so, wie gewünscht.
Kapitel 6.2 von Go To Java 2 sollte so verständlich sein. Nur fehlen mal wieder
Beispiele.
Sie sehen ja in Go To Java 2, daß eine if –Anweisung in zwei Versionen auftreten
kann. Einmal mit und einmal ohne else–Zweig. Beachten Sie bei der Besprechung
aller weiteren Anweisungen, daß eine Anweisung auch ein Block sein kann.
public class DemoDangling1 {
public static void main( String[] args )
{
int temperatur = 30;
boolean istKlimaanlageAn = true;
if ( temperatur < 15 ) // if-Anweisung 1
if ( istKlimaanlageAn ) // if-Anweisung 2
System.out.println("Klimaanlage abstellen");
else
System.out.println("Schön --- zu kalt ist es nicht.");
}
}
Beispiel: Hier ein Beispiel zu if
public class DemoIf1 {
public static void main( String[] args )
{
int temperatur = 30;
if ( temperatur > 25 )
System.out.println("Boah, ganz schön warm");
}
}
Das Problem kann durch Verwendung von Blöcken behoben werden. Sie
sollten sich angewöhnen, in solchen leicht mißverständlichen Situationen
immer Blöcke zu verwenden !
Beispiel: Hier ein Beispiel, bei welchem die Anweisung ein Block ist:
public class DemoIf2 {
public static void main( String[] args )
{
int temperatur = 30;
if ( temperatur > 25 ) {
System.out.println("Boah, ganz schön warm");
System.out.println("Stell doch mal einer die Klimaanlage an");
}
}
}
public class DemoDangling2 {
public static void main( String[] args )
{
int temperatur = 30;
boolean istKlimaanlageAn = true;
if ( temperatur < 15 ) {
if ( istKlimaanlageAn )
System.out.println("Klimaanlage abstellen");
} else
System.out.println("Schön --- zu kalt ist es nicht.");
}
}
Beispiel: Und hier noch ein Beispiel, in dem es auch einen else–Zweig
gibt:
public class DemoIfElse {
public static void main( String[] args )
{
65
9.6
Switch–Anweisung
Die Switch–Anweisung ist in Go To Java in Kapitel 6.2.2 beschrieben.
66
Zur switch–Anweisung ist hinzuzufügen, daß hinter jedem case eine Reihe von
Anweisungen steht. Wird ein case angesprungen, so werden auch die darauf
folgenden case–Blöcke abgearbeitet, wenn kein break in den Anweisungen steht.
Beispiel: Das folgende Programm gibt die textliche Darstellung einer
Zahl aus. Dastut es einmal mit einer Folge von if –Anweisungen und einmal
mit einer gleichwertigen switch–Anweisung.
Tippen Sie das Programm ab und testen Sie, was passiert, wenn Sie einige
break–Anweisungen entfernen !
public class DemoSwitch {
public static void main( String[] args )
{
int zahl = 1;
if ( zahl == 1) {
System.out.println("Eins");
} else if (zahl == 2) {
System.out.println("Zwei");
} else if ( zahl == 3) {
System.out.println("Drei");
} else if (zahl == 4) {
System.out.println("Vier");
} else {
System.out.println("Diese Zahl kenne ich nicht");
}
// Äquivalente Lösung per switch:
switch(zahl) {
case 1:
System.out.println("Eins");
break;
case 2:
System.out.println("Zwei");
break;
case 3:
System.out.println("Drei");
break;
case 4:
System.out.println("Vier");
break;
default:
System.out.println("Diese Zahl kenne ich nicht-");
break;
}
}
}
9.7
Schleifen
Zu Kapitel 6.3 ist nicht viel hinzuzufügen außer einigen Beispielen.
9.7.1
Der Anweisungsblock einer while–Anweisung wird immer wieder abgearbeitet,
während die Schleifenbedingung erfüllt ist.
Im Detail wird eine while–Anweisung wie folgt abgearbeitet: Zunächst wird die
Schleifenbedingung ausgewertet, welche ein boolscher Ausdruck sein muß. Falls
sich hier der Wert false ergibt, so wird mit der nächsten Anweisung hinter der
while–Schleife weitergemacht.
Falls sich hingegen für die Schleifenbedingung der Wert true ergibt, so wird
die Schleifenanweisung durchgeführt. Beachten Sie, daß diese Anweisung auch
ein Block sein darf. Nachdem die Schleifenanweisung abgearbeitet ist, wird die
Schleifenbedingung erneut geprüft, wenn sich hier wieder der Wert true ergibt,
wird die Schleifenanweisung erneut ausgeführt. Dies geschieht wieder und wieder, bis die Schleifenbedingung den Wert false ergibt.
Beispiel: Die Anweisung in Zeile 05 wird niemals ausgeführt, da die
Schleifenbedingung in Zeile 04 immer false ist.
01 public class DemoWhile1 {
02 public static void main( String[] args )
03 {
04
while( false )
05
System.out.println("Hallo, Welt");
06 }
07 }
Beispiel: Eine Schleife, die immer wieder ausgeführt wird und niemals
wieder verlassen wird, nennt man Endlosschleife. Das folgende Programm ist eine solche, da die Bedingung in Zeile 04 immer true ist.
Dieses Programm beendet sich nie, nachdem Sie es gestartet haben. Es
gibt wieder und wieder “Hallo, Welt” aus. Sie können es auf die harte
Tour unterbrechen, indem Sie die Tastenkombination Ctrl+c bzw. Strg+c
verwenden.
01 public class DemoWhile2 {
02 public static void main( String[] args )
03 {
04
while( true )
05
System.out.println("Hallo, Welt");
06 }
07 }
Beispiel: Das folgende Programm gibt die Zahlen von 1 bis 10 auf den
Bildschirm aus. Es verwendet dazu eine Zählervariable. Es demonstriert
außerdem, daß die Schleifenanweisung auch ein Block sein kann.
Die While–Schleife
Die While–Schleife können Sie immer dann einsetzen, wenn Sie eine oder mehrere Anweisungen immer wieder ausführen wollen, solange eine gewisse Bedingung
erfüllt ist.
Sie hat die Form
while( Schleifenbedingung )
anweisung;
67
01 public class DemoWhile3 {
02 public static void main( String[] args )
03 {
04
int i = 1;
04
while( i <= 10 ) {
05
System.out.println(i);
06
i++;
07
}
07 }
08 }
68
Man könnte das obige Programm auch noch kompakter schreiben, indem
man den Inkrement–Operator in den Ausgabe–Befehl schreibt:
05
06
07 }
08 }
01 public class DemoWhile4 {
02 public static void main( String[] args )
03 {
04
int i = 1;
04
while( i <= 10 )
05
System.out.println(i++);
06 }
07 }
Beispiel: Im folgenden Programm wird der Schleifenkörper immer wieder einmal durchlaufen und dabei “Hallo, Welt” ausgegeben, da Schleifenbedingung immer true ist. Das Programm unterscheidet sich im Resultat
nicht von der vorhin besprochenen while–Endlosschleife.
01 public class DemoDo2 {
02 public static void main( String[] args )
03 {
04
do
05
System.out.println("Hallo, Welt");
06
while( true );
07 }
08 }
Eine weitere Variante des vorigen Programmes ist lehrreich. Wir können
die Variable i auch innerhalb der Schleifenbedingung inkrementieren. Dabei müssen wir aber darauf achten, daß die Schleifenbedingung schon vorm
ersten Durchlauf der Schleife einmal ausgeführt wird.
Auch das folgende Programm gibt die Zahlen 1 bis 10 aus. Machen Sie sich
das klar ! Achten Sie vor allem darauf, daß nun in der Schleifenbedingung
ein echtes kleiner und nicht ein kleiner–gleich–Zeichen steht.
Beispiel: Das folgende Programm gibt die Zahlen von 1 bis 10 aus.
Beachten Sie den feinen Unterschied zum äquivalenten Programm mit
while–Schleife (class DemoWhile4) aus dem vorigen Abschnitt. Machen
Sie sich klar, warum hier nicht mit i=0 sondern mit i=1 begonnen wird.
01 public class DemoWhile4 {
02 public static void main( String[] args )
03 {
04
int i = 0;
04
while( i++ < 10 )
05
System.out.println(i);
06 }
07 }
9.7.2
System.out.println("Hallo, Welt");
while( false );
01 public class DemoWhile4 {
02 public static void main( String[] args )
03 {
04
int i = 1;
04
do {
05
System.out.println(i);
06
} while ( i++ < 10 );
07 }
07 }
Die Do–Schleife
Die do–Schleife arbeitet so ähnlich wie die while–Schleife. Sie hat die Form
Man kann while– in do–Schleife ineinander umschreiben. Eine do–Schleife der
Form
do
anweisung;
while ( Schleifenbedingung );
do
Sie unterscheidet sich von der while–Schleife dadurch, daß der Schleifenkörper
in jedem Fall mindestens einmal durchlaufen wird.
Genau wie bei der while–Schleife wird nach jedem Durchlauf des Schleifenkörpers
die Schleifenbedingung geprüft. Immer wenn die Bedingung true ergibt, wird die
Schleife erneut durchlaufen.
anweisung;
while( Schleifenbedingung );
kann als while–Schleife äquivalent so geschrieben werden:
Beispiel: Im folgenden Programm wird der Schleifenkörper genau einmal
anweisung;
while ( Schleifenbedingung )
anweisung;
durchlaufen und dabei “Hallo, Welt” ausgegeben. Da die Schleifenbedingung immer false ist, wird die Schleife danach nicht weiter ausgeführt.
Eine while–Schleife der Form
01 public class DemoDo1 {
02 public static void main( String[] args )
03 {
04
do
69
while ( Schleifenbedingung )
anweisung;
kann als äquivalente do–Schleife so geschrieben werden:
70
if ( Schleifenbedingung ) {
do
anweisung;
while( Schleifenbedingung);
}
for(int i=0 ; i < 10; i++)
System.out.println(i);
9.7.3
for(int i=0 ; i < 10; i++)
System.out.println(i);
for(double i=0.5 ; i < 10.5; i++)
System.out.println(i);
Eine so definierte Variable ist nur innerhalb der for–Anweisung gültig.
Daher ist der folgende Programmtext gültiger Java–Code:
Die For–Schleife
Die For–Schleife ist die wohl am häufigsten verwendete Schleife. Während die
while– und do–Schleife meist dann eingesetzt werden, wenn man beim Beginn
der Schleifenabarbeitung noch nicht genau sagen kann, wie oft die Schleife durchlaufen werden soll, setzt man die for–Schleife meist dann ein, wenn man schon
vor Beginn der Schleife weiß, wie oft die Schleife durchlaufen werden soll. Meist
wird die for–Schleife dazu eingesetzt, eine Variable einen gewissen Wertebereich
durchlaufen zu lassen.
Sie hat die Form
for (init; test; update)
anweisung;
In den runden Klammern hinter dem for–Befehl werden drei durch Semikoli
getrennte Ausdrücke erwartet.
Wie eine for–Schleife arbeitet, wird am besten klar, indem wir sie in eine äquivalente while–Schleife umschreiben. Die for–Schleife kann man als Abkürzung
für die folgende Schleife interpretieren:
• “init” darf leer sein:
for( ; false; ) ;
Der zweite Ausdruck (test–Ausdruck) muß boolschen Datentyp haben. Er wird
ausgewertet, um zu prüfen, ob die Schleife durchlaufen werden soll. Während
der test–Ausdruck true ergibt, wird die Schleifenanweisung immer wieder ausgeführt.
Nach jedem Ausführen der Schleifenanweisung wird der update–Teil in den
runden Klammern ausgewertet. Dabei darf “update” ein Ausdruck oder eine
durch Kommata getrennte Liste von Ausdrücken sein (siehe Beispiele oben).
Im “update”–Teil werden meist mit Hilfe von Inkrement–Operatoren Variablen
verändert. Der update–Ausdruck darf leer sein.
Beispiel: Das folgende Programm gibt die Zahlen von 1 bis 10 aus.
init;
while( test) {
anweisung;
update;
}
Der erste Teil in den runden Klammern (init) wird vor dem Start der Schleife
ausgewertet. Er dient meist dazu, in der Schleife benötigte Variablen zu definieren oder zu initialisieren.
Folgende Anweisungen und Ausdrücke sind hier erlaubt:
• “init” darf ein Ausdruck sein, wie in folgendem Beispiel:
01 public class DemoFor1 {
02 public static void main( String[] args )
03 {
04
int i;
05
for(i=1 ; i <= 10 ; i++ )
06
System.out.println(i);
07 }
08 }
Beispiel: Auch das folgende Programm gibt die Zahlen von 1 bis 10 aus.
Es empfiehlt sich, die Variablendefinition in die Initialisierungsanweisung
zu schreiben.
for( i=0; i < 10; i++)
System.out.println(i);
• “init” darf eine Liste von Ausdrücken sein, die dann durch Kommata getrennt sein müssen, wie in diesem Beispiel:
for(i=0, j=0 ; i < 10; i++, j+=i ) {
System.out.println(i);
System.out.println(j);
}
• “init” darf eine Variablendefinition sein:
71
01 public class DemoFor2 {
02 public static void main( String[] args )
03 {
04
for(int i=10 ; i <= 100 ; i+=10 )
05
System.out.println(i / 10 );
06 }
07 }
Beispiel: Das folgende Programm gibt die Zahlen von 1 bis 10 rückwärts
aus:
72
01 public class DemoFor3 {
02 public static void main( String[] args )
03 {
04
for(int i=10; i > 0 ; i-- )
05
System.out.println(i);
06 }
07 }
public class DemoFor7 {
public static void main( String[] args )
{
int i = 5;
for(double d=0 ; d <= 5 ; d++, i-- ) {
System.out.println(d + i);
}
}
}
Beispiel: In diesem Programm wird die Anweisung in Zeile 05 niemals
ausgeführt, da die Schleifenbedingung in Zeile 04 immer false ist.
9.7.4
01 public class DemoFor4 {
02 public static void main( String[] args )
03 {
04
for( ; false ; )
05
System.out.println("Hallo, Welt");
06 }
07 }
break und continue
Bitte lesen Sie die Ausführungen zu break und Continue in Go To Java, Kapitel
6.3 nach.
Beispiel: Dies ist eine Endlosschleife, da die Schleifenbedingung immer
true ist — es wird immer wieder der Text “Hallo, Welt” ausgegeben.
01 public class DemoFor5 {
02 public static void main( String[] args )
03 {
04
for( ; true ; )
05
System.out.println("Hallo, Welt");
06 }
07 }
Beispiel: Oft verschachtelt man mehrere Schleifen ineinander. Das folgende Programm gibt eine dreieckige Figur aus. Dazu verwenden wir die
Methode “System.out.print”. Diese arbeitet genauso wie die “println”–
Methode, beginnt aber nicht nach jeder Ausgabe mit einer neuen Zeile
sondern gibt aufeinanderfolgende Ausgaben hintereinander in der gleichen
Zeile aus.
01 public class DemoFor6 {
02 public static void main( String[] args )
03 {
04
for(int i=1 ; i <= 10 ; i++ ) {
05
for(int j = 1; j <= i ; j++ ) {
06
System.out.print("*");
07
}
08
System.out.println(); // neue Zeile beginnen
09
}
10 }
11 }
Beispiel: Sie können in einer for–Schleife beliebige Variablen als Kontrollvariablen verwenden, nicht nur int–Variablen. Wir demonstrieren hier
außerdem die Verwendung mehrerer Update–Ausdrücke.
Das Programm gibt 6–Mal die Zahl 5.0 aus.
73
74
9.8
10
Zusammenfassung
Sie müssten nun die folgenden Fragen beantworten können:
B Was ist ein Block ?
B Wieso darf man in Java auch mehr als ein Semikolon zum Abschluß
eines Befehls verwenden ?
B Was für einfache Anweisungen kennen Sie ?
B Erklären Sie, wo eine einmal definierte Variable überall verwendet werden darf — was ist ihr Gültigkeitsbereich ?
B Können sich Variablendefinitionen in Java gegenseitig verdecken ?
B Nennen Sie Beispiele für Ausdrucksanweisungen !
B Welche Beziehung gibt es zwischen Variablendefinitionen und
Blöcken ?
B Was ist ein Dangling Else ?
B Wie kann man ein Dangling Else vermeiden ?
B Welche Schleifen kennen Sie ?
B Wie werden do–Schleifen aufgebaut ?
B Wodurch unterscheiden sich do und while–Schleife ?
B Was ist eine Endlosschleife ?
B Wie kann man ein Programm unterbrechen, das in einer Endlosschleife
hängt ?
B Geben Sie ein Beispiel für eine Endlosschleife !
B Wie kann man eine Do in eine While–Schleife umschreiben ?
B Wie kann man eine While– in eine Do–Schleife umschreiben ?
B Wie kann man eine for–Schleife in eine while–Schleife umschreiben ?
B Wie muß eine For–Schleife aufgebaut sein ?
B Wie kann der init–Teil einer For–Schleife aussehen ?
B Wenn eine for–Schleife verwendet wird, um eine Variable einen gewissen Zahlenbereich durchlaufen zu lassen — wo sollte diese Variable
definiert werden ?
B Schreiben Sie ein Programm, das rückwärts von 10 bis 1 zählt – einmal
mit einer do–Schleife, einmal mit einer for– und einmal mit einer while–
Schleife.
Objekte in Java
Sie kennen nun die sogenannten imperativen Bestandteile von Java: Variablen,
Verzweigungen und Schleifen. Unser nächstes Ziel ist, Ihnen die objektorientierten Bestandteile zu vermitteln.
In Kapitel ?? wurde unabhängig von Java erläutert, was Klassen und Objekte
sind. Wenn Ihnen die Inhalte nicht mehr geläufig sind, lesen Sie es bitte noch
einmal.
Genau wie in Kapitel ?? beschrieben, ist auch in Java ein Objekt etwas, das
einen Zustand, eine Schnittstelle und Verhalten besitzt. Der Zustand eines Objektes ergibt sich aus seinen Attributen oder Variablen. Seine Schnittstelle und
sein Verhalten ist durch die in seiner Klasse beschriebenen Methoden definiert.
In diesem Kapitel soll nur gezeigt werden, wie man Objekte in Java benutzen
kann, welchen Lebenszyklus ein Objekt hat und wie sich Objekte von den Ihnen
bisher bekannten Datentypen wie int oder float unterscheiden.
Um ein Objekt zu erzeugen, muß zunächst seine Klasse definiert sein. Wie man
eigene Klassen definiert, soll erst in Kapitel 12 beschrieben werden. Um das
Verhalten von Objekten zu demonstrieren, werden wir in diesem Kapitel eine
von Java bereitgestellte Klasse verwenden.
10.1
Objekte und primitive Datentypen
Bisher haben Sie mit den primitiven Datentypen von Java und mit Strings
gearbeitet. Die primitiven Datentypen (sie fangen mit einem kleinen Buchstaben
an) sind:
boolean, char, byte, short, int, long long, float, double
Primitive Datentypen sind also die logischen Datentypen, Zeichen sowie alle
bisher benutzten Zahlen. Primitive Datentypen heißen so, da man als Programmierer selbst keine primitiven Datentypen definieren kann — alle primitiven Datentypen sind von den Java–Schöpfern fest eingebaut worden. Vielleicht kommt
diese Benennung aber auch daher, daß primitive Daten im Vergleich mit Objekten so “primitiv” sind.
Primitive Datentypen sind keine Klassen (wir erklären gleich einige Konsequenzen), und darum sind ihre Werte und Variablen auch keine Objekte.
Alle primitiven Datentypen haben gemeinsam, daß man die möglichen Werte
eines primitiven Datentyps durch Literale angegeben kann:
Beispiel: Angabe einiger Werte primitiver Datentypen durch Literale.
int i = 1;
char c = ’a’;
double f = 4.2390823;
Sie haben auch schon Objekte und Klassen kennengelernt, ohne daß Sie es wussten. Zeichenketten sind nämlich keine primitiven Datentypen sondern Objekte
der Klasse String. Da wir bisher nur wenige Fähigkeiten von Strings benutzt
haben, konnten Sie aber bisher vermutlich noch keinen Unterschied zwischen
75
76
Strings und den primitiven Datentypen feststellen. In diesem Kapitel wird sich
das etwas ändern.
Objekte kann man in der Regel nicht durch Literale erzeugen. Strings und Objekte der in Kapitel 11 behandelten Array–Klassen bilden hier die große Ausnahme. Die Java–Erfinder waren sich darüber im klaren, daß Strings unheimlich
häufig verwendet werden und haben daher die Möglichkeit geschaffen, Strings
durch Literale zu erzeugen.
Klasse StringBotschaften
1
2
3
4
5
6
7
8
9
10
Beispiel: Hier werden einige Objekte der Klasse String erzeugt:
String einString = "Hallo, Welt";
String name
= "Homer";
String wunsch = "Pizza";
Einen prinzipiellen Unterschied zwischen Klassen und primitiven Datentypen
können Sie vermutlich immer noch nicht erkennen. Vielleicht fällt Ihnen aber
eine ganz banale Sache fällt auf: Die primitiven Datentypen werden alle kleingeschrieben, der erste Buchstabe der String–Klasse hingegen wird großgeschrieben.
Eigentlich ist es Java egal, ob Klassennamen mit einem großen oder einem kleinen Buchstaben beginnen. Es ist aber üblich, alle Klassennamen mit einem
Großbuchstaben beginnen zu lassen. Bitte merken Sie sich das: Alle Klassennamen sollten mit einem Großbuchstaben beginnen.
Primitive Daten und Objekte unterscheiden sich durch das, was man mit ihnen anstellen kann. Den wichtigsten Unterschied können wir Ihnen hier leider
noch nicht erklären, da Sie vermutlich noch nicht wissen, was wir unter Vererbung verstehen. Für die fortgeschritteneren Leser sei hier erwähnt, daß man von
primitiven Datentypen nicht erben kann und daß primitive Datentypen keine
Extension einer anderen Klasse sind.
Einen fast genauso wichtigen Unterschied zwischen Objekten und primitiven
Daten werden Sie in diesem Kapitel aber noch kennenlernen: Während primitive Daten in einer Variablen gespeichert werden, ist eine Variable, in der Objekte
gespeichert werden, nur ein Verweis auf ein Objekt. Objekte haben im Unterschied zu primitiven Daten eine Identität (dazu mehr in Abschnitt 10.3).
Einen weiteren Unterschied zwischen Objekten und primitiven Daten können
wir Ihnen hier schon demonstrieren. Sie erinnern sich sicher, daß wir in Kapitel
?? geschrieben haben, daß Objekte Verhalten und einen Zustand haben und
daß Objekte miteinander kommunizieren können.
Primitive Daten haben hingegen nur einen Zustand. Sie sind nicht aktiv und besitzen weder eine Schnittstelle noch Verhalten. Man kann mit primitiven Daten
zwar rechnen oder sie verwenden, man kann primitiven Daten jedoch keine Botschaften schicken. Kurz gesagt: Primitive Daten sind nichts als dumme Daten
ohne Eigenleben.
Einen ersten Eindruck vom Unterschied zwischen primitiven Daten und Objekten liefert das folgende Beispiel. Es demonstriert, wie man String–Objekten
Botschaften schicken kann.
Beispiel: Im folgenden Beispiel erzeugen wir einige String–Objekte und
schicken ihnen dann Botschaften.
class StringBotschaften {
public static void main( String[] args ) {
String name = "Homer Simpson";
String wunsch = new String("Pizza");
System.out.println( "Bart Simpson".substring(0,4) );
System.out.println( name.substring(0,5) );
System.out.println( name.length() );
System.out.println( name.concat(" will ").concat( wunsch ) );
}
}
In Zeile 3 des Beispiels wird ein neues String–Objekt erzeugt, welches
danach über die String–Variable name angesprochen werden kann.
Auch in Zeile 4 wird ein String–Objekt erzeugt, welches den Text "Pizza"
enthält. Hier wird das Objekt jedoch nicht einfach durch Angabe des
String–Literals sondern durch Verwendung des new–Operators erzeugt.
Der new–Operator wird normalerweise immer benötigt, um ein Objekt
einer Klasse zu erzeugen. Da Strings auch durch Literale erzeugt werden
können, kann man auf den new–Operator bei Strings aber meist verzichten.
In Zeile 5 wird demonstriert, wie man an ein Objekt eine Botschaft
schicken kann. Hier wird an das String–Objekt "Bart Simpson" die Botschaft substring(0,4) geschickt. Das String–Objekt liefert daraufhin ein
String–Objekt zurück, das seine ersten vier Buchstaben, also den Text
"Bart", enthält. In Zeile 6 wird auf die gleiche Weise ein String–Objekt
erzeugt, das die ersten 5 Buchstaben des durch name bezeichneten Objektes enthält.
In Zeile 7 wird an das durch name bezeichnete Objekt die Botschaft
length() geschickt. Daraufhin liefert das Objekt die Länge des enthaltenen Textes.
In Zeile 8 wird an das durch name bezeichnete Objekt die Botschaft concat(" will ") geschickt. Die Botschaft concat veranlaßt
ein String–Objekt, ein neues Objekt zu erzeugen, indem es das in
der concat–Botschaft mit übergebene Objekt an sich selbst anhängt.
Das "Homer Simpson"–Objekt erzeugt also das neue String–Objekt
"Homer Simpson will ".
An dieses String–Objekt wird dann die Botschaft "concat(wunsch)" geschickt, woraufhin das String–Objekt "Homer Simpson will Pizza" erzeugt wird.
An primitive Daten kann man keine Botschaften schicken. Beispielsweise gibt
es keine Methode der ganzen Zahlen, die man als
int a;
a.tueWas();
// gibts nicht
5.quadrieren(); // auch ein Fehler
aufrufen könnte.
10.2
Der Lebenszyklus eines Objektes
Primitive Daten brauchen nicht erst irgendwie erzeugt zu werden. Sie werden
durch Literale gegeben und besitzen keinen Lebenszyklus.
77
78
Bei Objekten sieht das anders aus — sie haben einen gewissen Lebenszyklus:
Bevor man ein Objekt verwenden kann, muß es erzeugt werden. Während seiner
Lebensdauer kann es mit anderen Objekten kommunizieren, und wenn es nicht
mehr benötigt wird, wird es zerstört.
10.2.1
Dabei sind argument1 bis argumentN Argumente, die zur Initialisierung des
Objektes benutzt werden. Als Konstruktor wird ein solcher gewählt, der zu den
angegebenen Argumenten paßt (falls es in der Klasse keinen solchen Konstruktor
gibt, wird ein Kompilierfehler erzeugt). Was das genau bedeutet, erfahren Sie
in Kapitel 12.
Die Erzeugung von Objekten
Die Erzeugung eines Objektes geschieht durch Anwendung seines Bauplanes.
Seine Klasse wird als Muster genommen, um die Attribute des Objektes, seine
Schnittstelle und sein Verhalten zu definieren.
Die Objekterzeugung geht so vor sich, daß zunächst Speicherplatz für das Objekt bereitgestellt wird. Diesen Speicherplatz können Sie sich als eine Sammlung
von Variablen vorstellen: Ein Objekt ist eine Art Container, in dem einige Variablen enthalten sind. Dabei entspricht jedes in der Klasse definierte Attribut einer
Variable. Die Variablen, die zu einem Objekt gehören, nennt man auch Instanzvariablen, und der Zustand eines Objektes bestimmt sich aus den Zuständen
seiner Instanzvariablen.
Als erster Schritt wird also das Objekt mitsamt den enthaltenen Variablen angelegt. Da neu angelegte Variablen normalerweise einen undefinierten Zustand
haben und Objekte mit nicht definiertem Zustand in der Regel unerwünscht
sind, wird anschließend ein in der Klasse definiertes Initialisierungsverhalten
ausgeführt, welches den Instanzvariablen bestimmte Werte zuweist.
Dieses Initialisierungsverhalten wird in einer oder mehreren Methoden beschrieben, welche man in der objektorientierten Methodik als Konstruktoren bezeichnet. Man kann in Java das Anlegen und das Initialisieren des Objektes
nicht voneinander trennen, insofern empfiehlt es sich davon zu sprechen, daß
der Konstruktor ein Objekt erzeugt und initialisiert.
Einem Konstruktor können auch zusätzliche Daten mitgegeben werden, die zur
Initialisierung verwendet werden.
Beispiel: Ein String kann außer per Literal auch per Konstruktor erzeugt
werden.
1
2
3
4
Jede Klasse erhält automatisch einen Standardkonstruktor. Daher ist es nicht
unbedingt nötig, in eigenen Klassen einen Konstruktor vorzusehen.
Welcher Konstruktor in einer Klasse mit mehreren Konstruktoren beim Erzeugen eines Objektes benutzt wird, wird durch die Art der Objekterzeugung
festgelegt (genaueres dazu werden Sie in Kapitel 12 erfahren).
Der Standardkonstruktor einer Klasse kann man aufrufen, indem man den Ausdruck
new Klasse()
string1
string2
string3
string4
=
=
=
=
new String();
"Andreas";
new String("Hallo, Welt");
new String( string3 );
Im obigen Beispiel wird in Zeile 1 ein String durch den Standardkonstruktor erzeugt (new String()). In der String–Klasse ist festgelegt, daß dieser
Konstruktor den leeren String "" erzeugt.
Der durch string2 bezeichnete String wird durch das String–Literal automatisch erzeugt — immer wenn der Java–Compiler ein String–Literal entdeckt, fügt er automatisch einen entsprechenden Konstruktoraufruf zum
Erzeugen eines String–Objektes ein.
In Zeile 3 wird ein String durch einen Konstruktor erzeugt, der als Argument einen String entgegennimmt. Es wird daraufhin ein neuer String
erzeugt, der eine Kopie des Strings "Hallo, Welt" enthält.
In Zeile 4 wird ein String erzeugt, der eine Kopie des Strings string3
enthält.
Hier noch ein Beispiel mit einer selbstgebauten Klasse:
Beispiel: Angenommen, es sei eine Klasse Kind gegeben, welche ein Kind
Konstruktor
durch seinen Namen und sein Alter repräsentiert. Die Klasse könnte wie
folgt definiert sein:
Definition: Konstruktor
Ein Konstruktor ist eine Methode, welche ein Objekt erzeugt und dabei seinen anfänglichen Zustand initialisiert. Eine Klasse kann mehrere Konstruktoren für ihre Objekte definieren.
String
String
String
String
1
2
3
4
5
6
7
8
9
10
11
12
class Kind {
// Instanzvariablen eines Kindes:
String name;
int alter;
// Konstruktor:
public Kind( String neuerName, int neuesAlter ) {
name = neuerName;
alter = neuesAlter;
}
}
verwendet. Allgemeiner geschieht die Erzeugung eines Objektes durch einen
Ausdruck der Form
In Zeile 4 und 5 sind zwei Attribute, name und alter definiert. In Zeile
8–11 ist eine Methode definiert, deren Name gleich dem Klassennamen
ist. Dies ist ein Konstruktor.
new Klasse( argument1, argument2, ..., argumentN )
Wenn ein neues Kind erzeugt werden soll, könnte der Konstruktor wie
folgt aufgerufen werden:
79
80
Kind einKind = new Kind( "Bart Simpson", 12 );
Hier wird zunächst ein neues Kind–Objekt erzeugt, welches die beiden
Variablen name und alter enthält. Anschließend wird der Konstruktor der
Klasse (Zeile 8–11) ausgeführt. Der Konstruktor initialisiert daraufhin das
Attribut name zu "Bart Simpson" und das Attribut alter zu 12.
Sie sehen an diesem Beispiel, daß ein Konstruktor eigentlich nichts anderes
als eine Methode mit besonderem Namen ist.
10.3
Die Identität eines Objektes
Nachdem wir ein Objekt erzeugt haben, wollen wir es verwenden. Dazu müssen
wir das Objekt identifizieren können — wir benötigen also einen Namen, unter
dem wir es ansprechen können.
Genau wie bei primitiven Datentypen verwenden wir auch für Objekte Variablen. Es gibt dabei jedoch einen großen Unterschied: Während primitive Daten
in einer Variable gespeichert werden, wird ein Objekt durch eine Variable
nur referenziert.
Um primitive Daten in einer Variable zu speichern, verwendet man den Zuweisungsoperator. Auch bei der Zuweisung von Objekten verwendet man den
Zuweisungsoperator. Er bewirkt hier aber nicht, daß eine Kopie angelegt wird
sondern daß die zugewiesene Variable danach das Objekt referenziert. Es ist
durchaus möglich, daß mehrere Variablen das gleiche Objekt referenzieren.
Bitte merken Sie sich: Durch die alleinige Verwendung des Zuweisungsoperators wird kein neues Objekt erzeugt.
In Zeile 5 hingegegen wird durch Verwendung des new–Operators ein neues String–Objekt erzeugt, welches eine Kopie des durch Name name referenzierten Strings enthält. Dies Objekt wird dann durch n2 referenziert.
Klasse ReferenzDemo
1
2
3
4
5
6
7
8
9
class ReferenzDemo {
public static void main( String[] args ) {
String name = "Hallo, Welt";
String n1 = name;
String n2 = new String( name );
System.out.println( n1 == name );
System.out.println( n2 == name );
}
}
Die Situation nach Ausführung der Zuweisungen kann hier wie folgt graphisch dargestellt werden: Es gibt zwei String–Objekte mit gleichem Inhalt. Eines wird durch die Variablen name und n1 referenziert, und das
andere wird durch die Variable n2 referenziert:
String name
referenziert
referenziert
String−Objekt
Zustand: "Hallo, Welt"
String n1
String−Objekt
String n2
referenziert
Zustand: "Hallo, Welt"
Beispiel: Im folgendenProgrammfragment werden Zahlen in Variablen
gespeichert.
int i = 1;
// speichere die Zahl 1 in i
int j = i;
// speichere die Zahl 1 in j
double f = 3.141;// speichere 3.141 in f
Die Situation nach der Ausführung dieses Programmfragments könnte
man wie folgt darstellen: Zu jeder Variable gehört ein gewisser Teil des
Speichers, in welchem der Wert der Variable gespeichert ist:
int i
1
int j
1
double f
3.141
Beispiel: Nun soll demonstriert werden, wie Zuweisungsoperatoren auf
Objekte wirden. In Zeile 3 wird ein String–Objekt erzeugt und durch die
Variable name referenziert.
In Zeile 4 wird eine weitere String–Variable definiert und verweist nach
der Zuweisung auf das gleiche Objekt wie die Variable name. Durch die
Zuweisung in Zeile 4 wird kein neues Objekt erzeugt !
81
In Zeilen 6 und 7 des vorigen Beispiels verwenden wir den == Operator. Bisher haben Sie vermutlich gedacht, daß der ==–Operator zwei Ausdrücke auf
Gleichheit prüfe. Das stimmt aber so nicht ganz: der ==–Operator prüft, ob
zwei Ausdrücke identisch sind.
Zwei primitive Daten mit gleichem Wert sind auch identisch. Zwei Variablen,
die Objekte referenzieren, sind hingegen nur dann identisch, wenn sie beide auf
das gleiche Objekt verweisen. In Zeile 6 des vorigen Beispiels wurde daher true
und in Zeile 7 false ausgegeben.
Um das nochmal ganz deutlich zu machen: Wir unterscheiden zwischen Gleichheit und Identität. Zwei Objekte sind gleich, wenn sie den gleichen Zustand
haben. Zwei Objekte sind identisch, wenn sie beide das gleiche Objekt sind.
Im obigen Beispiel sind die durch name und n2 referenzierten Objekte gleich,
da sie beide den Text "Hallo,Welt" enthalten. Hingegen sind name und n2
nicht identisch, da sie auf unterschiedliche Objekte verweisen.
Die Identität eines Objektes ist unabhängig von seinem Zustand. Auch wenn
sich der Zustand eines Objektes ändert, bleibt seine Identität erhalten.
Es ist möglich, daß zwei nicht–identische Objekte den gleichen Zustand haben.
Es ist aber nicht möglich, daß zwei identische Objekte unterschiedliche Zustände
haben.
Bitte merken Sie sich folgendes:
82
Gleichheit
und
Identität
Identität
Identität:
Jedes Objekt hat Identität — die Identität existiert unabhängig
von Namen, mit denen wir das Objekt bezeichnen. Die Identität
eines Objektes ändert sich vom Beginn seines Lebenszyklus bis zur
Zerstörung nicht. Sie ändert sich auch nicht, wenn wir den Zustand
des Objektes verändern.
Übrigens bestimmt Java, ob zwei Objekte identisch sind, indem es nachschaut,
an welcher Stelle im Speicher sie gespeichert sind. Identisch sind genau diejenigen Objekte, die an gleichen Speicherstellen liegen.
Oft möchte man verhindern, daß zwei nicht–identische Objekte mit gleichem
Zustand existieren. In diesem Fall muß man das durch einen geeigneten Mechanismus sicherstellen.
Beispiel: Es ist denkbar, daß zwei verschiedene Studenten den gleichen
Namen haben. Will eine Universität verschiedene Studenten auseinanderhalten, eignet sich der Name also nicht zur Identifizierung.
Aus diesem Grund wird jedem Studenten eine eindeutige Immatrikulationsnummer gegeben. Eine Verfahrensvorschrift bei der Immatrikulation
stellt sicher, daß jede Immatrikulationsnummer nur einmal vergeben wird.
Die Immatrikulationsnummer ist aus Sicht der Universität also die Identität des Studenten.
ergebnis = einAusfuehrer.methodenName(eingabe 1 , . . . , eingabe n ).
Beispiel: Zum Beispiel ist in der String–Klasse die Methode length definiert, welche die Länge eines Strings zurückgibt. Sie nimmt keinen weiteren Parameter entgegen und liefert eine int–Zahl zurück.
Die Länge eines Strings kann man daher ermitteln, indem man dem String
die Botschaft length() schickt:
String meinString = "Ein Text";
int laenge = meinString.length();
int laenge1 = "Noch ein Text".length();
Bisher haben wir uns das Bild gemacht, daß wir mit Objekten kommunizieren,
indem wir ihnen Botschaften schicken. Dieses Bild ist auch weiterhin richtig,
und es entspricht hervorragend der objektorientierten Denkweise. Es ist nun
leider an der Zeit, diese Denkweise ein wenig an Java anzupassen.
In Java bedeutet der Punkt nach dem Objektnamen eigentlich nicht das Verschicken einer Botschaft. Vielmehr hat man in Java die Vorstellung, daß ein
Objekt ein Container ist, welcher Instanzvariablen und Methoden enthält. Auf
die in einem Objekt enthaltenen Dinge kann man dann zugreifen, indem man
objekt.enthaltenesDing
10.4
Die Kommunikation mit Objekten
Nachdem ein Objekt erzeugt wurde, können wir mit ihm kommunizieren. Wir
können es durch das Zusenden von Botschaften zu einem gewissen Verhalten
veranlassen, und es kann selbst Botschaften an andere Objekte verschicken.
Um einem Objekt eine Botschaft zu schicken, müssen wir eine Referenz auf
das Objekt kennen. Wir können ihm nur Botschaften schicken, die es versteht.
Welche Botschaften ein Objekt versteht und wie diese Botschaften aufgebaut
sein müssen, ist in seiner Klasse beschrieben.
Nochmal zur Erinnerung: Den Aufbau von Methoden definieren wir in der
Schnittstelle der Klasse wie folgt:
Klasse r methodenName(Klasse 1 e 1 , . . . , Klasse n e n )
Wenn wir nun ein Objekt auffordern wollen, eine Methode auszuführen, schicken
wir ihm eine Botschaft, deren Aufbau genau dieser Beschreibung entspricht.
Wenn eine Methode kein Ergebnis zurückliefert, schreiben wir die Aufforderung
an das Objekt einObjekt die Methode methodenName auszuführen, wie folgt:
schreibt. Der Punkt dient also sozusagen dazu, das Objekt aufzumachjen und auf
die enthaltenen Dinge zuzugreifen. Insofern paßt die Vorstellung, man schicke einem Objekt Botschaften nicht hundertprozentig zu Java. Man kann die Schreibweise
objekt.methode()
auch als den Aufruf einer im Objekt enthaltenen Methode verstehen. Natürlich
ist diese Vorstellung äquivalent zur Vorstellung, daß wir dem Objekt eine Botschaft schicken.
Man kann den Punkt auch verwenden, um auf Instanzvariablen eines Objektes
zuzugreifen, und hier hört die Analogie zum Verschicken von Botschaften auf.
Weiter oben hatten wir ein Beispiel mit einer Kind–Klasse. Wir können auf die
Attribute eines Kindes dieser Klasse wie folgt zugreifen:
Kind einKind;
einKind.name = "Bart Simpson";
einKind.alter = 12;
Dabei übergeben wir wir soviele zusätzliche Objekte eingabe 1 , . . . , eingabe n , wie
in der Schnittstelle beschrieben. Das Objekt eingabe i muß dabei Mitglied der
Klasse Klasse i sein.
Wenn die Methode ein Ergebnis liefert, können wir dieses Ergebnis abholen.
Dazu benötigen wir ein Objekt ergebnis der Klasse Klasse r . Wir schreiben in
diesem Fall:
Hier dient der Punkt also tatsächlich dazu, auf die in einem Objekt enthaltenen
Variablen zuzugreifen.
Vielleicht sollten wir daher in Zukunft lieber davon reden, daß ein Objekt Methoden enthalte, und daß wir, statt dem Objekt eine Botschaft zu schicken, eine
im Objekt enthaltene Methode aufrufen. Vermutlich werden wir in Zukunft beide Sprechweisen verwenden — sie sind schließlich äquivalent. Das Schicken von
Botschaften scheint dabei auch immer noch anschaulicher, auch wenn es nicht
so hundertprozentig zur Java–Philosophie paßt.
83
84
einAusfuehrer.methodenName(eingabe 1 , . . . , eingabe n )
10.5
Welche Botschaften versteht ein Objekt ?
Mit Hilfe der obigen Beschreibung können wir ein Programm schreiben,
das alle Zeichen eines Strings einzeln ausgibt. Dazu rufen wir in einer
Schleife wiederholt die String–Methode charAt auf und geben das durch
den String zurückgegebene Zeichen mit der Methode System.out.println
aus. Um die Länge des Strings zu ermitteln, schicken wir ihm die Botschaft
length(). Bitte sehen Sie sich auch die Dokumentation zur length–Methode
an.
Wenn Sie selbst eine Klasse schreiben, wissen Sie natürlich, welche Methoden
enthalten sind. Wie aber können Sie erfahren, welche Methoden fremde Klassen
enthalten ?
Zu Java gehört eine ganze Menge an Dokumentation. Sämtliche in Java enthaltenen Klassen sind in der Dokumentation des JDK (Java Development Kit)
beschrieben. Wie diese Dokumentation genau aufgebaut ist, erklären wir Ihnen,
sobald wir Klassen (Kapitel 12) und Pakete (Kapitel 15) besprochen haben.
In den folgenden Hausaufgaben und in den weiteren Texten werden Sie häufig
mit dieser Dokumentation arbeiten müssen. Hier soll Ihnen die Verwendung der
JDK–Dokumentation anhand eines Beispiels demonstriert werden:
Klasse DemoStringMethods
1
2
3
4
5
6
7
8
Beispiel: Die Dokumentation zur String–Klasse finden Sie auf der
class DemoStringMethods {
static public void main( String[] args ) {
String text = "Hallo, Welt";
for( int i = 0; i < text.length(); i++ ) {
System.out.println( text.charAt( i ) );
}
}
}
WWW–Seite
http://www.tu-bs.de:82/wir/EIP/jdk1.1.8/docs/api/java.lang.String.html
Bitte klicken Sie sich dorthin, indem Sie von unseren WWW–Seiten unter den Litaturlinks zu Java auf den relativ weit unten stehenden Link
“Java–Api (lokal)” klicken. Sie gelangen dann auf eine Seite, auf der einige sogenannte “packages” aufgelistet sind.
Dort klicken Sie bitte auf den als java.lang bezeichneten Link. Anschließend erhalten Sie eine Liste von Klassen, unter denen sich auch die Klasse
String befindet.
Wenn Sie nun auf den String betitelten Link klicken, gelangen Sie zu der
oben genannten WWW–Seite.
Auf dieser WWW–Seite sind alle Methoden beschrieben, die String–
Objekte verstehen. Bitte lesen Sie den kompletten ersten Teil der Seite
durch und schauen Sie sich unter der Überschrift “Method Index” die
Methode charAt an. Wenn Sie darauf klicken, sollten Sie die folgende
Erläuterung erhalten:
public char charAt(int index)
Returns the character at the specified index. An index
ranges from 0 to length() - 1.
Parameters:
index - the index of the character.
Returns:
the character at the specified index of this string.
The first character is at index 0.
Throws: StringIndexOutOfBoundsException
if the index is out of range.
Sie erkennen, daß hier eine Methode namens charAt beschrieben wird,
mit der man einen String auffordern kann, ein in ihm enthaltenes Zeichen
zurückliefern.
Beachten Sie, daß die Zeichen eines Strings mit 0 beginnend durchnumeriert werden. Das erste Zeichen eines Strings erhält man, also indem man
ihm die Botschaft charAt( 0 ) schickt.
85
10.6
Die Zerstörung von Objekten
Wenn ein Objekt nicht mehr benötigt wird, wird es zerstört und entsorgt. Dabei wird der gesamte Speicherplatz, den das Objekt im Speicher belegt hatte,
freigegeben.
Glücklicherweise muß man sich als Programmierer in Java überhaupt nicht um
die Objektentsorgung kümmern. Java kann nämlich selbst erkennen, ob ein Objekt noch benötigt wird oder nicht. Dazu enthält Java eine Funktion, die zwischendurch immer wieder mal automatisch gestartet wird und sich als “Müllsammler” betätigt — diese Funktion heißt sehr treffend der Garbage Collector14
Der Garbage Collector kann feststellen, auf welche der momentan existierenden
Objekte Variablenreferenzen existieren. Immer wenn er ein Objekt entdeckt, das
durch keine einzige Variable referenziert wird, sammelt er es ein und gibt den belegten Speicherplatz für andere Objekte frei — er betreibt also Recycling, denn
der so freigegebene Speicherplatz schafft Lebensraum im Speicher des Computers für neue Objekte. Das tollste daran ist, daß Sie selbst sich überhaupt nicht
um Ihre Müllentsorgung kümmern müssen — alle nicht mehr Objekte werden
volautomatisch entsorgt.
Vielleicht fragen Sie sich, ob das nicht etwas unsicher sei: Da kommt irgendso
ein dahergelaufenes Programm und löscht einfach Ihre Objekte.
Bedenken Sie aber, daß Sie ohnehin keine Möglichkeit haben, ein Objekt, das
Sie nicht durch eine Variable referenziert haben, zu benutzen. Insofern kann der
Garbage Collector keinen Schaden anrichten — er löscht niemals Objekte, auf
die Sie noch zugreifen können.
Noch ein Hinweis: Es ist zwar möglich, den Garbage Collector von Hand zu
starten. Nötig ist es aber meist nicht, da Java ihn ohnehin immer automatisch
startet, wenn mehr Platz benötigt wird.
Und noch ein Hinweis: Selbstverständlich werden nur Objekte gelöscht — bei
primitiven Daten ist das nicht nötig, da sie in einer Variable enthalten sind
14 Garbage Collectoren sind übrigens keine Erfindung von Java — das in den 70ern entwickelte Smalltalk besaß bereits einen Garbage Collector.
86
und ihre Lebensdauer daher durch die Lebensdauer der Variablen begrenzt ist.
Objekte müssen nur deshalb gelöscht werden, da sie unabhängig von Variablen
existieren.
B Nennen Sie einige Unterschiede zwischen primitiven Datentypen und
Klassen !
Beispiel: Im folgenden Programm werden in Zeile 3 und 4 zwei String–
B Wie erzeugt man ein Objekt ?
Objekte erzeugt.
B Was ist ein Konstruktor ?
Die Zuweisung in Zeile 5 bewirkt, daß auf "String1" keine Referenz mehr
existiert. Daher kann "String1" nach Ausführung von Zeile 5 vom Garbage Collector gelöscht werden.
B Beschreiben Sie, was Sie unter der Identität eines Objektes verstehen !
In Zeile 6 wird a2 ein neues Objekt zugewiesen. Das Objekt "String2"
darf jedoch noch nicht gelöscht werden, da es noch durch die Variable a1
referenziert wird.
Erst nach Ausführung von Zeile 7 wird das Objekt "String2" von keiner Variable mehr referenziert und kann vom Garbage Collector entsorgt
werden.
Klasse DemoGarbage
1
2
3
4
5
6
7
8
9
10.7
B Welche primitiven Datentypen kennt Java ?
class DemoGarbage {
public static void main() {
String a1 = "String 1";
String a2 = "String 2";
a1 = a2;
a2 = "String 3";
a1 = "";
}
}
B Enthalten Variablen Objekte ?
B Was bewirkt der Zuweisungsoperator bei primitiven Daten ?
B Was bewirkt der Zuweisungsoperator bei primitiven Objekten ?
B Was bewirkt der ==–Operator bei primitiven Daten ?
B Was bewirkt der ==–Operator bei Objekten ?
B Was ist der Unterschied zwischen Gleichheit und Identität ?
B Wie schickt man einem Objekt eine Botschaft ?
B Wie kann man herausfinden, welche Methoden die Klasse String
enthält ?
B Wie werden Objekte zerstört ?
B Wie arbeitet der Garbage–Collector ?
B Warum kann der Garbage–Collector keinen Schaden anrichten ?
Zusammenfassung
Sie sollten nun die folgenden Fragen beantworten können:
87
88
11
Arrays
Klasse ArrayDefinitionen
1
2
3
4
5
6
7
8
9
10
11
Bevor Sie lernen, selbst Klassen zu definieren, möchten wir Ihnen noch einen
weiteren Typ von sehr wichtigen Objekten vorstellen: Arrays.
Arrays sind Objekte, welche eine größere Anzahl von Zahlenwerten oder anderen
Daten verwalten können. Sie können sich ein Array als eine durchnumerierte
Sammlung von Variablen vorstellen. Arrays sind die einfachste Möglichkeit, die
Java zur Verwaltung mehrerer gleichartiger Daten oder Objekte bietet.
Arrays unterscheiden sich von allen anderen Objekten und Klassen in Java: Die
Array–Klassen haben einen recht eigenartigen Namen, und auch die Konstruktor–
Aufrufe von Arrays unterscheiden sich von normalen Konstruktor–Aufrufen.
11.1
class ArrayDefinitionen {
public static void main( String[] args ) {
int[] einIntArray;
einIntArray = new int[ 100 ];
double[] einDoubleArray = new double[ 10 ];
String[] einStringArray;
einStringArray = new String[ 50 ];
}
}
Bevor wir darauf eingehen, wie man Objekte benutzt, sollen noch ein paar Eigenarten von Arrays erwähnt werden:
Definition von Arrays
Ein Array ist ein Vektor gleichartiger Variablen. Die Klasse eines Arrays, in
welchem Variablen des Datentyps typ gespeichert werden können, ist typ[].
Beispielsweise speichern Objekte der Klasse int[] einen Vektor von int–Werten,
während Objekte der Klasse String[] einen Vektor String–Werten verwalten
können.
Eine Array–Klasse erhält man also, indem man hinter einen anderen Klassennamen zwei eckige Klammern setzt. Diese merkwürdige Schreibweise ist praktisch,
da sie sehr prägnant ist und für jede beliebige Klasse — auch für selbstentwickelte Klassen — verwendbar ist.
Eine Variable, welche ein Array–Objekt referenzieren kann, definiert man also
so:
typ[] arrayVariable;
• Die Größe eines Arrays kann im Nachhinen nicht mehr verändert werden.
Wenn Sie nach der Erzeugung eines Arrays feststellen, daß es zu klein ist,
können Sie es also nicht mehr wachsen lassen.
Statt dessen müssten Sie in diesem Fall ein weiteres, hinreichend großes
Array erzeugen und den Inhalt des alten Arrays in das neue Array hineinkopieren.
• Es ist nicht möglich, in einem Array Daten verschiedener Klassen oder
Datentypen zu speichern. Beispielsweise können Sie kein Array erzeugen,
das sowohl int– als auch String–Werte speichern kann15
• Beachten Sie bitte den Unterschied zwischen Arrays primitiver Datentypen
wie int[], double[] und Arrays von Objekten wie String[].
Arrays primitiver Datentypen der Größe n bieten n Positionen, an denen
Daten gespeichert werden, während Arrays von Objekten der Größe n
nicht die Objekte selbst sondern nur Referenzen auf Objekte speichern.
Wir besprechen das weiter unten noch an einem Beispiel.
Da Arrays Objekte sind, müssen sie durch einen Konstruktor erzeugt werden.
Dem Erzeugen eines Arrays muß man angebeben, wie groß das Array sein soll,
d.h. für wie viele Werte oder Objekte im Array Platz sein soll.
Ein Array–Objekt der Größe n eines Datentyps typ wird wie folgt erzeugt:
11.2
new typ[ n ]
Auch hier wird eine etwas eigenartige Schreibweise verwendet — normalerweise
wird der Konstruktor einer Klasse ja geschrieben als Klasse( argumente ).
Für ein Array würde man also eigentlich erwarten, daß der Konstruktor–Aufruf
als Datentyp[](n) geschrieben wird. Auch hier haben Arrays also eine Sonderstellung.
Beispiel: Im folgenden Beispiel wird in Zeile 3 eine Array–Variable namens einIntArray definiert, welche int–Werte speichern kann. In Zeile 4
wird ein Array–Objekt der Größe 100 angelegt und durch einIntArray
referenziert.
Verwendung von Arrays
Jedes Array der Größe n enthält n von 0 bis n − 1 durchnumerierte Variablen.
Wenn array eine Array–Variable ist und wenn i eine int–Zahl ist, so kann man
auf den i–ten Arrayinhalt wie folgt zugreifen.
array[i]
Einen Kompilierfehler erhält man, wenn man versucht mit einem Wert, welcher
nicht automatisch in einen int gewandelt werden kann, auf ein Array zuzugreifen.
Wäre i eine long oder eine double–Variable, so würde der Zugriff array[i] also
einen Kompilierfehler erzeugen.
Zeile 8–9 zeigen, daß man nicht nur Arrays von primitiven Datentypen
sondern auch Arrays von Objekten definieren kann.
15 Das stimmt nicht völlig — ein Array kann schon Objekte verschiedener Klassen speichern.
Das verstehen Sie aber erst, wenn Sie wissen, was Vererbung ist. Für die fortgeschrittenen Leser
ein Hinweis: Ein Array des Typs MeineKlasse[] kann selbstverständlich auch Instanzen von
Extensionen von MeineKlasse speichern. Insbesondere kann ein Array vom Typ Object[] alle
Objekte aufnehmen.
89
90
In Zeile 6 wird eine Variable zur Referenzierung eines double–Arrays erzeugt und mit einem Array der Größe 10 initialisiert.
Wenn man versucht, auf eine negative oder auf eine sonstige nicht–vorhandene
Array–Position zuzugreifen, erhält man während der Laufzeit seines Programms
eine Fehlermeldung. Das Programm wird dann beendet.
Beispiel: Das folgende Programm definiert ein int–Array der Größe 10.
Wenn Sie von vorneherein darauf achten, daß Ihre Programmteile möglichst wenig Annahmen über die zu bearbeitenden Objekte machen, werden Änderungen
einfacher.
In diesem Array speichert es die Zahlen 1 bis 10.
11.3
Anschließend wird versucht, die Zahlen auszugeben. Dabei wird ausversehen auf eine Array–Position zugegriffen, die nicht existiert. An der Stelle
bricht das Programm mit einer Fehlermeldung ab.
Auch Arrays kann man als Literale schreiben. Ein Array–Literal hat die Form
{ wert, wert, ...., wert }.
Zum Beispiel wird hier ein durch Verwendung eines Array–Literales ein int–
Array der Größe 5 erzeugt und mit den Zahlen 1, 4, 9, 16, 25 initialisiert:
Klasse ArrayZugriff
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class ArrayZugriff {
public static void main( String[] args ) {
int[] intArr = new int[ 10 ];
// Array mit Zahlen von 1 bis 10 fuellen
for( int i = 0; i < 10 ; i++ ) {
intArr[ i ] = i + 1;
}
// Arrayinhalt ausgeben. Dabei wird ein Fehler gemacht:
// Statt von 0..9 wird auf Array-Position 1..10 zugegriffen
for( int i = 1; i <= 10; i++ ) {
System.out.println( intArr[i]);
}
}
}
Man kann bei einem gegebenen Array herausfinden, wie groß es ist. Dazu greift
man auf sein Längen–Attribut zu, indem man schreibt:
array.length
Wannimmer Sie die Größe eines Arrays verwenden, sollten Sie das Längen–
Attribut des Arrays verwenden. Sie sollten die Größe niemals direkt als Literal
im Programm benutzen.
Beispiel: Angenommen, Sie wissen, daß ein Array namens meinArray
10 Elemente enthält, welche Sie ausgeben wollen, so sollten Sie dennoch
nicht schreiben
for( int i = 0 ; i < 10 ; i++ ) {
System.out.println( meinArray[i] )
}
Verwenden Sie statt dessen das Längen–Attribut:
Array–Literale
int[] quadrate = {1, 4, 9, 16, 25};
Ähnlich kann man auch andere Arrays initialisieren:
double[] werte = {1.1, 1.3, 1.4};
String[] tage = {"Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"};
11.4
Primitive Arrays und Objektarrays
Wir möchten Ihnen hier anhand eines Beispiels nochmal den Unterschied zwischen Arrays von primitiven Daten und zwischen Arrays von Objekten zeigen.
Dazu betrachten wir ein Programm, welches ein int– und ein String–Array verwendet. Beide Arrays haben 4 Einträge.
Klasse ArrayPrimObj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class ArrayPrimObj {
public static void main( String[] args ) {
int[] daten = {100, 200, 300, 400};
for( int i = 0; i < daten.length; i ++ ) {
System.out.println( daten[i] );
}
String[] sDaten = new String [ 4 ];
sDaten[0] = "String 1";
sDaten[1] = "String 2";
sDaten[2] = sDaten[3] = "String 3";
for( int i = 0; i < sDaten.length; i++ ) {
System.out.println( sDaten[i] );
}
}
}
Um Ihnen deutlich zu machen, wie die beiden Arrays von Java gehandhabt
werden, finden Sie hier zwei Zeichnungen:
for( int i = 0 ; i < meinArray.length ; i++ ) {
System.out.println( meinArray[i] )
}
Sie fragen sich vielleicht, warum man in seinem Programm die Größe eines Arrays nicht explizit verdrahten soll. Die Antwort ist einfach: Programme ändern
sich. Wenn Sie später die Größe des Arrays verändern, so müssten Sie alle Stellen, an denen Sie die Größe als Zahl geschrieben haben, manuell nachbessern.
Das führt dann meist zu Fehlern.
91
92
Klasse ArrayReferenz
int−Array
length=4
Inhalt=:
int[] daten;
referenziert
0
100
1
200
2
300
4
400
Das int–Array ist ein Objekt, welches von der Variable daten referenziert wird.
Als Array der Größe 4 enthält es vier von 0 bis 3 durchnumerierte Variablen, in
welchen int–Werte gespeichert werden. Das Array enthält außerdem ein Attribut
namens length, in welchem gespeichert wird, wie viele Speicherplätze das Array
enthält.
String−Objekt
String−Array
referenziert
length=4
Inhalt=:
0
referenziert
String[] sDaten;
referenziert
1
2
Inhalt: String 1
String−Objekt
Inhalt: String 2
referenziert
String−Objekt
4
referenziert
Inhalt: String 3
Auch das String–Array ist ein Objekt. Es wird von der Variable sDaten referenziert. Auch das String–Array enthält vier String–Variablen. Da String–
Variablen aber Objekte nicht speichern sondern nur referenzieren, enthält das
String–Array selbst lediglich vier Verweise auf andere Objekte.
11.5
Referenztypen am Array-Beispiel
Nun möchten wir Ihnen noch am Beispiel der Arrays demonstrieren, was es
für die Praxis bedeutet, mit Referenztypen zu arbeiten. Sie sollten dieses Programm auf jeden Fall ausprobieren und danach ein wenig mit dem Programm
herumspielen !
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class ArrayReferenz {
public static void main( String[] args ) {
int[] daten = {100, 200, 300, 400};
int[] datenNeu = daten;
datenNeu[1] = 1;
datenNeu[3] = 3;
datenNeu = new int[4];
for(int i = 0; i < daten.length; i++ ) {
System.out.println( daten[i] );
}
}
}
Im obigen Programm wird ein Array–Objekt erzeugt, welches durch die Variable
daten referenziert wird. In Zeile 5 wird eine weitere Variable, datenNeu definiert,
welche das selbe Objekt referenziert.
Dann wird in Zeile 6 und 7 die Variable datenNeu verwendet, um das Array–
Objekt zu verändern.
Obwohl wir die Variable daten nicht benutzt haben, um das Array zu verändern,
hat sich das durch die Variable daten referenzierte Array hierdurch verändert,
wie die Ausgabe in Zeile 10–12 beweist.
Sie sehen also, daß Änderungen an Objekten alle Variablen beeinflussen, welche das Objekt referenzieren. Wenn man im Umgang mit Referenztypen nicht
aufpasst und sich nicht immer wieder klarmacht, daß die Zuweisung keine Kopie sondern nur eine Referenz erzeugt, kann man daher große Überraschungen
erleben.
11.6
Mehrdimensionale Arrays
Man kann auch Arrays erzeugen, die Arrays enthalten. Beispielsweise wird hier
ein Array erzeugt, das int–Arrays enthält:
int[][] einZweiDIntArray;
Arrays, die Arrays enthalten, nennt man mehrdimensionale Arrays. Unter “Dimension” versteht man dabei die Schachtelungstiefe der Arrays. Ein vierdimensionales Array könnte man so definieren:
int[][][][] einVierdimArray;
Mehrdimensionale Arrays eignen sich zur Darstellung von Daten wie Matrizen,
Tensoren, Spreadsheets, und so weiter.
Ein zweidimensionales Array wird wie folgt erzeugt:
int[][] zweiDArray = new int[ zeilen ][ spalten ];
Beachten Sie aber den Unterschied zwischen einem zweidimensionalen Array
und einer Matrix: In einer Matrix hat jede Zeile und jede Spalte die gleiche
Länge. Ein zweidimensionales Array ist hingegen einfach ein Array, das andere
Arrays enthält. Über die Längen der enthaltenen Arrays ist damit nichts gesagt.
93
94
Die obige Initialisierung eines zweidimensionalen Arrays stellt allerdings sicher,
daß alle Zeilen des erzeugten Arrays die gleiche Länge haben.
Klasse Array2D
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Beispiel: Das folgende Programm demonstriert die Erzeugung eines matrixförmigen Arrays und eines zweidimensionalen Arrays einDreieck, in
welchem die Zeilen unterschiedliche Längen besitzen:
Klasse Array2D
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Array2D {
public static void main( String[] args ) {
int[][] eineMatrix = new int[10][10];
for( int i=0; i < eineMatrix.length; i++) {
for( int j=0; j < eineMatrix.length; j++) {
eineMatrix[i][j] = i-j;
}
}
int[][] einDreieck = new int[10][1];
for( int i=0; i < einDreieck.length; i++) {
einDreieck[i] = new int[i+1];
}
for( int i=0; i < einDreieck.length; i++) {
for( int j=0; j < einDreieck[i].length; j++ ) {
einDreieck[i][j]=i-j;
System.out.print( einDreieck[i][j] );
System.out.print(" ");
}
System.out.println();
}
class Array2D {
public static void main( String[] args ) {
// matrixförmiges double--array
double[][] matrix = { {1.1, 1.2}, {1.2, 1.3} };
for( int i = 0; i < matrix.length ; i++ ) {
for( int j= 0; j < matrix[i].length; j++ ) {
System.out.print( matrix[i][j] );
System.out.print(" ");
}
System.out.println();
}
// dreieckförmiges int--Array
int[][] zweiDInt = { {1}, {2,3}, {4,5,6}, {7,8,9,10} };
for( int i = 0; i < zweiDInt.length ; i++ ) {
for( int j= 0; j < zweiDInt[i].length; j++ ) {
System.out.print( zweiDInt[i][j] );
System.out.print(" ");
}
System.out.println();
}
}
}
}
}
11.7
Zusammenfassung
Sie sollten nun die folgenden Fragen beantworten können:
Beispiel: Schließlich demonstriert das folgende Programm demonstriert
den Umgang mit 2–dimensionalen Arrays und 2–dimensionalen Array–
Literalen.
B Was ist ein Array ?
Zuerst wird ein matrixförmiges double–Array definiert und ausgegeben,
und anschließend wird ein dreieckförmiges int–Array definiert und ausgegeben.
B Wie erzeugt man ein Array–Objekt ?
B Wie definiert man ein boolean–Array ?
B Wie kann man im Nachhinein die Größe eines Arrays ändern ?
B Erläutern Sie den Unterschied zwischen Arrays primitiver Datentypen
und Arrays von Objekten !
B Wie greift man auf Array–Elemente zu ?
B Wie sind die Variablen in einem Array der Länge 4 durchnumeriert ?
B Wie kann man auf das letzte Element eines Arrays der Länge 4 zugreifen ?
B Wie kann man auf das erste Element eines Arrays zugreifen ? Wie auf
das zweite ?
B Wie kann man die Größe eines gegebenen Arrays bestimmen ?
B Was ist ein Array–Literal, und wie benutzt man es ?
B Welche Gefahr besteht bei der Verwendung von Referenz–Typen ?
B Was ist ein Mehrdimensionales Array ?
B Wie erzeugt man ein mehrdimensionales Array ?
B Wie unterscheiden sich 2–dimensionale Arrays von Matrizen ?
95
96
12
Klassen in Java
Objekten selbst sondern an einer zentralen Stelle speichern, die irgendwie
zu den Objekten gehört. Hierzu verwendet man Klassenvariablen.
Nun soll es endlich daran gehen, in Java eigene Klassen zu erstellen. Wir schließen hier an der in in Kapitel ?? begonnenen Diskussion über Klassen und Objekte an. Wenn Ihnen die Inhalte von Kapitel ?? nicht mehr geläufig sind, sollten
Sie es nun noch einmal lesen.
12.1
Instanz- und Klassenbestandteile
Bevor wir beginnen, Klassen zu programmieren, müssen wir unsere Vorstellung
von Klassen etwas revidieren — Sie wissen bisher, daß eine Klasse ein Bauplan
für Objekte ist. Sie ist aber noch mehr — genau wie Objekte kann auch eine
Klasse Variablen und Methoden enthalten (eine Java–Klasse ist aber selbst kein
Objekt).
Die Klasse hat also zwei Funktionen: Zum einen ist die Klasse der Bauplan von
Objekten — in der Klasse ist beschrieben, welche Attribute die Objekte tragen
sollen, und auch das Verhalten der Objekte ist in der Klasse durch Methoden
beschrieben.
Zur Erinnerung: Die Methoden und Attribute der Objekte nennt man Instanzmethoden und Instanzvariablen. Von jeder Instanzvariable hat jedes Objekt
seine eigene, private Kopie. Instanzmethoden können nur im Zusammenhang
mit einem Objekt verwendet werden, und aus Instanzmethoden ist der direkte
Zugriff auf die Instanzvariablen des Objektes möglich.
Zum anderen kann auch eine Klasse selbst Methoden und Attribute besitzen. Die
der Klasse zugeordneten Methoden und Attribute nennt man Klassenmethoden und Klassenvariablen oder auch statische Methoden und statische
Variablen.
Von jeder Klassenvariable gibt es nur eine einzige Kopie pro Klasse, und jedes
Objekt der Klasse kann darauf zugreifen. Insofern teilen sich alle Objekte der
Klasse die Klassenvariablen. Da von jeder Klassenvariable nur ein Exemplar pro
Klasse vorhanden ist, greifen alle Objekte auf dieselben Klassenvariablen zu —
die Änderung einer Klassenvariable wirkt sich also auf alle Objekte aus, welche
diese Variable verwenden.
Ihnen ist sicher nicht klar, was wir mit dieser Unterscheidung in Instanzmethoden und Instanzvariablen auf der einen Seite und Klassenmethoden und Klassenvariablen auf der anderen Seite meinen. Nun, daß ein Objekt Methoden und
Variablen besitzt, sollte schon im vorigen Text hinreichend klar geworden sein.
Wieso aber sollte auch die Klasse Methoden und Variablen besitzen ? Dafür
gibt es einige Gründe:
• Eine Instanzmethode kann nur im Zusammenhang mit einem Objekt ausgeführt werden. Manchmal benötigt man aber Methoden, die ohne die
Existenz eines Objektes ausgeführt werden können. Ein Beispiel hierfür
ist die Ihnen schon bekannte main–Methode. Sie erst ermöglicht das Starten von Anwendungen, denn sie kann auch ausgeführt werden, ohne daß
bereits Objekte angelegt wurden.
• Oft benötigen alle Objekte einer Klasse Zugriff auf gemeinsame, von den
Objekten unabhängige Daten. Derartige Daten möchte man nicht in den
97
• Oft benötigt man in Objekten eine Funktionalität, die zwar logisch zum
Objekt gehört, aber nicht auf den Zustand des Objektes angewiesen ist,
und die man daher nicht den Objekten sondern woanders zuordnen möchte.
Hierzu verwendet man Klassenmethoden.
Wir werden Ihnen gleich erzählen, wie man diese verschiedenen Arten von Methoden und Variablen definieren kann. Vorher aber ein Beispiel, das Sie jetzt
schon verstehen können müssten:
Beispiel:
Klasse Auto a
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapKlassen/Auto.java
Die obige Klasse definiert eine Klasse namens Auto.
In der Klasse sind drei Attribute definiert:
In Zeile 6 und 7 ist ein String–Attribut namens hersteller und ein int–
Attribut namens ps definiert. Da diese Variablen nicht als statisch deklariert sind, sind sie Instanzvariablen. Jedes Auto–Objekt hat eine eigene
Kopie dieser beiden Attribute. Dabei legen die Attribute den Hersteller
des Autos und die PS–Zahl fest.
In Zeile 4 ist eine als static ausgezeichnete double–Variable namens
kwpsfaktor definiert. Diese Variable wird in Zeile 4 mit einem Zahlenwert
initialisiert, welcher zur Umrechnung von Pferdestärken in Kilowatt verwendet werden kann. Die Kennzeichnung als static macht aus kwpsfaktor
eine statische Variable bzw. eine Klassenvariable.
Der Grund, warum die Variablen hersteller und ps als Instanzvariablen
deklariert sind, ist klar — jedes Auto hat einen Hersteller und eine gewisse
PS–Zahl und braucht somit seine eigene Kopie dieser beiden Variablen.
Man kann diese Attribute von einem Auto nicht trennen.
Der Umrechnungsfaktor von PS–Werten zu Kilowatt hingegen ist für jedes
Auto gleich. Er existiert unabhängig von irgendwelchen Auto–Objekten,
und es wäre daher nicht angemessen, ihn zu einer Instanzvariable zu machen. Aus diesem Grund haben wir den Umrechnungsfaktor zu einer Klassenvariable gemacht. Damit können alle Auto–Objekte auf den Umrechnungsfaktor zugreifen, und es ist sichergestellt, daß alle Auto–Objekte
denselben Umrechnungsfaktor verwenden.
In Zeilen 9–12 sehen Sie eine Methode namens Auto. Ihnen sollte auffallen,
daß der Name dieser Methode mit dem Namen der Klasse übereinstimmt.
Derartige Methoden nennt man Konstruktoren (was das Wörtchen public
bedeutet, erzählen wir Ihnen später noch). Ein Konstruktor wird beim
Erzeugen eines Objektes benutzt, um die Instanzvariablen des Objektes
zu initialisieren.
Wir verwenden den Konstruktor zweimal — in der main–Methode in Zeile
29 wird ein Auto–Objekt namens mercedes erzeugt, und in Zeile 32 wird
98
ein Auto–Objekt namens ferrari erzeugt. Beide Male wird der Konstruktor
verwendet. Im Kapitel 10 haben wir bereits erläutert, wozu Konstruktoren
da sind. Vielleicht sollten Sie sich dieses Kapitel nochmal anschauen ?
Auch hier benutzt man den Punkt. Wenn eine Klasse namens EineKlasse eine
Klassenvariable namens klassenVar oder eine Methode klassenMethode() kann
man hierauf von außen wie folgt zugreifen:
In Zeilen 14–20 wird eine Methode void anzeigen() definiert. Dies ist eine Instanzmethode, welche ein Auto–Objekt anzeigen kann. Als Instanzmethode kann sie direkt auf die Attribute des Objektes zugreifen. Beim
Aufruf muß ihr daher ein Objekt angegeben werden.
EineKlasse.klassenVar;
// oder
EineKlasse.klassenMethode();
Die anzeigen()–Methode wird in Zeile 30 und in Zeile 33 aufgerufen. Dabei wird sie einmal im Objekt mercedes und einmal im Objekt ferrari
aktiviert.
Beachten Sie bitte auch, daß die anzeigen()–Methode auf die Klassenvariable kwpsfaktor zugreifen kann — dies geschieht in Zeile 19.
Der Punkt dient also dazu, von außen auf die Inhalte eines Objektes oder einer
Klasse zuzugreifen. Ein Objekt kann auf seine Instanzvariablen, Klassenvariablen, Instanzmethoden und Klassenmethoden direkt zugreifen. Genauso können
Sie in einer Klassenmethode direkt auf die Klassenattribute zugreifen.
In der anzeigen()–Methode wird in Zeile 17 eine Methode namens
wandlePSzuKW aufgerufen, um die PS–Zahl des Autos in den Kilowatt–
Wert umzuwandeln. Die wandlePSzuKW –Methode ist in Zeilen 22–25
definiert. Da sie als static ausgezeichnet ist, ist sie keine Instanz– sondern
eine Klassenmethode. Als solche kann sie auch auf alle Klassenvariablen
(in diesem Fall nur kwpsfaktor), nicht aber auf Instanzvariablen zugreifen.
Beispiel:
Die folgende Klasse verwendet die eben definierte Klasse Auto. Die
kompilierte Datei UseAuto.class sollte sich im gleichen Verzeichnis wie
Auto.class befinden, damit sie funktioniert:
Klasse UseAuto a
Der Grund, daß die wandlePSzuKW –Methode als Klassenmethode und
nicht als Instanzmethode definiert wurde, sollte klar sein: Die Wandlung
eines Pferdestärken in einen Kilowatt–Wert ist nicht von einem konkreten
Auto–Objekt abhängig. Es wäre daher nicht angemessen, diese Methode
als Instanzmethode zu definieren.
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapKlassen/UseAuto.java
In Zeile 5 wird ein Auto–Objekt namens vw erzeugt. Auf dessen Attribute
wird in Zeilen 7–8 zugegriffen.
Schließlich noch ein Wort zur main–Methode auf Zeile 27–34: Diese Methode ist durch die Definition als static eine Klassenmethode, ist also
nicht mit einem Objekt assoziiert. Die main–Methode macht die Klasse
ausführbar.
In Zeile 10 und 11 werden die Attribute des Objektes von außen geändert.
Der dann erfolgte Aufruf der anzeigen()–Methode beweist, daß wir von
außen den Zustand des Objektes verändert haben.
In der main–Methode werden zwei Objekte namens mercedes und ferrari
definiert, und es werden die anzeigen()–Methoden beider Objekte aufgerufen.
12.2
In Zeile 15–16 greifen wir von außen auf die Klassenvariable kwpsfaktor
zu. In Zeile 18 erdreisten wir uns sogar, diese von außen auf einen falschen
Wert zu setzen.
Da die Umrechnungsroutine der Auto–Klasse auf diese Klassenvariable
angewiesen ist, haben wir damit auch unser vw–Objekt beeinflußt — ab
sofort funktioniert die Umrechnung von PS in KW nur noch fehlerhaft,
wie der Aufruf der anzeigen()–Instanzmethode in Zeile 21 beweist.
Zugriff auf Methoden und Attribute
In Kapitel 10.4 haben wir zwar bereits beschrieben, wie man auf die Bestandteile
von Objekten zugreift. Das soll hier nochmal rekapituliert werden:
Sie können sich die Java–Philosophie so vorstellen, daß ein Objekt Attribute und
Methoden enthält. Wenn man auf die Attribute zugreifen oder die Methoden
verwenden will, muß man in das Objekt hineingreifen. Dies geschieht in Java
durch den Punkt “.”. Will man auf etwas in einem Objekt zugreifen, schreibt
man hinter den Objektnamen einen Punkt und dahinter den Namen dessen,
worauf man zugreifen möchte.
Will man von außen auf ein Attribut attribut in einem Objekt einObjekt zugreifen oder eine Methode methode() aufrufen, schreibt man
Sie sehen am vorigen Beispiel, daß man durch Eingriffe von außen die Funktionsfähigkeit einer Klasse beeinträchtigen kann. Java bietet Mechanismen an,
die derartige Eingriffe in das Innenleben von Klassen und Objekten abwehren.
In einem späteren Kapitel werden Sie lernen, wie man “wehrhafte” Objekte und
Klassen entwickeln kann, die Eingriffe von außen abweisen.
12.3
Die Bestandteile einer Java–Klasse
Genauso wie man auf die Inhalte eines Objektes zugreift, kann man auch auf
in einer Klasse enthaltene Klassenvariablen und Klassenmethoden zugreifen.
Nun endlich zum Aufbau einer Java–Klasse: Jede Java–Klasse beginnt mit der
Definition der Klasseneigenschaften — dem Klassenkopf — gefolgt von einem
Block, in welchem die Klasse definiert wird — dem Klassenkörper. Vorerst sollten Sie davon ausgehen, daß jede Klasse in einer eigenen Datei enthalten ist.
Der Name dieser Datei ist der Klassenname gefolgt von der Endung “.java”.
Die Klassendefinition hat in ihrer einfachsten Form den Aufbau
99
100
einObjekt.attribut;
// oder
einObjekt.methode();
class KlassenName // Klassenkopf
{
// Klassenkörper
}
Die Beschreibung der Klasseneigenschaften im Klassenkopf werden wir später
noch ergänzen. Beispielsweise könnte eine kompliziertere Klasse auch die folgende Eigenschaftsbeschreibung haben:
public class MyClass extends AnotherClass implements MyInterface
{
// Klassenkörper
}
Eine Klassendefinition besteht also aus zwei Teilen: Dem Klassenkopf, in welchem gewisse später zu erläuternde Eigenschaften der Klasse beschrieben werden
und dem Klassenkörper, in welchem die Klasse selbst definiert wird.
In der einfachsten Version besteht der Klassenkopf aus dem Text
class KlassenName
Das Wort class weist den Java–Compiler darauf hin, daß nun die Definition
einer Klasse folgt. Durch den hinter dem Wort class stehenden Namen erfährt
der Compiler den Namen der zu definierenden Klasse. Der Klassenkopf veranlasst den Java–Compiler, den darauf folgenden Block als Definition der im Kopf
benannten Klasse zu interpretieren.
Beachten Sie, daß sich der Klassenkörper von den Ihnen bereits bekannten Anweisungsblöcken unterscheidet — der Klassenkörper selbst enthält nämlich im
Gegensatz zu den Anweisungsblöcken keine Anweisungen sondern eine Folge von
Definitionen.
Abstrakt ist ein Klassenkörper wie folgt aufgabaut:
12.4
Attribute
Ein Attribut wird genauso definiert wie eine Variable: Es wird sein Datentyp
oder seine Klasse gefolgt von seinem Namen angegeben. Die Definition eines
Attributs muß mit einem Semikolon beendet werden.
Wenn die Objekte der Klasse eine Instanzvariable namens instanzVariable des
Datentyps Datentyp haben sollen, so wird diese wie folgt definiert (ein funktionierendes Beispiel folgt weiter unten):
Datentyp
instanzVariable;
Soll statt einer Instanzvariable eine Klassenvariable definiert werden, so schreibt
man vor die Definition das Wort “static”. Soll beispielsweise eine Klassenvariable
klassenVariable des Typs Datentyp definiert werden, so schreibt man
static Datentyp klassenVariable;
Genau wie alle Variablendefinitionen kann auch ein Klassenattribut oder ein
Instanzattribut schon bei der Definition initialisiert werden. Dazu schreibt man
hinter den Namen des Attributes direkt die Initialisierungszuweisung:
Datentyp
instanzVariable = Initialisierung;
static Datentyp klassenVariable = Initialisierung;
Wird auf diese Weise eine Instanzvariable initialisiert, so erhält diese Instanzvariable bei jedem neu erzeugten Objekt den angegebenen Wert erhält. Wird
hingegen eine Klassenvariable auf diese Weise initialisiert, so erhält die Klassenvariable noch vor der ersten Verwendung der Klasse den angegebenen Wert.
Das folgende Beispiel demonstriert die Definition von Instanzvariablen:
Beispiel:
Hier wird eine Klasse Punkt3D definiert, deren Objekte Punkte im dreidimensionalen Raum repräsentieren. Zunächst definieren wir keine Methoden sondern nur die Attribute der Objekte.
class KlassenName {
Definition_1
Definition_2
...
Definition_n
}
Objekte dieser Klasse erhalten drei double–Instanzvariablen namens x,y
und z, welche die Koordinaten des Punktes beschreiben.
Die Klasse ist in dieser Form kompilierbar aber nicht ausführbar, da sie
keine main–Methode besitzt.
Klasse Punkt3Da
Die einzelnen Definitionen definieren dabei entweder Attribute oder Methoden.
Es ist auch möglich, in einer Klasse andere Klassen zu definieren, aber das soll
zunächst außer acht gelassen werden.
Es gibt keine vorgeschriebene Reihenfolge für die einzelnen Definitionen — es ist
also nicht nötig, alle Attribute vor allen Methoden zu definieren oder umgekehrt.
Methoden– und Attribut–Definitionen dürfen in beliebiger Reihenfolge stehen.
Es empfiehlt sich allerdings, die einzelnen Definitionen zusammenzulassen. Meist
definiert man zuerst alle Attribute und danach alle Methoden.
Wie die Methoden- und Attributdefinitionen aufgebaut sein müssen, wird in den
nächsten Abschnitten erklärt.
101
1
2
3
4
5
6
7
8
class Punkt3Da {
// Koordinaten:
double x;
double y;
double z;
}
Falls wir möchten, daß jeder neu angelegte Punkt einen vorher festgelegten Zustand erhält, können wir dies dadurch erreichen, daß wir jede
Instanzvariable schon bei der Definition initialisieren.
102
Wenn wir uns entscheiden, jeden neu angelegten Punkt auf die Koordinaten (0, 0, 0) zu initialisieren, können wir das so erreichen:
Klasse Punkt3D
1
2
3
4
5
6
7
8
// Methodenkörper
}
Dabei beschreibt der Methodenkopf mindestens
class Punkt3D {
• den Namen der Methode,
// Koordinaten:
double x = 0;
double y = 0;
double z = 0;
• welche Werte die Methode zur Ausführung benötigt,
• den Typ der von der Methode zurückgelieferten Daten
}
• und ob es sich um eine Instanzmethode oder eine Klassenmethode handelt.
Beispiel: Hier noch ein Beispiel ohne tieferen Sinn, in welchem auch
Klassenvariable verwendet werden:
Klasse InstKlassVar
1
2
3
4
5
6
7
8
9
static double klassenVar1 = 0;
static double klassenVar2 = 1.3;
double instanzVar1 = 3;
double instanzVar2 = 5;
void nichtsTun() {
}
Diese Methode hat einen leeren Methodenkörper und tut daher beim Aufruf gar nichts.
}
Der Methodenkopf legt fest, daß die Methode den Namen “nichtsTun”
hat. Das Wort “void” bedeutet, daß sie keinen Wert zurückliefert.
Beispiel:
Das folgende Beispiel verwendet die oben definierte Klasse Punkt3D, um
eine Linie von einem Punkt zum anderem im dreidimensionalen Raum zu
beschreiben.
Eine Linie ist dabei gegeben durch zwei Eckpunkte, welche wir punkt1
und punkt2 nennen, und welche Objekte der Klasse Punkt3D sind:
Klasse Linie
12.5
Beispiel: Die wohl einfachste Methode wird so definiert:
class InstKlassVar {
Und noch eine hoffentlich überflüssige Bemerkung: Als Attribute können natürlich
nicht nur primitive Daten sondern auch Objekte anderer Klassen verwendet werden.
1
2
3
4
5
Der Methodenkörper besteht aus einer Folge von Anweisungen, welche bei jeder
Ausführung der Methode abgearbeitet werden.
class Linie {
Punkt3D punkt1, punkt2;
}
Der Methodenkopf ist in Java genauso wie in Kapitel ?? beschrieben aufgebaut. Eine Instanzmethode namens methodenName, welche einen Wert des Typs
RueckgabeTyp zurückliefert und zur Ausführung Werte der Datentypen Typ1
bis TypN benötigt, welche dann in der Methode unter den Bezeichnern wert1
bis wertN angesprochen werden können, wird wie folgt definiert:
RueckgabeTyp instanzMethode( Typ1 wert1, ... TypN wertN )
Falls eine Methode keinen Wert zurückliefern soll, wird als Rückgabe–Typ der
Typ void verwendet (eng. void: leer, ungültig). Die zur Ausführung der Methode
benötigten Werte wert1 bis wertN nennt man auch formale Parameter der
Methode.
Soll eine Methode nicht als Instanz– sondern als Klassenmethode definiert werden, so ist vor die Methodendefinition noch das Wort “static” zu setzen:
static RueckgabeTyp klassenMethode( Typ1 wert1, ... TypN wertN )
Definition von Methoden
Auch eine Methodendefinition besteht aus zwei Teilen, nämlich dem Methodenkopf und dem Methodenkörper. Abstrakt hat eine Methodendefinition folgenden
Aufbau:
Vom Aufbau unterscheiden sich Klassen– und Instanzmethoden ansonsten nicht
— der Unterschied ist der, daß innerhalb von Instanzmethoden auf alle Instanzvariablen eines Objektes sowie auf alle Klassenvariablen der Klasse zugegriffen
werden kann, während aus Klassenmethoden nur auf die Klassenvariablen, nicht
aber auf Instanzvariablen zugegriffen werden kann.
Beispiel: Hier einige Beispiele für gültige Methodenköpfe:
Methodenkopf {
103
104
1
2
3
4
5
void anzeigen()
static void zeilenVorschub( int anzahlZeilen )
static double summiere( double[] werte )
double[] sortiere( double[] werte )
static int searchIndex( String[] stringListe, String s2 )
Beschreibung der obigen Methodenköpfen:
1. Eine Instanzmethode namens anzeigen, welche keine Argumente entgegennimmt und keinen Wert zurückliefert.
2. Eine Klassenmethode namens zeilenVorschub, welche einen Parameter vom Typ int entgegennimmt, welcher in der Methode unter dem
Namen anzahlZeilen angesprochen werden kann. Diese Methode liefert keinen Wert zurück.
3. Eine Klassenmethode namens summiere, welche ein Array von
double–Werten entgegennimmt und einen double–Wert zurückliefert. Das Array kann im Methodenkörper unter der Variabel werte
angesprochen werden.
4. Eine Instanzmethode namens sortiere, welche ein double–Array
zurückliefert und ein Array aus double–Werten namens werte entgegennimmt.
5. Eine Klassenmethode namens searchIndex, welche ein String–Array
namens stringListe und einen String namens s2 entgegennimmt und
eine int–Wert zurückliefert.
Der Methodenkörper besteht aus einer Folge von Anweisungen. Wenn im Methodenkopf Übergabeparameter beschrieben sind, so kann im Methodenkörper auf
diese genauso wie auf alle anderen Variablen zugegriffen werden. Dabei werden
die formalen Parameter bei jedem Aufruf der Methode durch die Aufrufsparameter ersetzt.
Ist eine Methode nicht als void gekennzeichnet, so muß sie ein Ergebnis an
den Aufrufer zurückübermitteln. Dazu wird der return–Befehl verwendet. Der
return–Befehl gibt einen Wert zurück und beendet dabei die Bearbeitung der
Methode.
In einer Methode darf der return–Befehl beliebig oft verwendet werden. Es dient
aber normalerweise nicht der Übersichtlichkeit und dem besseren Verständnis
des Programmes, wenn man viele return–Befehle in einer Methode benutzt.
Abstrakt wird der return–Befehl wie folgt benutzt:
So wäre die Methode korrekt:
int rechne( int wert ) {
return (int) (wert * 1.355);
}
Der return–Befehl darf auch in einer als void deklarierten Methode verwendet
werden, um die Methodenbearbeitung abzubrechen und zum Aufrufer der Methode zurückzukehren. In einer void–Methode muß allerdings nicht unbedingt
ein return stehen, denn am Ende eines jeden Methodenkörpers wird vom Java–
Compiler automatisch ein return eingefügt.
In einer void–Methode darf kein Wert zurückgegeben werden. Die Verwendung
des return–Befehles in einer void–Methode sieht so aus:
return;
Beispiel: Hier ein Beispiel für eine void–Methode, in der mehrere return–
Befehle auftauchen. Wenn man sehr viele Fallunterscheidungen hat, kann
es Sinn machen, mehrere return–Befehle in einer Methode zu haben. Normalerweise sollten Sie das jedoch vermeiden. In dieser einfachen Methode
ist die Verwendung mehrerer return–Befehle kein guter Programmierstil:
/** Beispiel für unschöne Verwendung mehrerer return--Befehle
*/
void intervallausgabe( int i ) {
if( i < 0) return;
System.out.println("i ist >= 0");
if( i < 10) return;
System.out.println("i ist >= 10");
if( i < 20) return;
System.out.println("i ist >= 20");
}
Hier folgt die Methode nochmal ohne Verwendung von return–Befehlen.
Durch die Verwendung geschachtelter if –Befehle wird die Struktur der
Methode im Gegensatz zur ersten Version auf den ersten Blick klar.
void intervallausgabe( int i ) {
if( i >= 0) {
System.out.println("i ist >= 0");
return Wert;
Der zurückgegebene Wert muß dabei den Datentyp haben, welchen die Methode
zurückliefern soll.
if( i >= 10) {
System.out.println("i ist >= 10");
Beispiel: Die folgende Methode würde zu einem Kompilierfehler führen,
if( i >= 20) {
System.out.println("i ist >= 20")
}
denn die Methode ist als int deklariert. Der Wert, der im return–Befehl
zurückgegeben wird, ist aber ein double–Wert.
}
int rechne( int wert ) {
return wert * 1.355;
}
}
}
105
106
Nun sollen noch einige Beispiel–Methoden gezeigt und besprochen werden.
Beispiel: Die folgende Klasse enthält eine Klassenmethode namens
quadriereWerte und eine Klassenmethode namens durchschnitt:
Klasse DemoMethode
a
Methode bei einem Aufruf gemeint ist, müssen sich die Methoden dann durch
die geforderten Parameter unterscheiden.
Beispiel: In der folgenden Klasse ist die Methode max zweimal definiert
— einmal als Methode, welche zwei int–Werte akzeptiert und einmal als
Methode, welche zwei double–Werte akzeptiert.
Klasse MethodenDemo a
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapKlassen/DemoMethode.java
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapKlassen/MethodenDemo.java
Die Klassenmethode quadriereWerte ist als void deklariert und hat einen
formalen Parameter, der innerhalb der Methode als werte angesprochen
werden kann und vom Typ double[] ist. Da die Methode als void deklariert ist, muß in ihr kein return–Befehl stehen. Auf den formalen Parameter kann in der Methode (z.B. in Zeile 5) zugegriffen werden wie auf jede
andere Variable auch.
In Zeilen 25 und 26 wird die Methode verwendet. Dabei wird anstelle des
formalen Parameters werte einmal die Variable w1 und einmal die Variable w2 eingesetzt. In der Methode wird dann der Inhalt der Parameter
verändert.
Auch die durchschnitt–Methode hat einen formalen Parameter namens
werte. Da sie keine void–Methode ist, muß sie mit return einen Wert
zurückliefern.
Beispiel: Nun noch ein Beispiel mit einigen Instanzmethoden:
Wir erweitern die Punkt3D–Klasse aus dem vorigen Abschnitt um zwei
Methoden: Die Methode show zeigt einen Punkt auf dem Bildschirm an,
die Methode norm berechnet die Euklidische Norm des Punktes, die Methode move verschiebt den Punkt um eine gewisse Distanz, indem die
Koordinaten eines anderen Punktes addiert werden:
Klasse Punkt3D a
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapKlassen/Punkt3D.java
Beispiel: Und hier noch ein Beispiel, welches das vorige Beispiel verwendet. Die Klasse Linie3D muß im selben Verzeichnis gespeichert sein wie
die Klasse Punkt3D.
Klasse Linie3D a
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapKlassen/Linie3D.java
12.6
Mehrere Methoden mit gleichem Namen
Immer wenn Java einen Methodenaufruf sieht, geht es folgendermaßen vor:
• Zuerst schaut es nach, ob in der Klasse eine Methode definiert ist, die zu
den aktuellen Parametern im Methodenaufruf stehen.
Im obigen Beispiel geschieht der Aufruf in Zeile 20 mit zwei int–Werten
und in Zeile 21 mit zwei double–Werten. Dem Compiler ist also sofort
klar, daß der Aufruf in Zeile 20 die erste max–Methode auf Zeile 3–9 und
der Aufruf in Zeile 21 die max–Methode auf Zeile 11–17 meint.
• Wenn auf die Parameter im Methodenaufruf keine Methode passt, so
schaut der Compiler nach, ob er die Argumente im Methodenaufruf in
einen anderen Typ verwandeln kann, so daß der Aufruf dann auf eine Definition paßt. Beim Wandeln der Typen werden die Regeln aus Kapitel 8
verwendet.
Im obigen Beispiel werden im Aufruf in Zeile 22 ein int und ein double–
Wert verwendet. Eine solche Methode kennt der Compiler nicht. Er kann
aber den int–Wert in einen double–Wert verwandeln und dann die double–
Methode verwenden.
Kurz gesagt: Sie können beliebig viele Methoden des gleichen Namens schreiben,
wenn es eine eindeutige Möglichkeit gibt, anhand der übergebenen Parameter
herauszufinden, welche Methode gemeint ist.
Sie können insbesondere nicht zwei Methoden schreiben, die sich nur durch den
Rückgabewert unterscheiden. Warum ist das so ? Nun, man muß ja den Rückgabewert einer Methode nicht unbedingt verwenden. Zum Beispiel ist folgender
Programmtext legal:
int rechne(int i) {
return i * 2;
}
public static void main(String[] args) {
rechne(5);
reche(3);
}
Java hat eine Fähigkeit, die nur wenige andere Sprachen bieten: Es ist möglich,
mehrere Methoden mit gleichem Namen zu benutzen. Damit Java weiß, welche
Wenn Sie nun mehrere Methoden definieren, die die gleichen Parameter definieren aber unterschiedliche Rückgabewerte haben, hätte Java keine Möglichkeit
herauszufinden, welche Methode Sie meinen.
107
108
Beispiel: Das folgende Beispiel würde nicht kompilieren, da sich die bei-
Beispiel:
den Methoden nur durch den Rückgabewert unterscheiden.
Klasse ParamUebergabe a
public class MethodenDemo2 {
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapKlassen/ParamUebergabe.java
int rechne( int i ) {
return i*2;
}
Wenn Sie das Programm starten, erhalten Sie folgende Ausgabe:
double rechne( int i ) { // Fehler
return i*3.0;
}
a ist 3
a ist jetzt 5
In main ist i = 3
a[0] ist 2
a[0] ist jetzt 5
In main ist arr[0] = 5
}
12.7
Konstruktoren
Konstruktoren sind besondere Methoden, welche beim Erzeugen von Objekten benutzt werden. Jedesmal wenn ein Objekt erzeugt wird, wird vom Java–
Laufzeitsystem zunächst Speicher für das Objekt bereitgestellt, d.h. für jede
Instanzvariable des Objektes wird Speicher belegt.
Anschließend wird ein Konstruktor aufgerufen. Der Konstruktor dient dazu,
die Instanzvariablen des Objektes zu initialisieren. Ein Konstruktor ist eine
Methode, deren Namen gleich dem Namen der Klasse ist.
Eine Klasse darf mehrere Konstruktoren besitzen. Welcher Konstruktor bei der
Erzeugung eines Objektes aufgerufen wird, richtet sich nach den beim Erzeugen
des Objektes durch den new–Operator übergebenen Parametern
Beispiel: Die folgende Klasse PunktND repräsentiert einen Punkt im
N –dimensionalen Raum. Sie enthält drei Konstruktoren:
Klasse PunktND a
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapKlassen/PunktND.java
Der erste Konstruktor, PunktND() wird in Zeilen 9–14 definiert. Er wird
in Zeile 39 aufgerufen. Beachten Sie bitte, daß in Zeile 39 zwar durch den
new–Operator ein neues Objekt angelegt wird; dieses wird aber keiner
Variable zugewiesen.
Der zweite Konstruktor, PunktND( double[] ) wird in Zeilen 15–20 definiert. Er wird in Zeile 42 verwendet.
In
Zeile
22–27
wird
ein
weiterer
Konstruktor,
PunktND(double,double,double) definiert, welcher auf Zeile 45 verwendet wird. Auch hier wird das durch den new–Operator erzeugte
Objekt keiner Variable zugewiesen.
Wie Sie sehen, wirkt sich die Änderung des Parameters a innerhalb der ersten
change–Methode nicht auf die Variable i im Hauptprogramm aus.
Hingegen wirkt sich die Änderung am Array in der zweiten change–Methode
auf das Hauptprogramm aus.
Den Grund für dieses unterschiedliche Verhalten haben wir bereits in einem vorigen Kapitel erklärt — in Kapitel 11.5 haben wir Ihnen den Unterschiend zwischen Referenztypen und primitiven Typen erläutert. Genau dieser Unterschied
ist es, der bewirkt, daß das Array in der Methode verändert, die int–Variable
jedoch nicht.
Wenn Java einen Methodenaufruf sieht, so erzeugt es für jeden Parameter der
Methode eine Variable und weist diesen die übergebenen Variablen zu.
Wenn Sie sich noch an die Ausführungen über die Referenztypen erinnern, sollte
Ihnen nun sofort einleuchten, warum die Variable des primitiven Datentyps nicht
verändert und die Array-Variable verändert wurde.
12.9
Zusammenfassung
Sie sollten nun die folgenden Fragen beantworten können:
• Was ist der Unterschied zwischen Klassen- und Instanzvariablen ?
• Was ist der Unterschied zwischen Klassen- und Instanzmethoden ?
• Auf welche Variablen kann in einer Klassenmethode zugegriffen werden ?
Auf welche Variablen kann in einer Instanzmethode zugegriffen werden ?
• Wie greift man auf eine Klassenvariable zu, wie greift man auf eine Instanzvariable zu ?
• Wie unterscheidet sich ein Klassenkörper von einem Anweisungsblock ?
12.8
Die Parameterübergabe an eine Methode
Wie werden Parameter an eine Methode übergeben ? Das wollen wir am folgenden Beispielprogramm besprechen:
109
• Wie definiert man Klassenvariablen und Instanzvariablen ?
• Wie unterscheiden sich Klassenmethoden und Instanzmethoden ?
110
• Wie definiert man einen Konstruktor und was tut er ?
13
• Unter welchen Umständen dürfen innerhalb einer Klasse mehrere gleichnamige Instanz- oder Klassenmethoden definiert sein ?
Es ist sehr wichtig, seine Programme zu dokumentieren, denn wenn Sie Ihre Programme in einigen Monaten nochmal anschauen, wissen Sie meist nicht mehr,
wozu diese oder jene Klasse da ist und was welche Methode oder Variable tut.
Üblicherweise schreibt man seine Dokumentation in den Klassencode. Wenn
man dann später etwas über eine Klasse in Erfahrung wissen will, kann man
den Quelltext öffnen und lesen.
Zur Erzeugung übersichtlicher Dokumentation gibt gibt es für Java das Werkzeug javadoc. Diese extrahiert die Dokumentation aus einer Klasse und schreibt
sie in Html–Dateien, welche dann mit einem WWW–Browser betrachtet werden
können. Auf diese Weise kann man seine eigenen Klassen mit einer Hypertext–
Dokumentation16 versehen.
Sie haben bereits die Dokumentation des Java–API kennengelernt. Sie wurde
mit diesem Werkzeug erzeugt. Wäre das Java–API nicht in Form von HTML–
Dateien oder einem anderen Hypertext–Format dokumentiert, wäre es sicher
schwerer, sich darin zurechtzufinden.
• Besprechen Sie die Unterschiede zwischen Primitiven Datentypen und Referenztypen bei der Wertübergabe an eine Methode.
13.1
Dokumentieren von Java–Programmen
Wie arbeitet javadoc ?
Javadoc nimmt eine oder mehrere Java–Quelltextdateien entgegen und erzeugt
aus diesen Dokumentation im HTML–Format. Die erzeugten Dateien dokumentieren die angegebenen Klassen, Methoden und Instanzvariablen. Zur Dokumentation werden dabei in den Quelltexten gefundene besondere Kommentare
verwendet, welche man auch javadoc–Komentare nennt.
Ein javadoc–Kommentar sieht aus wie ein normaler mehrzeiliger Kommentar,
nur beginnt er nicht mit den Zeichen /* sondern mit den Zeichen /**.
Ein Javadoc–Kommentar könnte so aussehen:
/**
*
*/
Ein Javadoc -- Komentar
Jeder gefundene Javadoc–Kommentar wird von Javadoc als Dokumentation der
nachfolgenden Klasse, Instanzvariable, Klassenvariable oder Methode interpretiert.
Um javadoc zu starten, geben Sie auf der Kommandozeile den Befehl “javadoc”
gefolgt von den Namen aller zu verarbeitenden Dateien ein:
> javadoc datei1.java datei2.java ...
Um alle Dateien in einem Verzeichnis zu dokumentieren könnten Sie eingeben:
> javadoc *.java
Beispiel: Am besten schauen wir uns die Arbeit von javadoc an einem
Beispiel an. Die folgende Klasse tut keine sinnvollen Dinge, zeigt aber den
Einsatz von javadoc–Kommentaren:
16 Unter Hypertext versteht man einen Text, in welchem man sich mit Hilfe von Mausklicks
zwischen einzelnen Textteilen bewegen kann
111
112
Klasse DemoDoc a
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/KapJavaDoc/DemoDoc.java
Bitte speichern Sie die obige Datei in einem eigenen Verzeichnis, wechseln
in das Verzeichnis und geben dann ein:
> javadoc -private DemoDoc.java
Hieraufhin werden mehrere HTML–Dateien erzeugt, von denen uns
zunächst nur die DemoDoc.html–Datei interessiert. Sie beschreibt die
Klasse. Am besten sehen Sie sich die Datei in einem WWW–Browser an.
Schauen Sie sich auch die anderen erzeugten Dateien an.
Die Option -private im obigen Befehl haben wir deshalb verwendet, weil
Sie sich vermutlich noch nicht mit dem Zugriffsschutz von Objektattributen auskennen — normalerweise läßt man das Wort -private weg. Dann
erscheinen in der Html–Ausgabe nur Methoden und Variablen, die entweder als “public” oder als “protected” definiert sind.
Im fünften Hausaufgabenblock ist ein Beispiel mit mehreren Klassen enthalten,
welches mit javadoc dokumentiert ist. Nachdem Sie dieses Beispiel durchgearbeitet haben, sollte Ihnen der Umgang mit Javadoc sofort einsichtig werden.
Zu Javadoc gibt es in der von Sun bereitgestellten Dokumentation des Java–API
weitere Informationen, die hier nicht wiederholt werden sollen. Wenn Sie selber
Javadoc–Kommentare schreiben wollen, schauen Sie dabei am besten entweder
auf der lokalen WWW–Seite
http://www.tu-bs.de:82/wir/EIP/jdk1.1.8/docs/tooldocs/solaris/javadoc.html
oder auf der WWW–Seite von Sun auf
14
Vererbung — Extensionen von Klassen
Sie haben bisher Klassen als Mittel kennengelernt, um Konzepte im Computer
als Einheit von Daten und Verhalten zu repräsentieren. Die objektorientierte
Methodik wäre heute nicht so verbreitet, wenn das Zusammenfügen von Daten
und Methoden der einzige Zweck von Klassen wäre.
Die objektorientierte Methodik wird erst dadurch zu einem mächtigen Werkzeug, daß wir gleichartiges Verhalten verschiedener Klassen in einer abstrakteren
Klasse zusammenfassen können.
Um mehrere Klassen zu einer abstrakteren zusammenzufassen, suchen wir nach
Klassen, die im Rahmen unserer Anwendung ähnliche Aufgaben haben oder
ähnliche Dinge beschreiben. Dann abstrahieren wir von diesen Klassen und erarbeiten ein gedankliches Konzept, welches die entscheidenden Merkmale und
das gemeinsame Verhalten dieser Klassen enthält.
Dieses Konzept implementieren wir dann als Klasse. Dabei wird alles Verhalten, das den ursprünglichen Klassen gemeinsam ist, in der abstrakteren, übergeordneten Klasse implementiert. Das gemeinsame Verhalten muß dann nicht
mehrfach in jeder der spezielleren Klassen implementiert werden sondern kann
von der abstrakteren Klasse übernommen (man sagt auch “vererbt”) werden.
Indem man Verhalten vererbt, spart man sich nicht nur viel Programmierarbeit;
die Programme werden auch übersichtlicher und leichter wartbar.
14.1
Ein einführendes Beispiel
Angenommen, wir schreiben ein Spiel, in welchem die Hauptfigur verschiedene
Fahrzeuge wie Auto, LKW, Fahrrad oder Kutsche verwenden soll. Jedes dieser Fahrzeuge kann von der Hauptfigur des Spiels gefahren werden, und die
motorisierten Fahrzeuge müssen tanken, sobald der Tank leer ist.
Wir könnten nun 4 verschiedene Klassen bilden:
http://www.javasoft.com/products/jdk/1.1/docs/tooldocs/solaris/javadoc.html
Auto
nach.
13.2
Zusammenfassung
Fahrrad
LKW
Kutsche
double geschwindigkeit
double tankFuellstand
double geschwindigkeit
double tankFuellstand
double geschwindigkeit
double geschwindigkeit
void fahren()
void tanken()
void fahren()
void tanken()
void fahren()
void fahren()
Nach Lesen dieses Kapitels
• sollten Sie wissen, was javadoc tut,
• wie man javadoc einsetzt,
• wie es prinzipiell arbeitet und
• wo Sie weitere Informationen zu javadoc erhalten können.
113
All diese Klassen beschreiben ein Fahrzeug, und vermutlich wäre die fahren()–
Methode in allen Klassen ähnlich. Wir können daher diese vier Klassen in
einer abstrakteren Klasse zusammenfassen, welche wir Fahrzeug nennen. Die
Fahrzeug–Klasse würde dabei alle Attribute und Methoden enthalten, welche
mit dem eigentlichen Vorgang des fahrens zusammenhängen. Sie enthielte also
das Attribut geschwindigkeit und die Methode fahren().
Auch die tanken()–Methode in den Klassen Auto und LKW wären annähernd
identisch (sie würde den Füllstand des Tanks hochsetzen). Wir können daher
die Attribute und Methoden, die mit dem Tanken zusammenhängen in einer
gemeinsamen Klasse namens Motorisiertes Fahrzeug zusammenfassen.
Eine Klasse Unmotorisiertes Fahrzeug würden wir übrigens nicht einführen, da
wir in den Klassen Fahrrad und Kutsche kein eigenständiges Verhalten beschrieben haben, das man allen unmotorisierten Fahrzeugen zuschreiben könnte.
114
Das Verhältnis zwischen all diesen Klassen sieht nun wie folgt aus: Jedes Auto
und jeder LKW ist ein Motorisiertes Fahrzeug. Jedes Motorisierte Fahrzeug
ist auch ein Fahrzeug. Wir meinen hiermit, daß jede Instanz der Klasse Auto
und jedes LKW –Objekt gleichzeitig auch eine Instanz der Klasse Motorisiertes
Fahrzeug ist. Jedes Objekt der Klasse Motorisiertes Fahrzeug ist gleichzeitig ein
Objekt der Klasse Fahrzeug.
Auch jedes Objekt der Klasse Fahrrad oder Kutsche ist gleichzeitig ein Objekt
der Klasse Fahrzeug.
Wir können diese Beziehungen in einem Diagramm darstellen. Wenn jede Instanz der Klasse B auch eine Instanz der Klasse A ist, machen wir einen Pfeil
von Klasse B zu Klasse A. Das resultierende Klassendiagramm sieht wie folgt
aus:
Extension
Ein anderer Begriff für Erweiterung.
erben
Eine Klasse B erbt von Klasse A, wenn sie eine Erweiterung von Klasse A ist. Wenn eine Kindklasse von einer
Elternklasse erbt, so übernimmt sie alles in der Elternklasse beschriebene Verhalten.
Wir haben ein Java–Programm vorbereitet, welches die obige Klassenhierarchie
implementiert. Es ist allerdings zum Abdrucken etwas lang — wir besprechen
es mit weiteren Beispielen in Kapitel 14.6.
14.2
Erweitern von Klassen
Eine Erweiterung einer Klasse Elternklasse wird definiert, indem im Klassenkopf
der Text extends Elternklasse angefügt wird:
Fahrzeug
double geschwindigkeit
class Kindklasse extends Elternklasse {
// Klassenkoerper
}
void fahren()
Motorisiertes Fahrzeug
Fahrrad
double tankFuellstand
Kutsche
void tanken()
Der Effekt ist ungefähr der gleiche als hätten Sie alle Definitionen aus dem
Klassenkörper der Elternklasse in Ihre neue Klasse Kindklasse kopiert.
Die Kindklasse enthält dann alle in der Elternklasse vorgenommenen Definitionen plus die im Klassenkörper der Kindklasse getätigten Definitionen.
Beispiel:
Auto
LKW
Beispiel: Erweitern einer Klasse
Wir verwenden im weiteren folgende Begriffe:
Elternklasse/Vorfahre Eine Klasse A ist eine Elternklasse oder ein Vorfahre von
Klasse B, wenn jedes Objekt von Klasse B gleichzeitig
Objekt von Klasse A ist.
Im vorigen Beispiel ist die Klasse Motorisiertes Fahrzeug
Elternklasse von Auto und LKW . Die Klasse Fahrzeug
ist eine Elternklasse der Klassen Motorisiertes Fahrzeug,
Fahrrad Kutsche, Auto und LKW .
Dabei ist die Fahrzeug–Klasse nur indirekter Vorfahre
der Klassen Auto und LKW aber direkter Vorfahre der
Klassen Fahrrad, Kutsche und Motorisiertes Fahrzeug.
Super–Klasse
Ein anderer Begriff für Elternklasse oder Vorfahre.
Erweiterung
Eine Klasse B ist eine Erweiterung von Klasse A, wenn
Klasse A eine Elternklasse für Klasse B ist.
Im obigen Beispiel ist die Fahrrad–Klasse eine Erweiterung der Fahrzeug–Klasse; die Auto–Klasse ist eine
Erweiterung der Klasse Motorisiertes Fahrzeug und eine Erweiterung der Klasse Fahrzeug.
Kindklasse
Ein anderer Begriff für Erweiterung.
115
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Point {
double x, y;
void move(double dx, double dy) {
x+=dx;
y+=dy;
}
}
class LabeledPoint extends Point {
String label;
void setLabel(String newLabel) {
label = newLabel;
}
}
Die Klasse Point stellt einen Punkt mit Koordinaten (x, y) dar, welcher
durch die move–Methode verschoben werden kann.
Die Klasse LabeledPoint stellt einen Punkt dar, welcher zusätzlich eine
Beschriftung trägt. Indem in Zeile 9 die Klasse LabeledPoint als Erweiterung der Klasse Point definiert wird, übernimmt LabeledPoint alle Definitionen der Klasse Point. Ein ähnliches Ergebnis hätten wir also erhalten,
wenn wir die Klasse LabeledPoint wie folgt definiert hätten:
116
Beispiel: Erweiterte Klasse
1
2
3
4
5
6
7
8
9
10
11
12
13
Beispiel:
Beispiel: Methoden überschreiben
class LabeledPoint2 {
double x, y;
String label;
void move(double dx, double dy) {
x+=dx;
y+=dy;
}
void setLabel(String newLabel) {
label = newLabel;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Point {
double x, y;
String getDescription() {
return "Punkt";
}
}
class LabeledPoint extends Point {
String label;
String getDescription() {
return "Punkt mit Label";
}
}
Die Übernahme von Definitionen aus der Elternklasse geschieht nach folgenden
Regeln:
• Wenn eine Kindklasse eine Elternklasse erweitert, so werden bis auf Konstruktordefinitionen alle Definitionen der Elternklasse übernommen (Sie
können davon jedoch einige Definitionen ausnehmen — wie das geht, erfahren Sie im Kapitel über “Zugriffsschutz: private, protected, public”).
Die Kindklasse erhält somit alle Instanzvariablen, Klassenvariablen, Instanzmethoden und Klassenmethoden der Elternklasse. All diese Dinge
haben in der Kindklasse die gleiche Definition wie in der Elternklasse.
• Definitionen der Elternklasse können in der Kindklasse verdeckt werden,
indem eine Definition gleicher Signatur vorgenommen wird (das wird im
nächsten Beispiel klar). Man sagt hierzu auch, daß eine Definition “überschrieben” wird.
Zwei Variablen haben dabei die gleiche Signatur, wenn sie den gleichen
Namen haben. Zwei Methoden besitzen die gleiche Signatur, wenn sie den
gleichen Namen haben und die gleichen formalen Parameter entgegennehmen.
• Beim Vererben werden alle Definitionen, die die Elternklasse selbst geerbt hat, weiter vererbt. Hat die Elternklasse eine Methode oder Variable
mit einer neuen Definition überschrieben, so wird nur die überschriebene
Version der Elternklasse weitervererbt.
Hier wird die getDescription()–Methode überschrieben. Objekte der Klasse LabeledPoint liefern daher beim Aufruf der getDescription()–Methode
immer den Text “Punkt mit Label” zurück.
Beispiel: Methoden überladen
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Point {
double x, y;
String getDescription() {
return "Punkt";
}
}
class LabeledPoint extends Point {
String label;
String getDescription(boolean outputFlag) {
if( outputFlag ) {
return "Punkt mit Label";
} else {
return "";
}
}
}
Hier wird die getDescription()–Methode nicht überschrieben, da die
getDescription–Methode in der Klasse LabeledPoint nicht die gleiche Signatur wie in der Klasse Point hat.
Wie schon erwähnt, können Methoden und Variablen in der Unterklasse überschrieben werden — da es sich in der Regel nicht empfiehlt, Variablen eines
gewissen Typs mit einer Variable eines anderen Typs zu überschreiben, gehen
wir hier nur auf das Überschreiben von Methoden ein.
Eine Methode in der Oberklasse wird immer dann überschrieben, wenn in der
Unterklasse eine Methode mit gleicher Signatur definiert wird. Dabei haben
zwei Methoden die gleiche Signatur, wenn sie den gleichen Namen haben und
die gleichen Parameter entgegennehmen.
Die objektorientierte Methodik ist zum Teil deshalb so mächtig, weil ererbte
Routinen in der Lage sind, überschriebene Routinen aufzurufen. Um dies zu
verstehen, stellen Sie sich den Methodenaufruf am besten als das Verschicken
von Botschaften vor:
Immer wenn ein Objekt eine Botschaft erhält, schaut es nach, ob in seiner Klasse
eine Methode für diese Botschaft definiert ist. Wenn ja, benutzt es diese Methode. Wenn nein, schaut es in seiner Oberklasse nach und benutzt gegebenenfalls
die dort definierte Methode. Wenn auch in seiner Oberklasse keine passende
Methode definiert ist, so schaut es in der Oberklasse seiner Oberklasse nach
und so weiter.
Entscheidend ist hier, daß das Objekt dies für jede Botschaft tut, die es erhält,
117
118
14.3
Überschreiben von Methoden
selbst wenn die Botschaft in seiner Oberklasse abgesetzt wurde. Schauen Sie
sich das folgende Programmfragment an:
Beispiel: Überschreiben und Botschaften
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Point {
double x, y;
String getDescription() {
return "Punkt (" + x + "," + y + ")";
}
void output() {
System.out.println( getDescription() );
}
}
class LabeledPoint extends Point {
String label;
String getDescription() {
return "Punkt mit Label:" + label;
}
}
Was passiert in diesem Beispiel, wenn man einem Objekt der Klasse LabeledPoint
die Botschaft “output()” schickt ? Sie müssten die Frage bereits beantworten
können.
Hier die Antwort: Zuerst schaut das LabeledPoint–Objekt in seiner Klasse nach,
ob es dort eine Methode namens output() findet. Da das nicht der Fall ist,
schaut es dann in seiner Oberklasse Point nach und findet dort die output()–
Methode von Zeile 8–10. Nun wird der Programmtext dieser output()–Methode
ausgeführt.
Bei der Ausführung des Programmtextes wird in Zeile 9 an das Objekt die
Botschaft getDescription() geschickt. Obwohl dies im Programmtext der Klasse
Point geschieht, ist unser Objekt immer noch ein Objekt der Klasse LabeledPoint.
Es schaut daher zuerst in der LabeledPoint–Klasse nach und findet dort die
getDescription()–Methode aus Zeilen 16–17. Nun führt es den in der LabeledPoint
enthaltenen Programmtext der getDescription()–Methode aus.
Es ist also ohne weiteres möglich, daß in der Oberklasse definierte Methoden
Programmtext aufrufen, der in den Unterklassen überschrieben wurde. Es ist
daher möglich, in einer Oberklasse sehr abstrakt formulierten Programmtext zu
schreiben und die Details erst in den Unterklassen einzusetzen.
14.4
Die super–Variable
Das Überschreiben von Methoden wird dann zum Problem, wenn man die überschriebene Methode weiterverwenden möchte — oft verändert die überschreibende Methode das Verhalten der überschriebenen Methode nur minimal, und so
möchte man die Möglichkeit haben, die überschriebene Methode zu verwenden
und vielleicht ihr Resultat zu modifizieren.
Um dies zu ermöglichen, trägt jedes Objekt in sich eine Variable namens super.
Immer wenn man innerhalb des Objektes diese Variable anspricht, spricht man
das Objekt als Instanz seiner Oberklasse an.
119
Beispiel: Verwendung von super
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Point {
double x, y;
String getDescription() {
return "Punkt (" + x + "," + y + ")";
}
void output() {
System.out.println( getDescription() );
}
}
class LabeledPoint extends Point {
String label;
String getDescription() {
return super.getDescription() + " mit Label: " + label;
}
}
Im obigen Programmtext benutzen wir in der überschreibenden getDescription()–
Routine die super–Variable, um die überschriebene getDescription()–Methode
von Zeile 4–6 aufzurufen.
Die super–Variable ermöglicht also den Zugriff auf überschriebene Methoden.
14.5
Vererbung und Konstruktoren
Wie schon erwähnt, erbt ein Objekt von seiner Oberklasse alle Definitionen,
nicht aber Konstruktoren. Es ist aber häufig nötig, Konstruktoren der Oberklasse aufzurufen.
Hier ein Beispiel:
Beispiel: Vererbung und Konstruktoren
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Point {
double x, y;
Point( double newX, double newY ) {
x = newX;
y = newY;
}
}
class LabeledPoint extends Point {
String label;
LabeledPoint( double newX, double newY, String newLabel ) {
x = newX;
y = newY;
label = newLabel;
}
}
Dieser Programmtext ist nicht besonders gut. Wir haben im LabeledPoint–
Konstruktor nämlich Programmtext wiederholt, der eigentlich in die Klase Point
gehört. Damit greifen wir auf Interna der Klasse Point zu, die die vererbte
Klasse nicht zu interessieren haben (Kinder sollten nicht alle Geheimnisse der
Eltern kennen, das gilt auch beim objektorientierten Programmieren). Wenn
120
sich später irgendwann der Konstruktor für Point ändert, müssten wir auch den
Programmtext für den LabeledPoint–Konstruktor ändern.
Statt dessen sollten wir den Konstruktor der Oberklasse direkt verwenden. Dies
geschieht auch mit Hilfe des super–Schlüsselwortes, allerdings wird es jetzt nicht
wie vorhin als Variable sondern als Methode verwendet:
Beispiel: Konstruktoren der Oberklasse aufrufen
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Point { double x, y;
Point( double newX, double newY ) {
x = newX;
y = newY;
}
}
Beispiel: Das Beispiel vom Anfang
Am Anfang des Kapitels haben wir Klassenhierarchien am Beispiel verschiedener Fahrzeuge eingeführt. Wir haben ein dazu passendes Java–
Programm entwickelt, welches zum Abdrucken leider zu groß ist.
Sie sollten es austesten, sich ausdrucken und lesen. Sie starten das
Programm, indem Sie die Klasse FahrzeugDemo.java kompilieren und
ausführen. Sie finden das Programm unter
http://www.wire.tu-bs.de/lehre/eipclasses/Vererbung/Fahrzeug/.
class LabeledPoint extends Point {
String label;
LabeledPoint( double newX, double newY, String newLabel ) {
super(x,y);
label = newLabel;
}
Dieses Beispiel besteht aus den Klassen Fahrzeug, MotorisiertesFahrzeug,
Auto, Fahrrad, LKW und Kutsche. Vergleichen Sie die Klassenstruktur
der Programme bitte mit dem Diagramm am Anfang des Kapitels.
Beispiel: Geometrische Objekte
}
Immer wenn in einem Konstruktor einer Unterklasse ein Methodenaufruf namens super(...) steht, so wird der zu den angegebenen Parametern passende
Konstruktor der Oberklasse aufgerufen.
Sie können diese Art des Konstruktor–Aufrufes übrigens nur in Konstruktoren
verwenden.
14.6
und überschreibt so die getDescription()–Methode der Oberklasse Point.
Immer wenn nun in einem Objekt der Klasse LabeledPoint die
getDescription()–Methode aufgerufen wird, wird diese überschriebene Methode benutzt.
Beispiele
Beispiel: Point und LabeledPoint
Das folgende Beispiel besteht aus drei Klassen, welche sich alle in einer
gemeinsamen Datei befinden. Sie können das Beispiel ausführen, indem
Sie auf der Kommandozeile javac Points.java und dann java Demo eingeben.
Hier eine kleine Klassenhierarchie zur Modellierung geometrischer Objekte. Starten Sie das Beispiel, indem Sie javac Demo.java und dann java
Demo eingeben.
Beachten Sie, wie wir die Interna der Objekte kapseln — wir vermeiden
direkte Zugriffe auf die Instanzvariablen von GeomObjekt und verwenden
statt dessen die getX() und getY()–Methoden. Hierdurch erhalten wir
Flexibilität, wenn wir irgendwann mal in einer Unterklasse die Art und
Weise verändern möchten, wie die Position berechnet wird.
Es empfiehlt sich sehr, Zugriffe auf Instanzvariablen durch entsprechende
get– bzw. set– Methoden zu erledigen. Beachten Sie auch die Klasse Linie
— sie erbt nicht nur von GeomObjekt sondern verwendet auch noch im
Konstruktor ein zweites GeomObjekt, um den Linienvektor zu bestimmen.
Beispiel: Geometrisches Objekta
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Vererbung/Geom/GeomObjekt.java
Beispiel: Überschreiben von Methodena
Beispiel: Punkta
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Vererbung/ex1/Points.java
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Vererbung/Geom/Punkt.java
Die Klasse Point repräsentiert einen Punkt im zweidimensionalen Raum.
Sie besitzt unter anderem eine Methode output(), welche eine Beschreibung des Punktes ausgibt. Um die Beschreibung zu ermitteln, wird auf
die Methode getDescription() zurückgegriffen.
Von der Klasse Point wird in Zeilen 23–38 eine Klasse namens
LabeledPoint abgeleitet. Objekte dieser Klasse haben durch Vererbung
alle Variablen und Methoden, die auch die Objekte der Point–Klasse
besitzen. Dabei werden alle Definitionen der Oberklasse bis auf die
getDescription()–Methode direkt übernommen.
Beispiel: Liniea
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Vererbung/Geom/Linie.java
Die getDescription()–Methode wird in Zeilen 35–37 erneut definiert
121
122
Beispiel: Demoa
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Vererbung/Geom/Demo.java
14.7
Die Object-Klasse
Zu Java gehört eine spezielle Klasse namens Object. Wannimmer Sie eine Klasse
definieren, welche nicht explizit von einer anderen Klasse erbt, fügt der Java–
Compiler automatisch eine Vererbung von Object ein.
Wenn Sie eine Klasse
class MeineKlasse {
// Klassenkörper
}
Java bietet spezielle Unterstützung für abstrakte Klassen. Eine abstrakte Klasse ist eine Klasse, in der zwar alle nötigen Methodenköpfe definiert sind, in
der einige Methoden jedoch noch keinen Methodenkörper besitzen. Von einer
abstrakten Klasse weiß man somit zwar, wie man jede Methode aufruft und
welchen Zweck jede Methode hat, aber da die Klasse nur ein abstraktes Gedankenmodell ist, weiß man nicht, welches Verhalten die Methoden zeigen sollen.
Eine abstrakte Methode wird definiert, indem der Methodenkörper ausgelassen
und vor den Methodenname das Wort “abstract” gesetzt wird. Beispielsweise
könnte eine abstrakte Methode namens draw wie folgt definiert werden:
abstract void draw();
Sobald eine Klasse mindestens eine abstrakte Methode enthält, muß auch die
Klasse als abstract definiert werden. Dies geschieht, indem in die Klassendefinition das Wort “abstract” gesetzt wird:
abstract class GeometrischesObjekt {
double x, y;
definieren, so wird das vom Java–Compiler übersetzt als
void move(double dx, dy) {
x+=dx; y+=dy;
}
class MeineKlasse extends Object {
// Klassenkörper
}
Es ist also unmöglich, eine Klasse zu schreiben, die nicht zumindest indirekt von
Object erbt. Die meisten von Object geerbten Methoden sind nur mit größerem
Wissen über Java zu verstehen.
Schauen Sie sich bitte im Java–API die Klasse Object an. Sie erhalten die Dokumentation, indem Sie unter
http://www.tu-bs.de:82/wir/EIP/jdk1.1.8/docs/api/packages.html
auf das Paket java.lang und dann auf die Klasse Object klicken.
14.8
abstract void draw();
}
Eine abstrakte Klasse ist zum Erweitern gedacht. Für die Extensionen einer
abstrakten Klasse gilt: Entweder füllt die Extension jede abstrakte Methode
der Oberklasse mit einem Methodenkörper, oder auch die Extension muß als
abstrakte Klasse definiert werden.
Es ist nicht möglich, Instanzen abstrakter Klassen zu erzeugen. Es ist jedoch
möglich, Variablen abstrakter Klassen zu definieren. Diese Variablen können
dann Instanzen der Unterklassen aufnehmen.
Beispiel: Im folgenden Beispiel wird eine abstrakte Klasse namens
Abstrakte Klassen
Häufig führt man Klassen ein, von denen man überhaupt nicht plant, Instanzen
zu erzeugen.
Möchte man beispielsweise geometrische Objekte wie Linien, Rechtecke und
Punkte in einem gemeinsamen Konzept zusammenfassen, so könnte man eine
Klasse GeometrischesObjekt definieren.
In der Klasse GeometrischesObjekt könnte die Intelligenz zum Verschieben von
geometrischen Objekten enthalten sein. Dieses Verhalten wäre für alle geometrischen Objekte gleich und sollte daher in der Klasse GeometrischesObjekt
realisiert werden.
Allerdings würde man vermutlich niemals eine Instanz von GeometrischesObjekt
erzeugen, da dies nur ein abstraktes Konzept ist — Sie wissen, wie man eine Linie
oder ein Rechteck zeichnet, aber welches Verhalten soll das abstrakte Konzept
GeometrischesObjekt beim Zeichnen an den Tag legen ?
123
GeometrischesObjekt definiert, welche eine abstrakte draw–Methode sowie Verhalten zum Verschieben eines geometrischen Objektes enthält.
Von dieser abstrakten Klasse werden zwei konkrete Klassen, Punkt und
Linie vererbt. Die Klasse Demo zeigt, wie man Variablen abstrakter Klassen verwenden kann.
Beispiel: Geometrisches Objekta
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Vererbung/Geom2/GeomObjekt.java
Beispiel: Punkta
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Vererbung/Geom2/Punkt.java
124
Beispiel: Liniea
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Vererbung/Geom2/Linie.java
Beispiel: Demoa
Dreieck einDreieck
= new Dreieck();
Rechteck einRechteck = new Rechteck();
Flaeche eineFlaeche = new Rechteck();
GeometrischesObject[] meinArray = new GeometrischesObject[3];
meinArray[0] = einDreieck;
meinArray[1] = einRechteck;
meinArray[2] = eineFlaeche;
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Vererbung/Geom2/Demo.java
14.9
Zuweisung an Variablen und Arrays
Jedes Objekt ist eine Instanz all seiner Oberklassen. Dies erschliesst vielfältige
Möglichkeiten beim Umgang mit Variablen und Arrays. Angenommen, es seien
die folgenden drei Klassen definiert:
abstract class GeometrischesObjekt { ... }
class Linie extends GeometrischesObjekt { ... }
abstract class Flaeche extends GeometrischesObjekt { ... }
class Rechteck extends Flaeche { ... }
class Dreieck extends Flaeche { ... }
In diesem Fall ist jedes Rechteck–Objekt auch eine Flaeche– und eine GeometrischesObjekt–
Instanz. Da GeometrischesObjekt automatisch von der Object–Klasse erbt, ist
jedes Rechteck–Objekt auch eine Instanz der Klasse Object.
Die folgenden Definitionen sind daher gültig:
Object
GeometrischesObjekt
Flaeche
Rechteck
einObj
einGeoObj
eineFlaeche
einRechteck
=
=
=
=
new
new
new
new
Rechteck();
Rechteck();
Rechteck();
Rechteck();
Sie dürfen jedes Objekt an Variablen seiner Oberklassen zuweisen. Dies ist eigentlich logisch, denn jedes Objekt IST auch ein Objekt seiner Oberklassen:
Jedes Rechteck ist ein Object, jedes Rechteck ist ein GeometrischesObjekt, und
jedes Rechteck ist eine Flaeche; daher sind die obigen Definitionen gültig.
Die folgenden Definitionen hingegen sind allesamt ungültig:
Rechteck einRechteck1 = new Flaeche(); // Fehler
Rechteck einRechteck2 = new Object(); // Fehler
Rechteck einRechteck3 = new Dreieck(); // Fehler
Daß diese Definitionen ungültig sind, sollte einleuchten — denn in unserem
Vererbungsbaum ist zwar jedes Rechteck eine Flaeche, aber nicht jede Flaeche
ist ein Rechteck. Auch ist zwar jedes Rechteck ein Object aber nicht jedes Object
ein Rechteck.
Es ist nun ohne weiteres möglich, Arrays zu erzeugen, welche Objekte verschiedener Klassen aufnehmen (man spricht hier auch von “polymorphen Arrays”).
Das folgende Programmfragment ist korrekt:
125
Was kann man nun mit den Objekten anstellen, die man in Variablen einer
Oberklasse gespeichert hat ? Man kann ihnen natürlich Botschaften schicken,
aber der Java–Compiler achtet sehr darauf, daß man jedem Objekt nur die
Botschaften schickt, die es sicher verstehen kann.
Angenommen, in der GeometrischesObjekt–Klasse sei eine Methode Methode
draw() definiert, welche ein geometrisches Objekt auf dem Bildschirm zeichnet,
und welche in den erbenden Klassen durch das spezielle benötigte Verhalten
überschrieben wird.
In diesem Fall könnte der obige Programmtext wie folgt fortgesetzt werden:
for(int i=0; i < meinArray.length(); i++) {
meinArray[i].draw();
}
Hier würde das Array durchlaufen und jedes gespeicherte Objekt würde die
zugehörige draw()–Methode ausführen. Auf diese Art und Weise könnte man
eine ganze Sammlung von geometrischen Objekten zeichnen ohne sich darum zu
kümmern, ob das gerade gezeichnete Objekt ein Dreieck, Rechteck oder sonstwas
ist — das jeweilige Objekt weiß ja immer selbst, wie es zu zeichnen ist.
Es ist hingegen nicht möglich, einem Objekt Botschaften zu schicken, die nur
eine Unterklasse versteht. Angenommen, ein Dreieck–Objekt besitze eine Methode Linie getHypothenuse(), welche in einem Linie–Objekt die Hypothenuse
zurückliefere. Die Klasse GeometrischesObjekt besitze keine solche Methode.
In diesem Fall wäre der folgende Programmtext ungültig:
GeometrischesObjekt einGeomObj = new Dreieck();
Linie eineLinie = einGeomObj.getHypothenuse(); // Fehler
Können Sie schon beantworten, warum der Programmtext ungültig ist ? In
der Variable “einGeomObj” ist ein Dreieck gespeichert, und da ein Dreieck die
Botschaft “getHypothenuse()” versteht, sollte doch alles in Ordnung sein.
Berücksichtigen Sie aber, daß wir “einGeomObj” als GeometrischesObjekt definiert haben. Der Compiler weiß in der zweiten Zeile daher lediglich, daß wir an
eine Variable des Typs GeometrischesObjekt die Botschaft “getHypothenuse()”
schicken, und da in der Klasse GeometrischesObjekt keine derartige Methode
existiert, läßt er das nicht zu.
Wenn Sie wissen, daß ein Objekt ein Objekt einer gewissen Klasse enthält,
können Sie einen Type–Cast verwenden. Der folgende Programmtext ist gültig:
GeometrischesObjekt einGeomObj = new Dreieck();
Linie eineLinie = (Dreieck)einGeomObj.getHypothenuse(); // ok
126
Durch den Type–Cast “(Dreieck)” sagen wir dem Compiler: Compiler, wir machen hier schon das korrekte, gehe davon aus, daß in einGeomObj ein Objekt
der Klasse Dreieck steht.
Der Compiler würde in solch einem Fall keinen Fehler melden. Wenn wir hierbei
aber einen Fehler machen, entsteht während der Laufzeit des Programms ein
Fehler:
• erklären können, wie man Konstruktoren einer Kindklasse schreiben sollte.
GeometrischesObjekt einGeomObj = new Quadrat();
Linie eineLinie = (Dreieck)einGeomObj.getHypothenuse();
• erklären können, warum man nicht direkt alle Methoden von Objekten
aufrufen kann, die in einer Variable der Oberklasse gespeichert sind.
Das obige Fragment ist so kompilierbar, da wir durch den Type–Cast die Überprüfung durch den Compiler ausgeschaltet haben. Wenn das Programm abläuft,
merkt das Laufzeitsystem aber, daß hier versucht wird, ein Quadrat als Dreieck zu betrachten. Das Programm würde dann einen Fehler ausgeben und sich
beenden.
• beschreiben können, wie und warum man im Rahmen von Vererbung den
Type–Cast–Operator einsetzen kann.
• die Beispiele in Kapitel 14.6 verstanden haben und Fragen dazu beantworten können.
• beschreiben können, an Variablen welchen Typs man Objekte zuweisen
kann.
• sich überlegen, ob und warum der Einsatz von Type–Cast–Operatoren
gefährlich sein kann.
Beispiel: Das folgende Beispiel demonstriert eine Verwendung des Type–
Cast–Operators
Beispiel: TypeCast–Demoa
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Vererbung/Cast/CastDemo.java
Hier wird in Zeile 36–39 ein Object[]–Array definiert, in welchem verschiedene Objekte gespeichert werden. Außerdem wird in Zeile 35 ein Array definiert, in welchem beschrieben ist, was für ein Objekt an welcher
Position des Object–Arrays liegt.
Beide Arrays werden an die Methode output übergeben. Diese Methode
durchläuft das Object[]–Array und führt für jeden Eintrag basierend auf
der Information im desc–Array einen Type–Cast aus. Dann führt es in
jedem gecasteten Objekt eine spezielle Methode aus.
14.10
Zusammenfassung
Nach Lesen dieses Kapitels sollten Sie
• erklären können, welche Vorteile Vererbung bietet.
• anhand von Beispielen die Vorzüge von Vererbung demonstrieren können.
• die Begriffe, Extension, erben, Super–Klasse, Elternklasse, Erweiterung,
direkter/indirekter Nachkomme erklären können.
• beschreiben können, wie man in Java Extensionen schreibt.
• erklären können, was beim Vererben in Java passiert.
• beschreiben können, was es bedeutet, eine Methode zu überschreiben, und
wie man überschriebene Methoden der Oberklasse aufrufen kann.
• sich Gedanken darüber gemacht haben, was es bedeutet, daß Konstruktoren nicht vererbt werden.
127
128
15
Packages
Zu Java gehören sehr viele verschiedene Klassen. Um nicht die Übersicht zu
verlieren, werden Klassen mit ähnlichem Zweck gemeinsam zu größeren Paketen,
sogenannten “packages” zusammengeschnürt.
Um einen weiteren Zweck von Paketen klarzumachen, stellen Sie sich vor, Sie
hätten eine Klasse namens Y2K erstellt, welche alle Millenium–Bugs vertreibt
und wollten diese Klasse verkaufen. Stellen Sie sich nun vor, ein potentieller
Kunde habe bereits eine eigene Klasse namens Y2K erstellt, benutze diese in
seinem Programm und wolle nicht auf sie verzichten.
Was tun ? Sie könnten natürlich ihre Klasse umbenennen. Aber selbst wenn sie
sie umbenennen, könnte es einen Namenskonflikt mit einem anderen Kunden
geben.
Eine Lösung, derartige Namenskonflikte gar nicht erst zum Problem werden zu
lassen, sind packages. Ein package oder Paket enthält beliebig viele Klassen. Die
in einem package enthaltenen Klassen kann man ansprechen, indem man hinter
den Namen des packages einen Punkt und dann den Namen der Klasse setzt.
Wenn zum Beispiel ein Paket den Namen de.tubs.cs.sc.akeese hat und in dem
Paket eine Klasse namens Y2K enthalten ist, so könnte man die Klasse als
de.tubs.cs.sc.akeese.Y2K ansprechen.
Es ist üblich, Paket–Namen aus der Internet–Adressierung einer Firma zu generieren. Wenn die Firma SUN (www.sun.com) eine Erweiterung zu Java entwickelt, welche nicht im Java–Kern enthalten ist, so würde diese Erweiterung in
einem Paket namens com.sun.paketname enthalten sein.
Da Internet–Adressen eindeutig sind, wird so sichergestellt, daß Pakete unterschiedlicher Firmen unterschiedliche Namen enthalten. Somit haben auch in der
Regel Klassen verschiedener Firmen verschiedene Namen und sind deshalb gemeinsam einsetzbar.
Alle zu Java gehörigen Klassen sind in Paketen enthalten, die mit dem Text
“java” beginnen. So gibt es ein Paket java.awt, in welchem alle Bestandteile des
“Abstract Windowing Toolkits” enthalten sind, es gibt ein Paket java.math,
in welchem spezielle mathematische Klassen enthalten sind, und viele mehr.
Das wichtigste Paket ist das Paket java.lang, in welchem die wichtigsten Java–
Klassen wie z.B. String oder Object enthalten sind.
Wir wollen hier nicht weiter darauf eingehen, wie man packages erstellt, möchten
Ihnen jedoch erläutern, wie man packages benutzt.
Um eine in einem Paket enthaltene Klasse anzusprechen, müssen Sie vor den
Namen der Klasse jedesmal den Namen des Paketes setzen. Wenn der Paketname
lang ist, wird das eine ganze Menge Schreibarbeit. Stellen Sie sich vor, statt
String müssten Sie jedesmal java.lang.String schreiben.
Man kann daher die in einem Paket enthaltenen Namen in ein Programm importieren. Dazu setzt man an den Anfang der Datei den Text
Wenn Sie nur einzelne Klassen eines Paketes importieren wollen, können Sie
statt des Sterns auch für jede zu importierende Klasse einen einzelnen import–
Befehl angeben, etwa so:
import paketname.klasse1;
import paketname.klasse2;
Beispielsweise enthält das Paket java.util die Klasse Dictionary. Wenn Sie diese
Klasse benutzen wollen, haben Sie zwei Möglichkeiten:
Sie können die Klasse direkt verwenden:
class MeineKlasse {
java.util.Dictionary einDict;
public static void main( String[] args ) {
java.util.Dictionary aDict = new java.util.Dictionary();
}
}
Alternativ können Sie die Klasse auch importieren und können dann eine kürzere
Schreibweise wählen:
import java.util.*;
// oder import java.util.Dictionary
class MeineKlasse {
Dictionary einDict;
public static void main( String[] args ) {
Dictionary aDict = new Dictionary();
}
}
Es ist übrigens nicht nötig, Inhalte des java.lang–Paketes zu importieren. Da die
dort enthaltenen Klassen so häufig benutzt werden, wird es automatisch in jedes
Programm exportiert. Der Java–Compiler fügt automatisch in jedes kompilierte
Programm den Befehl
import java.lang.*;
ein.
Eine Übersicht über die zu Java gehörigen Pakete finden Sie in der Dokumentation zum Java API unter
http://www.tu-bs.de:82/wir/EIP/jdk1.1.8/docs/api/packages.html
Hierdurch werden alle in dem jeweiligen Paket enthaltenen Klassen importiert
und sind in Zukunft ansprechbar, ohne daß Sie den Paketnamen vor den Klassennamen setzen müssen.
Bitte klicken Sie sich dorthin, indem Sie von unseren WWW–Seiten unter den
Litaturlinks zu Java auf den relativ weit unten stehenden Link “Java–Api (lokal)” klicken.
Bitte schauen Sie sich auf dieser WWW–Seite um, klicken Sie dort auf das
Package java.lang und schauen Sie sich die Dokumentation der Object–Klasse
in java.lang an.
129
130
import paketname.*;
15.1
16
Zusammenfassung
Nach Lesen dieses Kapitels sollten Sie
• erklären können, welche Vorteile ein Package bietet.
• den import–Befehl kennen.
• wissen, was am java.lang–Paket besonders ist.
• eine Übersicht der zu Java gehörenden Packages aufrufen können.
Exceptions
Zur Behandlung unerwarteter Situationen bietet Java Unterstützung in Form
von Exceptions oder Ausnahmen.
Den Sinn von Exceptions können wir Ihnen an einem kleinen Beispiel klarmachen. Nehmen Sie an, wir schreiben eine Methode, in welcher durch eine Zahl
geteilt werden muß — es könnte etwa aus der zurückgelegten Distanz und einem Zeitintervall berechnet werden, mit welcher Geschwindigkeit sich ein Auto
bewegt. Eine erste Fassung einer entsprechenden Methode könnte wie folgt aussehen:
Beispiel: Methode mit einem Fehler
1
2
3
4
static int geschwindigkeit( int distanz, int dauer )
{
return distanz / dauer;
}
Diese Methode wird problematisch, wenn von außen eine Dauer von 0 Sekunden
angegeben wird, etwa im Aufruf
int speed = geschwindigkeit( 10, 0 );
Was soll in solch einem Fall geschehen — in der Methode würde nun offensichtlich versucht, durch 0 zu teilen. Dies wiederum würde einen Fehler erzeugen,
welcher das Programm beenden würde.
Nun ist es nicht besonders wünschenswert, daß ein Programm sich einfach beendet, wenn irgendwo ein ungültiger Zahlenwert erscheint. Das Programm sollte
zumindest die noch nicht gespeicherten Daten speichern und Aufräumarbeiten
durchführen (etwa die vom Programm erzeugen 5 Gigabyte temporärer Daten
von der Festplatte löschen).
Noch schöner wäre es natürlich, wenn das Programm einen Fehler melden würde.
Man könnte nun vor jedem Aufruf der Funktion überprüfen, ob die Eingabedaten in Ordnung sind. Es ist aber durchaus denkbar, daß vor dem Aufruf einer
Methode nicht von außen prüfbar ist, ob sie durchführbar ist — stellen Sie sich
eine Methode vor, welche auf eine Diskette zugreifen will. Hier hinge es davon
ab, ob eine Diskette im Laufwerk liegt, ob die Methode funktioniert oder nicht.
Beim Programmieren kommt es immer wieder zu Situationen, in denen unerwartete Daten oder unerwartete Ereignisse (Ausnahmen) vorliegen. Wenn eine
Ausnahme auftritt, muß sie entweder dort, wo sie aufgetreten ist, behandelt
werden, oder sie muß weitergegeben werden, so daß ein anderer Programmteil
eine Möglichkeit hat, auf die Ausnahme zu reagieren. Wird die Ausnahme nirgends behandelt, bleibt als einzige Alternative der Abbruch des Programms mit
einem Fehler.
16.1
Try–catch
Der try–catch–Block bietet eine Möglichkeit, Programmtext auszuführen, in welchem Ausnahmen auftreten könnten. Dabei ist eine Ausnahme ein Objekt einer
gewissen Klasse, welches erzeugt wird, wenn eine unerwartete Situation aufgetreten ist.
131
132
Sie können sich das wie folgt vorstellen: An einer Stelle der Programmausführung
tritt eine unerwartete Situation auf (z.B. Teilen durch Null, Diskette fehlt im
Laufwerk). Als Reaktion auf diese Situation wird ein Ausnahme–Objekt erzeugt,
welches die aufgetretene Situation genauer beschreibt. Dieses Ausnahme–Objekt
wird nun weitergereicht (“geworfen”), bis irgendwo Programmtext gefunden
wird, welcher das Ausnahmeobjekt auffängt und dann die Ausnahme behandelt. Wird kein Programmtext gefunden, der das Ausnahmeobjekt fängt, wird
das Programm mit einer Fehlermeldung beendet.
Eine Ausnahme kann nur gefangen werden, wenn sie innerhalb eines try–catch–
Blocks auftritt. Die try–catch–Anweisung ermöglicht erst das Einfangen der
Ausnahmeobjekte und schützt so einen gewissen Programmtextbereich vor einem ungewollten Programmabbruch. Man verwendet einen try–catch–Block, indem man den Programmtext, in welchem Ausnahmen–Objekte geworfen werden
könnten, in einen try–Block setzt und dann für jeden Ausnahmetyp, der eingefangen werden soll, hinter den geschützten Block eine catch–Anweisung setzt:
try {
geschuetzte Anweisungen;
...
} catch ( Ausnahmetyp1 x )
Ausnahme-Anweisungen für
...
} catch ( Ausnahmetyp2 x )
Ausnahme-Anweisungen für
...
}
Beim Ablauf des Programmtextes entsteht in Zeile 7 beim Teilen durch
0 ein ArithmeticException–Objekt, welches dann als Ausnahme geworfen
wird. Dadurch bricht die Ausführung von Zeile 7 sofort ab. Da in Zeile 9 eine catch–Anweisung für Ausnahmeobjekte des Typs ArithmeticException
steht, wird das Programm dann in Zeile 10 fortgesetzt.
Das gefangene ArithmeticException–Ausnahmeobjekt kann in Zeile 10 unter der Variable e angesprochen werden.
Durch die Aneinanderreihung mehrerer catch–Blöcke kann man unterschiedliche
Ausnahmen fangen und auf die unterschiedlichen Ausnahmen auch unterschiedlich reagieren.
Beispiel:
Spricht man in einem Array nicht existierende Indizes an,
so
wird
eine
ArrayOutOfBoundsException
geworfen.
Die
Klasse
ArrayOutOfBoundsException
erbt
von
der
Klasse
IndexOutOfBoundsException.
Im folgenden Programm wird sowohl das Teilen durch 0 als auch das
Verwenden eines zu großen Index abgefangen:
Beispiel: Exceptions 2a
{
Ausnahmetyp 1;
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Except/ExcDemo2.java
{
Ausnahmetyp 2;
16.2
Der Block zwischen dem try und dem ersten catch ist hierdurch vor jeder Ausnahme geschützt, welche durch eine der catch–Anweisungen aufgefangen werden
kann.
Sofern im geschützten Block eine Ausnahme auftritt (wie man selbst Ausnahmen
erzeugt, erzählen wir gleich noch), wird die Ausführung des geschützten Blocks
sofort abgebrochen, und die Ausführung wird in demjenigen Block ausgeführt,
welcher auf das passende catch folgt.
Was da genau passiert, wird nach dem folgenden Beispiel sicher klarer:
Beispiel: Beispielsweise entsteht in Java beim ganzzahligen Teilen durch
0 eine Ausnahme des Typs ArithmeticException. Das folgende Programm
demonstriert, wie man einen Programmteil vor einer solchen Ausnahme
schützen kann:
Beispiel: Exceptions 1a
Ausnahmen werfen
Ausnahmen entstehen entweder durch die mißbräuchliche Verwendung von Java–
Anweisungen oder dadurch, daß im Programmtext eine Ausnahme geworfen
wird. Die bei der fehlerhaften Verwendung von Java–Anweisungen entstehenden Ausnahmen sind im Java–API im java.lang–Paket beschrieben.
Alle Ausnahmen müssen indirekt oder direkt von der Klasse Throwable erben.
Von dieser Klasse vererben sich unter anderem die Klasse Exception, und von
Exception ist eine Klasse RuntimeException abgeleitet. Alle Ausnahmen, die
bei fehlerhafter Verwendung von Java–Anweisungen auftreten kommen, sind
von RuntimeException erbende Objekte.
Wenn Sie selbst Ausnahmen definieren wollen, so sollten Sie diese in der Regel
von der Klasse Exception oder einer ihrer Unterklassen ableiten (schauen Sie
sich die genannten Klassen bitte in der JDK–Dokumentation an).
Sie können selbst Ausnahmen werfen, indem Sie ein Objekt der Klasse Throwable
oder ein Objekt einer Unterklasse von Throwable erzeugen und dann mit der
throw–Anweisung die Ausnahme auslösen.
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Except/ExcDemo1.java
Exception myException = new Exception("Meine Ausnahme");
throw myException;
Der Programmtext von Zeile 6 bis Zeile 8 ist durch den umschliessenden try–Block und das folgende catch–Statement vor einem Programmabbruch durch alle Ausnahmen des Typs ArithmeticException geschützt.
oder kürzer:
throw new Exception();
133
134
Beispiel: So können Sie selbst eine Exception werfen und wieder fangen:
Beispiel: Throw 1
Im folgenden Beispiel wirft die geschwindigkeit–Methode eine eigene Ausnahme. Da diese Ausnahme keine Java–Laufzeitausnahme ist, muß sie im
Methodenkopf durch die throws–Klausel deklariert werden. Wir deklarieren hier auch überflüssigerweise, daß die Routine eine ArithmeticException (dies ist eine Java–Laufzeitausnahme) werfen kann.
a
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Except/ThrowDemo1.java
Beispiel: Eigene Exceptions in Methodena
16.3
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Except/MethodsDemo2.java
Exceptions in Methoden
Wenn bei der Ausführung einer Methode A eine Ausnahme geworfen wird, welche nicht in der Methode selbst gefangen wird, so wird die Methode beendet. Die
Ausnahme wird dann an die Stelle übergeben, an der die Methode A aufgerufen
wurde. Dort wird die Ausnahme erneut geworfen.
Wurde die Methode A aus einer anderen Methode B aufgerufen, so gibt es
zwei Möglichkeiten: Wenn der Aufruf der Methode A in Methode B von einem
try–catch–Block geschützt wurde, welcher die erzeugte Ausnahme fangen kann,
so wird das Programm im zugehörigen catch–Block fortgesetzt. Wurde der Methode A jedoch ungeschützt aufgerufen, so wird Methode B abgebrochen, und
die Ausnahme wird dort erneut geworfen, wo Methode B aufgerufen wurde.
Dies setzt sich fort, bis ein try–catch–Block gefunden wird, welcher die geworfene Ausnahme fängt. Wird kein try–catch–Block gefunden, der die Ausnahme
behandelt, so wird das Programm mit einer Fehlermeldung abgebrochen.
Wenn in einer Methode A eine Methode B aufgerufen wird, welche eine Ausnahme von Typ X (abgesehen von RuntimeExceptions) erzeugen kann, so muß die
von B erzeugte Ausnahme entweder innerhalb der Methode A gefangen werden,
oder im Methodenkopf von A muß vermerkt sein, daß Methode A eine Ausnahme vom Typ X werfen kann. Andernfalls wird ein Kompilierfehler erzeugt.
So wird sichergestellt, daß jede Methode, welche Ausnahmen werfen kann, dies
im Methodenkopf vermerkt.
Beispiel:
Das folgende Beispiel kompiliert nicht korrekt. Der Compiler beschwert
sich, daß die Methode test eine DistanzException werfen kann, ohne daß
das im Kopf der Methode vermerkt ist.
Beispiel: Eigene Exceptions in Methodena
Beispiel: Im folgenden Beispiel wird in der geschwindigkeit–Routine eine
Exception geworfen, wenn versucht wird durch 0 zu teilen. Die Ausnahme
wird in der main–Methode gefangen.
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Except/MethodsDemo3.java
Beispiel: Exceptions in Methodena
Wir können das Beispiel reparieren, indem wir den Kopf der test–Methode
wie folgt ändern:
a Siehe http://www.wire.tu-bs.de/lehre/eipclasses/Except/MethodsDemo1.java
public static void test() throws DistanzException
Wenn eine Methode eine Ausnahme zurückgibt, welche nicht zu den Java–
Laufzeitausnahmen gehört, muß dies im Kopf der Methode vermerkt werden.
Die Java–Laufzeitausnahmen (dies sind alle Ausnahmen, welche von der Klasse
java.lang.RuntimeException vererbt sind) wird dies deshalb nicht gefordert, weil
diese Ausnahmen fast jederzeit auftreten können und daher fast jede Methode
eine RuntimeException werfen kann. Wäre aber im Kopf einer jeden Methoden
vermerkt, daß sie eine Java–Laufzeitausnahme werfen kann, so wäre das kein
besonderer Informationsgewinn.
In einer Methode wird im Methodenkopf beschrieben, welche Ausnahmen ihre
Ausführung erzeugen kann, indem hinter der Kopfdeklaration der Text
Wir könnten das Beispiel auch reparieren, indem wir in der test–Methode
einen try–catch–Block einfügen. Die test–Methode sähe dann so aus:
public static void test() {
try {
System.out.println( geschwindigkeit(11,3) );
} catch( DistanzException e ) {
System.out.println("Habe Ausnahme gefangen: " + e);
}
}
throws Ausnahmetyp1, ... , AusnahmetypN
16.4
Ein paar abschließende Bemerkungen
folgt.
Immer wenn Sie Klassen aus dem Java–API benutzen wollen, so müssen Sie
in der Dokumentation des Java–API nachsehen, ob die von Ihnen verwendeten
Beispiel:
135
136
Methoden eine Ausnahme werfen können. Wenn ja, so müssen Sie sich in Ihrem
Programm um diese Ausnahme kümmern.
Wir haben nicht alle Aspekte von Ausnahmen besprochen. Wenn Sie sich dafür
interessieren, lesen Sie es bitte im Buch Go To Java 2 (Kapitel 9) oder sonst
irgendwo nach.
16.5
Zusammenfassung
Nach Lesen dieses Kapitels sollten Sie
A
Anhang: Unix, Editor und CIP-Pool
A.1
Hinweise zu weiterer Unix-Literatur
Sie sollten zuerst das Don’t Panic-Heftchen des Rechenzentrums lesen, um die
Grundlagen von Unix kennenzulernen.
Zusätzlich empfiehlt es sich, auf die in den Seiten des Rechenzentrums angebotene Dokumentation zu schauen. Insbesondere möchten wir Sie auf folgende
Dokumente hinweisen:
• erklären können, was eine Ausnahme ist.
• Verzeichnis der vom Rechenzentrum angebotenen Dokumente17
• Beispielsituationen nennen können, in denen Ausnahmen auftreten.
• Don’t Panic online18
• erklären können, wie Ausnahmen in Java repräsentiert werden.
• Dokumentation zu Unix19
• den try–catch–Befehl erklären können.
• beschreiben können, wie Ausnahmen behandelt werden, die innerhalb einer Methodenausführung auftreten.
• beschreiben können, was man beim Schreiben von Methoden berücksichtigen muß, in denen Ausnahmen entstehen können.
• erläutern können, was man beachten muß, wenn man JDK–Funktionen
verwendet, die Ausnahmen werfen können.
A.2
A.2.1
Editoren
Der nedit-Editor
Um Programmtexte zu schreiben, benötigen Sie einen Editor. Wir empfehlen
Ihnen, den nedit Editor zu verwenden. Denn wenn Sie bereits mit Windows
oder DOS gearbeitet haben, werden Sie ihn sehr schnell verwenden können.
Sie starten ihn, indem Sie auf einer Unix-Shell
> nc &
eingeben (Das Größerzeichen sollten Sie dabei nicht miteingeben; wir verwenden
es hier nur, um zu verdeutlichen, daß Sie etwas eingeben sollen). Nach dem
Start lesen Sie in seinem Hilfe-Menü bitte die Abschnitte Getting Started und
Programming with NEdit (letzteres finden Sie im Untermenü des Hilfe-Menus
Features for programming).
Weitere Dokumentation finden Sie auf folgenden Seiten:
• Dokumentation im Rechenzentrum20
• Dokumentation zu nedit (FU Berlin; engl.)21
• Regular Expressions in nedit (eher ein Thema für Fortgeschrittene)22
A.2.2
Der Emacs-Editor
Der Editor Emacs ist vermutlich der mächtigste Editor überhaupt. Seine Bedienung ist für MS Windows-Kenner nicht sofort einsichtig, und das Kennenlernen
des Emacs deutlich länger, als den Umgang mit nedit zu lernen.
17 http://www.tu-bs.de/rz/doku/
18 http://www.tu-bs.de/rz/doku/panic.html
19 http://www.tu-bs.de/rz/doku/unix-pages/kap0-unix.html
20 http://www.tu-bs.de/rz/software/nedit/neditdoc.htm
21 http://www.chemie.fu-berlin.de/chemnet/use/nedit.html
22 HTTP://www.iti.cs.tu-bs.de/soft/nedit/hlp11.html
137
138
Dafür werden Sie niemals wieder einen anderen Editor benötigen, wenn Sie ihn
erstmal schätzen gelernt haben. Sie sollten sich mit dem Emacs allerdings nur
dann auseinandersetzen, wenn Sie etwas Zeit haben und wissen, daß Sie auch in
Zukunft Programme schreiben werden.
Starten Sie ihn von der Unix-Shell per
> emacs &
Anschließend sollten Sie das Emacs-Tutorial durcharbeiten. Sie starten es, indem
Sie nach dem Start des Emacs die Tastenkombination Strg+h (auf englischen
Tastaturen ist die “Strg”-Taste mit “Ctrl” bezeichnet) und danach die Taste
“t”drücken .
Weitere Hilfe zum Emacs finden Sie hier:
http://www.cs.tu-bs.de/softech/info/
A.3
Der Apropos-Befehl
Die oben beschriebene Form des man-Befehles hat einen Nachteil: Sie können sich
nur Informationen zu einem Kommando geben lassen, wenn Sie schon dessen
Namen kennen.
Wenn Sie einen Befehl suchen, der eine gewisse Aufgabe erledigt, dessen Namen Sie aber nicht kennen, können Sie das apropos Kommando, gefolgt von
einem Schlüsselwort, verwenden. Daraufhin werden die Kurzbeschreibungen aller durch man dokumentierten Kommandos durchsucht. Alle Kommandos, in
deren Beschreibung dies Schlüsselwort auftaucht, werden aufgelistet.
Wenn Sie ganz allgemein nach Hilfe suchen, könnten Sie zum Beispiel einen der
folgenden Befehle ausprobieren:
> apropos help
> apropos info
> apropos manual
Das Hilfe-System
Unter Unix-Systemen sind mehrere Hilfesysteme verfügbar. Gerade beim Programmieren ist es wichtig, sich mit diesen Systemen auszukennen, da man des
öfteren die Aufrufkonventionen von Bibliotheksfunktionen nachschlagen muß.
A.3.1
A.3.2
Der man-Befehl
Um Hilfe zu einem Unix-Befehl zu erhalten, können Sie den man-Befehl verwenden. Hierzu geben Sie beim Aufruf des man-Befehls als Argument den Namen
des Unix-Kommandos, zu dem Sie Hilfe wünschen.
Sie können auch zum man-Befehl Hilfe erhalten, und das wollen wir gleich mal
ausprobieren. Geben Sie ein:
> man man
Wenn Sie im CIP-Pool arbeiten, erscheint nun zuerst ein Hilfetext zum aproposBefehl (dieser ist ein Bestandteil des man-Befehls), aber wenn Sie mit der Leertaste weiterblättern, erscheint etwas weiter unten auch Hilfe zum man-Befehl.
Diese Hilfe verlassen Sie durch drücken der Taste “q”.
Um den Umgang mit man zu trainieren, schauen Sie sich bitte auch die Hilfe zu
anderen Unix-Kommandos an. Wenn Sie Hilfe zum Kopier-Befehl cp oder zum
Directory-Anzeigekommando ls wünschen, probieren Sie aus:
> man cp
> man ls
Sie erhalten bei jedem apropos-Befehl eine Liste von zum Schlüsselwort passenden Kommandos mit einer Kurzerklärung angezeigt.
Diese Beispiele demonstrieren, daß Sie je nach gewählten Schlüsselwort unterschiedliche Kommandos angezeigt bekommen. Selbst wenn ein Befehl sinngemäß
etwas mit dem Hilfesystem zu tun hat, nennt apropos help ihn nur dann, wenn
in seiner Kurzbeschreibung auch das Wort help vorkommt. Man muß daher
manchmal ein wenig mit unterschiedlichen Schlüsselwörtern rumprobieren, bis
man einen Befehl gefunden hat.
Außerdem zeigen diese Beispiele, daß apropos auch unerwartete Antworten liefert - so hat der Befehl apropos manual auch die Zeile
route(1) - Manually manipulates the routing tables
angezeigt. Das hat nichts mit manuals zu tun, aber weil in der Beschreibung
die Zeichenkette “manual” vorkommt, hat der apropos-Befehl auch dieses Kommando angezeigt.
Ein weiteres Beispiel: Angenommen, Sie suchen nach einem Befehl, der eine
Eingabe sortiert. Also geben Sie ein
> apropos sort
Irgendwo in der Anzeige findet sich die Zeile
sort(1) - Sorts files, merges files that are already sorted, and
checks files to determine if they have been sorted.
Es gibt übrigens auch eine graphische Version des man-Befehls. Um diese zu
starten, geben Sie im CIP-Pool ein:
> xman &
So haben wir also herausgefunden, daß man zum sortieren einer Textdatei den
sort-Befehl verwenden kann. Bevor man den Befehl verwenden kann, braucht
man natürlich noch detailliertere Hilfe:
> man sort
139
140
A.4
Ausgabeumleitung
> cat < testDatei
Als nächstes wollen wir Sie mit Ausgabeumleitung bekannt machen. Ausgabeumleitung ist ein Weg, mehrere Unix-Programme miteinander zu kombinieren. Eine für das Programmieren hilfreiche Anwendung ist z.B. das Blättern
oder Suchen in Ausgaben des Compilers oder anderer Werkzeuge.
Fast alle Unix-Shell-Programme arbeiten wie folgt: Sie nehmen Eingaben aus
Ihrem Eingabekanal entgegen, verarbeiten diese und geben Sie auf ihrem Ausgabekanal aus. Ein Eingabekanal kann z.B. eine Datei, Eingaben eines Benutzers
oder Ausgaben eines anderen Programms sein. Ein Ausgabekanal kann z.B. der
Bildschirm, eine Datei oder der Eingabekanal eines anderen Programms sein.
Normalerweise wählt jedes Unix-Programm als Eingabekanal die Tastatur und
als Ausgabekanal den Bildschirm. Nehmen wir beispielsweise den Befehl cat. Er
kopiert alle Daten aus seinem Eingabekanal zu seinem Ausgabekanal. Probieren
wir das aus:
Dies sollte Ihre vorhin angegebenen Zeilen vom Eingabekanal, also der Datei
testDatei auf den Ausgabekanal, also den Bildschirm, ausgeben.
Das man auch auch kombinieren, um eine eine Datei zu kopieren (in der Praxis
verwendet man dafür aber lieber den cp-Befehl):
> cat < testDatei > kopie
Dies liefert keine Ausgabe auf dem Bildschirm. Der Eingabekanal war die Datei
testDatei und der Ausgabekanal ging in die Datei kopie. Testen Sie, ob die
Datei auch wirklich kopiert wurde:
> cat < kopie
Übrigens ist dies gleichwertig zu
> cat
> cat kopie
Sie erhalten nun einen blinkenden Cursor. Geben Sie irgend etwas ein und
drücken die Return-Taste. Als Ergebnis wird Ihre Eingabe ein zweites Mal ausgeben. Als Sie Return gedrückt haben, hat cat Ihre Eingabe (von der Tastatur)
auf seinen Ausgabekanal (das Bildschirmfenster) kopiert. Die Tatsache, daß Ihre Eingabe schon beim Tippen auf dem Bildschirm erschien, darf Sie hier nicht
stören - damit hatte cat nichts zu tun.
Geben Sie noch ein paar Zeilen ein - jedesmal, wenn Sie Return drücken, wird
ihre Eingabe abgeschickt und von cat auf die Ausgabe kopiert. Beenden Sie cat,
indem Sie die Tasten Strg und “d” gleichzeitig drücken. Die Tastenkombination
“Strg+d” bedeutet für cat, daß die Eingabe beendet ist und es zu arbeiten
aufhören kann — Hier gleich eine Warnung: Der Tastendruck Strg+d und das
EOF, das sie beim Programmieren mit C kennenlernen werden, sind nicht das
gleiche — allerdings erzeugt “Strg+d” ein EOF.
Jetzt wollen wir die Ausgabe von cat umleiten, d.h. wir wollen seinen Ausgabekanal verändern. Wenn man die Ausgabe in eine Datei leiten will, so gibt man
nach dem umzuleitenden Befehl den Text > dateiname an, wobei “dateiname”
für den Namen der Zieldatei steht.
Probieren wir das aus:
> cat > testDatei
Geben Sie wieder ein paar Textzeilen, jedesmal gefolgt von Return, ein. Ihnen
fällt sicher auf, daß die Textzeilen nach dem Return nicht ein zweites Mal ausgeben werden. Das war erwartet, da der Ausgabekanal nicht mehr der Bildschirm
sondern die Datei testDatei ist. Schließen Sie nach ein paar Zeilen die Eingabe
ab, indem Sie wieder Strg+d drücken.
Benutzen Sie bitte den ls-Befehl, um sich davon zu überzeugen, daß eine Datei
namens testDatei erzeugt wurde. Um den Inhalt dieser Datei am Bildschirm
anzuzeigen, benutzen wir wieder cat, leiten diesmal aber nicht die Ausgabe
sondern die Eingabe um. Dies geschieht, indem man hinter den Befehl den Text
> dateiname schreibt. Probieren Sie das bitte aus:
141
Das letzte Beispiel demonstriert eine Eigenschaft vieler Unix-Befehle — oft interpretieren Unix-Befehle Parameter als Dateinamen, welche dann zum Einoder Ausgabekanal werden.
Nun folgen noch ein paar Anwendungen und Beispiele zur Ausgabeumleitung.
Das Umleiten von Ein- und Ausgabekanal funktioniert bei fast allen UnixProgrammen. Probieren Sie einfach mal die folgenden Kommandos aus (Falls
Sie wissen wollen, was der sort-Befehl tut, können Sie sich darüber mit dem
man-Befehl informieren):
> ls > verzeichnis
> cat verzeichnis
> sort -r < verzeichnis
Was ist hier passiert ? Wir haben die Ausgabe von ls in eine Datei geleitet und
anschließend diese Datei als Eingabekanal an den sort-Befehl gegeben. Dieser
hat den Inhalt der Datei absteigend sortiert wieder an seinen Ausgabekanal, den
Bildschirm, ausgegeben.
Mit Hilfe des |-Operators kann man mehrere Ausgabeumleitungen kombinieren.
Der |-Operator leitet den Ausgabekanal eines Programms in den Eingabekanal
eines anderen Programms um. Konstrukte der Form
> befehl1 | befehl2
arbeiten ungefähr wie folgende Sequenz von Befehlen, allerdings ohne eine temporäre Datei anzulegen:
> befehl1 > temporäreDatei
> befehl2 < temporäreDatei
Wir können dies auf das Beispiel, in welchem wir das Verzeichnis sortiert haben,
anwenden — probieren Sie bitte folgende Befehle aus:
142
>
>
>
>
3. Anschließend müssen Sie sich auf den fremden Rechner einloggen.
ls | sort -r
ls | sort -r > sorted
cat sorted
ls -lF /usr/bin | sort | less
> telnet fremderRechner.rz.tu-bs.de
Die letzte Zeile demonstriert, daß man beliebig viele Ausgabeumleitungen hintereinanderschalten kann. Hier wird die Ausgabe von ls an sort weitergeleitet,
dort sortiert und dann an den less-Befehl weitergegeben.
Der less-Befehl gibt die Eingabe seitenweise auf den Bildschirm aus. Sie verlassen ihn durch die Taste “q”. Wenn Sie etwas durch den less-Befehl anzeigen
lassen, können Sie sich mit den Cursor hoch und Cursor runter-Tasten in der
Ausgabe bewegen.
A.5
Trennung von Rechner und Bildschirm
Es ist in einigen Praktika aufgefallen, daß viele Studenten einen der genialsten
Mechanismen von Unix nicht kennen. Darum werden wir hier kurz darauf eingehen.
Der Monitor, auf dem Ihre Programme angezeigt werden, und der Rechner auf
dem Ihre Programme laufen, sind voneinander völlig unabhängig. Auf Ihrem
Monitor hier in Braunschweig könnte ein in München oder in Amerika laufendes
Programm angezeigt werden. Dazu müsste man in München einem Programm
beim Start nur mitteilen, daß es für Ausgaben bitte nicht den lokalen Monitor
sondern den Monitor in Braunschweig verwenden soll.
Nehmen wir an, Sie sitzen an einem Terminal namens lokalerRechner.rz.tu-bs.de
und wollen sich auf den Rechner fremderRechner.rz.tu-bs.de einloggen und
dort Programme ausführen, deren Fenster dann bei Ihnen landen sollen.
Dazu müssen Sie drei Dinge tun:
1. Zuerst müssen Sie dem anderen Rechner gestatten, auf Ihren Monitor zuzugreifen. Die Methode, die wir hier beschreiben, ist zwar etwas unsicher,
da Sie dem fremden Rechner völligen Zugriff auf Ihren Monitor gewährt,
aber sie demonstriert am besten die Trennung von Bildschirm und Rechner.
Um dem fremden Rechner Zugriff auf Ihren Monitor zu gestatten, geben
Sie in einer Unix-Shell auf dem lokalen Rechner ein:
4. Nachdem Sie sich auf dem fremden Rechner angemeldet haben, müssen
noch das Display einstellen, auf das er seine Ausgabe leiten soll.
Wenn Sie bei der Ausgabe von
> echo $DISPLAY
vorhin den Text :0.0 erhalten haben, ist der Name des Displays lokalerRechner.rz.tu-bs.de:0.0.
Ansonsten ist der Name des Displays der vorhin angezeigte Name.
Geben Sie in der telnet-Sitzung23 folgendes ein, wenn vorhin der Name
:0.0 angezeigt wurde:
> export DISPLAY=lokalerRechner.rz.tu-bs.de:0.0
oder, wenn vorhin ein anderer Name als :0.0 angezeigt wurde, geben Sie
hinter dem Gleichheitszeichen den Namen des vorhin angezeigten Displays
an.
> export DISPLAY=name des displays
Anschließend starten Sie irgendein X-Programm, z.B. xclock, um zu testen, daß das Umlenken des Displays funktioniert hat:
> xclock
Und hier auch gleich eine Tip: Der Pool ist sehr stark ausgelastet. Wenn Sie
im Pool arbeiten und nebenher einen WWW-Browser wie Netscape verwenden
wollen, so können Sie sich mit Ihrer y-Nummer auf einem Rechner außerhalb
des Pools einloggen und dann das Display auf Ihren Arbeitsrechner im Pool
umlenken. Sie können dann Netscape auf dem entfernten Rechner starten.
Und noch ein Tip: Natürlich können Sie sich auf diese Weise auch von anderen
Rechnern aus im CIP-Pool einloggen. Sie können ohne weiteres in einem Institut
oder im Rechenzentrum sitzen, während Sie im Pool im Altbau arbeiten.
> xhost fremderRechner.rz.tu-bs.de
Damit kann der fremde Rechner Ihren Monitor beschreiben und auch auslesen.
2. Anschließend müssen Sie in Erfahrung bringen, wie das Display heißt, auf
dem Ihr Rechner seine Fenster momentan öffnet. Dazu geben Sie auf der
Kommandozeile ein:
> echo $DISPLAY
Daraufhin sollte entweder der Text :0.0 oder ein Text der Form rechnername:0.0
ausgeben werden. Merken Sie sich diesen Namen.
143
23 wir
gehen davon aus, daß Sie die bash–Shell benutzen
144
B
Anhang: Verwendung von Java unter Unix
System.out.println("Hallo, Welt");
}
B.1
Java-Compiler und Laufzeitumgebung
Die Programmierung mit Java geht folgendermaßen vor sich: Sie tippen Ihren
Programmtext mit einem Editor ein und speichern ihn irgendwo in Ihrem Homeverzeichnis. Der Programmtext kann von einem Computer aber nicht verstanden
und muß erst in eine vom Computer verstandene Form übersetzt (kompiliert)
werden.
Das Programm, welches Ihren Quelltext in eine vom Computer verstandene
Form übersetzt, nennt sich Compiler. Der Java-Compiler hat eine Besonderheit
— er erzeugt zwar für einen Computer verständlichen Code, aber der erzeugte
Code ist für keinen existierenden Computer verständlich.
Der Java-Compiler erzeugt Code — den sogenannten Java Bytecode, der von
einem sogenannten virtuellen Computer — der Java Virtual Machine
(JVM) — verstanden werden kann. Die Java Virtual Machine ähnelt real existierenden Prozessoren, berücksichtigt dabei aber die besonderen Eigenschaften
von Java.
Zum Java-System gehört nun ein Programm, welches diesen virtuellen Computer auf einem anderen Computer emuliert. Sie müssen also nach dem Kompilieren Ihres Quelltextes ein weiteres Programm starten, welches den Bytecode
entgegennimmt und interpretiert.
Natürlich kann Java damit nicht so schnell sein wie andere Programmiersprachen, die direkt Programmcode die jeweilige Zielplattform erzeugen, weil der
Prozessor niemals Java-Code direkt ausführt. Es gibt allerdings inzwischen Laufzeitsysteme, welche welche den Bytecode auf die jeweilige reale Hardware-Plattform
kompilieren und dort direkt ausführen können.
Die Tatsache, daß Java-Programme nicht auf eine spezielle Zielarchitektur kompiliert werden, bewirkt also daß Java-Programme nicht so schnell laufen wie in
anderen Sprachen entwickelte Software. Dennoch ist die Verwendung der virtuellen Maschine ein großer Vorteil und hat den Einsatz von Java im Internet erst
ermöglicht — hierdurch wird nämlich Systemunabhängigkeit erreicht.
In der Theorie läuft ein Java-Programm auf jeder Hardware und jedem Betriebssystem, für das eine virtuelle Maschine existiert. Man muß sich also nicht
mehr entscheiden, ob man ein Programm für Windows, Macintosh, Linux, HPUnix, Be-OS, OS/2 oder sonst ein Betriebssystem entwickelt. Sobald die virtuelle Java Maschine auf diesem Betriebssystem vorhanden ist, läuft hierauf jedes
Java-Programm identisch (wohlgemerkt: in der Theorie).
B.2
Kompilation
Wir wollen nun ein erstes Programm kompilieren. Bitte tippen Sie dazu folgendes Programm in einem Editor ein — beachten Sie dabei, Groß und Kleinschreibung exakt so wiederzugeben wie hier beschrieben.
public class HalloWelt
{
public static void main( String[] args )
{
145
}
Sie sollten immer darauf achten, daß der Name einer Programmdatei mit dem
Namen der enthaltenen Klasse beginnt und auf .java endet. Hier ist der Name
der Klasse “HalloWelt”. Speichern Sie daher den obigen Programmtext in der
Datei HalloWelt.java ab.
Um die Klasse zu kompilieren, gehen Sie bitte auf eine Unix-Shell und wechseln
in das Verzeichnis, in welchem Sie die Datei gespeichert haben. Hier geben Sie
dann ein
> javac HalloWelt.java
Wenn Sie beim Abtippen einen Fehler gemacht haben, meldet sich der Compiler
mit einer Fehlermeldung. Lesen Sie bitte die Fehlermeldung aufmerksam —
Sie sollten Fehlermeldungen immer aufmerksam lessen — und korrigieren ihn
bitte im Editor anschließend den in der Fehlermeldung beschriebenen Fehler.
Speichern Sie dann die Datei und kompilieren sie erneut.
Wenn Sie beim abtippen keine Fehler gemacht haben, sollte beim Kompilieren keine Ausgabe auf dem Bildschirm erzeugt worden sein aber die Datei
HalloWelt.class entstanden sein. Prüfen Sie dies bitte nach !
Die Datei HalloWelt.class enthält den Bytecode unserer Klasse. Sie können
das Programm nun laufen lassen, indem Sie die Java-Virtual-Machine mit unserem kompilierten Programm starten:
> java HalloWelt
Achten Sie bitte darauf, beim Aufruf von java nicht die Erweiterung .class
anzugeben. Dann wird ihre Klasse nämlich nicht gefunden.
Wenn Sie bis hierher alles nachgemacht haben, sollte der Text “Hallo, Welt” auf
dem Bildschirm ausgegeben werden.
B.3
Datentypen
Um dieses Kapitel zu verstehen, sollten Sie den Anhang ?? zum Aufbau eines
Computers gelesen haben.
Um die Attribute unserer Objekte zu definieren, haben wir bisher Wertebereiche
wie ganze Zahl, reelle Zahl, Zeichenkette oder Vektor verwendet. Wenn wir in
Java die Wertebereiche von Attributen beschreiben, kann man nicht einfach
einen umgangssprachlichen Ausdruck wie “ganze positivie Zahl” verwenden.
Der Java-Compiler muß schon etwas genauer wissen, was für Zahlen zu verwenden sind. Letztendlich muß ja jede Zahl in einem Java-Programm im Speicher
des Computers gespeichert werden. Es sollte einleuchtend sein, daß große Zahlen
mehr Platz zur Speicherung benötigen als kleine Zahlen — um eine 20 stellige
Zahl aufzuschreiben, benötigt man ja auch mehr Platz als für eine 2 stellige
Zahl. Es wäre nun sehr unangebracht, wenn der Java-Compiler jede ganzzahlige
Zahl
146
C
C.1
Probleme
Probleme bei Verwendung von javac
Beim Kompilieren einer Klassendatei
> javac MeineKlasse.java
treten manchmal folgende Fehlermeldungen auf:
bash: MeineKlasse.java: command not found
MeineKlasse.java:1: Class ak.Turtle.TurtleScreen not found in import.
import ak.Turtle.TurtleScreen;
^
MeineKlasse.java:2: Class ak.Turtle.Turtle not found in import.
import ak.Turtle.Turtle;
^
2 errors
Der Compiler findet die Turtle–Graphik nicht. Sie sollten die Turtle–Graphik
installieren und die Umgebungsvariable CLASSPATH prüfen. Siehe Anhang E
Sie haben das “>” Zeichen mit eingegeben. Wenn wir
C.2
> javac MeineKlasse.java
Beim Ausführen einer Klasse
Probleme bei Verwendung von java
schreiben, dann meinen wir damit, daß Sie auf der Kommandozeile den Text
javac MeineKlasse.java eingeben sollen. Das Größerzeichen verbildlicht also
die Kommandozeile und darf nicht mit eingetippt werden.
> java MeineKlasse
error: Can’t read: MeineKlasse.java
1 error
Can’t find class MeineKlasse.class
treten möglicherweise folgende Fehler auf:
Sie haben statt
Der Compiler findet die Datei nicht. Möglicherweise befinden Sie sich im falschen
Verzeichnis oder haben die Datei im Editor noch nicht oder unter einem anderen
Namen abgespeichert. Prüfen Sie, ob die Datei vorhanden ist:
> java MeineKlasse
das Kommando
> ll MeineKlasse.java
> java MeineKlasse.class
javac: invalid argument: MeineKlasse
use: javac [-g][-O][-debug][-depend][-nowarn][-verbose]
[-classpath path][-nowrite][-deprecation][-d dir]
[-J<runtime flag>] file.java...
verwendet.
In class MeineKlasse: void main(String argv[]) is not defined
Sie versuchen eine Klasse auszuführen, in welcher die main-Methode fehlt. Jede
Klasse, die Sie ausführen wollen, benötigt eine solche Methode. (siehe ??).
Sie haben statt
> javac MeineKlasse.java
In class MeineKlasse: void main(String argv[]) is not defined
den Befehl
Sie versuchen eine Klasse auszuführen, in welcher die main-Methode fehlt. Jede
Klasse, die Sie ausführen wollen, benötigt eine solche Methode. (siehe ??).
> javac MeineKlasse
eingegeben. Wenn der Name, den Sie an javac übergeben, nicht auf .java
endet, denkt javac, sie wollten ihm besondere Hinweise zur Kompilation geben.
Unable to initialize threads: cannot find class java/lang/Thread
Der Compiler findet die zum Java-System gehörigen Klassen nicht. Ihr JavaProgrammiersystem ist nicht korrekt installiert. Sie sollten die Umgebungsvariable CLASSPATH prüfen. Siehe Anhang E
147
Can’t find class MeineKlasse
Entweder existiert im aktuellen Verzeichnis keine Datei MeineKlasse.class,
oder die CLASSPATH–Variable enthält nicht das aktuelle Verzeichnis. Siehe Anhang E
Can’t find class MeineKlasse
148
Entweder existiert im aktuellen Verzeichnis keine Datei MeineKlasse.class,
oder die CLASSPATH–Variable enthält nicht das aktuelle Verzeichnis. Siehe Anhang E
java.lang.NoClassDefFoundError: ak/Turtle/TurtleScreen
at MeineKlasse.main(Compiled Code)
Die Turtle–Graphik ist nicht in über die CLASSPATH–Umgebungsvariable zugänglich. Siehe Anhang E
D
Goldene Regeln fürs Programmieren
Ihre erstellten Javaprogramme sollen nicht nur syntaktisch richtig, sondern auch
leicht zu lesen sein. Deshalb sollen Sie von der ersten Zeile an auf einen guten
Programmierstil achten. Dieser zeichnet sich vor allem dadurch aus, dass ihre
Programme gut gegliedert sind, Kommentare enthalten und von anderen leicht
verständlich zu lesen sind. Dadurch vermeiden Sie beim Programmieren Fehler
und ihre Programme sind besser wartbar. Um ihnen von Anfang an einen guten
Programmierstil beizubringen, möchten wir ihnen folgende Richtlinien mit auf
den Weg geben, die für diese Lehrveranstaltung verbindlivh sind.
D.1
Allgemeines
Hier nun ein paar allgemein Regeln auf die in den nächsten Abschnitten noch
näher eingegangen wird.
• Benutzen Sie maximal einen Befehl pro Zeile!
• Verwenden Sie sprechende Bezeichner.
• Folgen Sie bei der Benennung von Bezeichnern vorhersehbaren Konventionen.
• Kommentieren Sie die einzelnen Programmteile.
• Benutzen Sie eine sinnvolle und einheitliche Einrückung.
• Trennen Sie Programmteile durch Leerzeilen.
• Teilen Sie ein Programm sinnvoll auf.
• Vermeiden Sie “magic numbers”.
Benennen Sie Klassen nach ihrem Zweck, Variablen nach ihrem Inhalt, Methoden nach ihrer Aufgabe. Das Programm wird dadurch lesbarer, da es dann nicht
mehr notwendig ist, bei jedem Vorkommen eines Bezeichners zu überlegen, wozu
der Bezeichner da ist. Lassen Sie nach jedem Schlüsselwort und zwischen den
binären Operatoren ein Leerzeichen frei.
D.2
Quelldateien
Die Quelldateien sollen folgendes Aussehen besitzen:
• Übungskommentar
• package Anweisung
• import Anweisung
• Die als public deklarierte Klasse
• andere Klassen, falls erforderlich
149
150
Der Übungskommentar besteht aus dem Namen des Studenten, seiner Matrikelnummer, dem Datum und der Aufgabenstellung. Dieser Kommentar sollte
als spezieller “doc Kommentar” dargestellt werden, d. h. er beginnt mit einem
/** und endet mit */. Diese werden vom javadoc Programm speziell ausgewertet, um eine einfache Onlinedokumentation aus dem Javaquellcode zu erstellen.
Nutzen Sie auch die @author und @version tags. Hier ist kleines Beispiel:
/**
* Die Klasse Kreise mit ihren Daten und Methoden
* Hausaufgabe 3
* @author: Harry Hacker
* @version 1.2.3 31.04.00
*/
Benutzen Sie maximal einen Befehl pro Zeile! Tritt im Programm ein Fehler
auf, kann man seinen Ort häufig schnell auf eine Programmzeile einschränken.
Wenn dort dann mehrere Anweisungen stehen, ist eine Lokalisierung des Fehlers
schwierig. Auch die Fehlermeldungen des Compilers beziehen sich auf eine Zeile.
D.3
Klassen
Es ist üblich, Klassennamen mit einem Grossbuchstaben beginnen zu lassen.
Es empfiehlt sich, englischsprachige Bezeichner zu verwenden, da das gesamte
JDK englischsprachig ist. Wo möglich, sollten Ihre Wahl von Bezeichnern den
im JDK verwendeten Konventionen folgen.
Schreiben Sie als erstes die Variablen und Methoden auf, die als public deklariert werden und dann die als private deklarierten.
D.4
Methoden
Jede Methode (ausser main) beginnt mit einem Kommentar im javadoc Format.
/**
* Berechnet die Fakultaet von n
*/
public int fakultaet(int fac)
{ . . .
}
Vermeiden Sie Programmzeilen, die mehr als 80 Zeichen enthalten und Methoden mit mehr als 50 Zeilen, da beides die Übersichtlichkeit reduziert. Manchmal
lässt es sich aber nicht vermeiden, wie z.B. bei langen if/else Anweisungen.
Sie sollten jedoch immer komplexe Probleme in kleinere und einfachere Teilprobleme unterteilen.
men, so können Sie die nächstfolgenden Wörter auch mit einem grossen Buchstaben beginnen lassen, zum Beispiel firstPlayer. Definieren Sie nicht alle
Variablen sofort am Anfang eines Blockes,
public static double sqrt(double a)
{
double xold;
double xnew;
boolean more;
. . .
}
sondern dann wenn sie das erste mal gebraucht werden.
public static double sqrt(double a)
{
. . .
while(more)
{
double xnew = (xold + a / xold) / 2;
. . .
}
}
Benutzen Sie für Konstantenbezeichner nur Grossbuchstaben. Werden sie nicht
von anderen Klassen benötigt sollten als private deklariert werden.
privat static final int DAYS_PER_YEAR = 365
Vermeiden Sie im Programmtext die Verwendung von “magic numbers”. Eine
“magic number” ist eine Zahl die sie ohne Erklärung in ihrem Quellcode benutzen. Definieren Sie statt dessen an einer zentralen Stelle Konstanten und
verwenden Sie diese.
Wenn Sie ein Array der Grösse 100 dimensionieren, schreiben Sie nicht
int[] daten_Arr = new int[ 100 ]
sondern definieren Sie am Klassenanfang eine Konstante z.B. als
final int SIZE_DATEN_ARR = 100;
und dimensionieren das Array dann als
int[] daten_Arr = new int[ SIZE_DATEN_ARR ];
Benutzen Sie für Variablenbezeichner nur kleine Buchstaben. Setzt sich wegen
der besseren Lesbarkeit der Variablenbezeichner aus mehreren Wörtern zusam-
Wenn sich die Variable SIZE DATEN ARR später ändern sollte, sind Sie so auf
der sicheren Seite, ausserdem wird der Programmtext durch die Verwendung
sprechender Namen besser lesbar.
Wenn in einem Programmtext die Zahl π benötigt wird, schreiben Sie diese
nicht als 3.14159265358979323846 sondern definieren Sie am Klassenanfang die
Konstante
151
152
D.5
Variablen, Konstanten und Literale
final static double PI = 3.14159265358979323846;
E
E.1
D.6
Kontrollstrukturen
Benutzen Sie eine sinnvolle und einheitliche Einrückung. Die Einrückung soll
die Struktur des Programms deutlich machen. Die Lesbarkeit des Programms
wird deutlich erhöht, wenn zusammengehörige Programmteile auch optisch zusammen gehören. Achten Sie darauf, dass die Einrückung konsistent ist. Die
Einrücktiefe sollte jeweils drei Leerzeichen betragen. Benutzen Sie geschweifte
Klammern um die entsprechenden Zugehörigkeiten anzuzeigen, oder um sie zu
erzwingen. Bei diesem Beispiel ist nicht eindeutig wohin die else Anweisung
gehört.
if (n > 0)
if (a > b)
z = a;
else
z = b;
Installation von Java und Turtle–Graphik
Installation von Java
Wenn Sie im CIP–Pool arbeiten, ist dies schon für Sie erledigt. Falls Sie zuhause
arbeiten wollen, holen Sie sich bitte von Sun24 das JDK 1.2 für Ihr Betriebssystem und folgen den Installationsanweisungen.
E.2
Der CLASSPATH
Das JDK besteht aus sehr vielen Programmbausteinen (Klassen), die in auf die
Zeichenfolge .class endenden Dateien enthalten sind. Der Name einer Java–
Klasse besteht aus einer Pfadangabe und einem Klassennamen. Beispielsweise
bezeichnet der Klassenname
eip.TurtleScreen
Abhilfe erhält man durch das Benutzen von geschweiften Klammern.
if (n > 0)
{ if (a > b)
z = a;
else
z = b;
} /* {...} sind hier nicht erforderlich */
if (n > 0)
{ if (a > b)
z = a;
}
else
z = b; /* hier sind {...} erforderlich */
eine Klasse namens TurtleScreen, welche unter der Pfadangabe eip zu finden
ist. Da jeder Benutzer die Dateien auf seiner Festplatte unterschiedlich organisiert, muß Java irgendwie mitgeteilt werden, wo auf der Festplatte nach einer
derartigen Klasse gesucht werden soll.
Hierzu verwendet Java die CLASSPATH–Umgebungsvariable. Eine Umgebungsvariable ist ein Mittel des Betriebssystems zur Konfiguration von Programmen.
Die CLASSPATH–Variable enthält beliebig viele, durch Doppelpunkte getrennte Pfadangaben:
CLASSPATH=pfad1:pfad2:pfad3:...:pfadN
Dabei ist eine Pfadangabe entweder ein Verzeichnispfad oder der Name eines
.zip–Archives. Ein .zip–Archiv ist eine Datei, welche viele andere Dateien
enthält.
Beispiel: Unter Windows könnte eine CLASSPATH–Variable, welche auf
die Verzeichnissse c:\java\jdk\classes.zip, c:\java\turtle und . verweist, so ausssehen:
CLASSPATH=.:C:\java\jdk\classes.zip:C:\java\turtle
Die offene geschweifte und die dazugehörige geschlossene geschweifte Klammer
sollten entweder in der gleichen Spalte (vertikal) oder in der gleichen Zeile (horizontal) angeordnet sein. Dies erleichtert die Überprüfung ob alle Klammern
ordentlich gesetzt wurden.
while (i < n) { print(a[i]); i++; }
while (i < n)
{
print(a[i]);
i++;
}
Unter Unix könnte die CLASSPATH–Variable so aussehen:
CLASSPATH=.:/usr/local/java/jdk/classes.zip:/usr/local/java/turtle/
Wenn Java nach der Klase eip.TurtleScreen sucht, geht es wie folgt vor: Es
schaut in jedem im CLASSPATH angegebene Verzeichnis nach, ob es eine Datei
ak/Turtle/TurtleScreen.class enthält (unter Windows würde Java schauen,
ob es eine Datei ak\Turtle\TurtleScreen.class findet). Die erste derartige
Datei, die in einem Verzeichnis des CLASSPATH gefunden wird, wird dann benutzt.
24 http://www.java.sun.com/products/
153
154
Beispiel: Wenn unter Unix der CLASSPATH wie oben angegeben ist,
würde Java zuerst nachsehen, ob die Datei ak/Turtle/Turtle.class in
der .zip–Datei /usr/local/java/jdk/classes.zip enthalten ist.
Prüfen Sie nun, ob die Datei ~/turtle/ak/Turtle/Turtle.java existiert.
Anschließend setzen Sie bitte, wie im nächsten Kapitel beschrieben, den
CLASSPATH und testen die Turtle durch den Befehl
Wenn dies nicht der Fall ist, würde Java nachschauen, ob die Datei
/usr/local/java/turtle/ak/Turtle/Turtle.class existiert.
> java eip.TurtleDemo
Falls auch dies nicht der Fall ist, würde Java nachsehen, ob im aktuellen Verzeichnis das Unterverzeichnis ak/Turtle/ und darin die Datei
TurtleScreen.class existiert.
• Um die Turtle–Graphik unter Windows zu installieren, holen Sie sich bitte
von unseren WWW–Seiten26 die Datei Turtle.zip.
Sie benötigen außerdem den Entpacker unzip27 oder Winzip28 (Winzip ist
eine kommerzielle Software — es ist üblich, daß fast alle unter Unix frei
erhältliche Software unter Windows Geld kostet).
Der CLASSPATH wird immer benutzt, wenn Java eine Datei sucht. Ob Sie Java
innerhalb eines Programms durch den Befehl
import eip.TurtleScreen;
anweisen, die Klasse eip.TurtleScreen zu verwenden, oder ob Sie auf der Kommandozeile ein Javaprogramm per
Legen Sie bitte ein Verzeichnis für die Turtle an (z.B. C:\java\turtle).
Dies geht entweder mit Hilfe des Explorers oder auf der Windows–Kommandozeile
per
> java MeineKlasse
> mkdir C:\java\turtle
starten — immer wird die Klasse mit Hilfe des CLASSPATH gesucht.
Dies kann zu verwirrenden Effekten führen, wenn im CLASSPATH nicht auch das
aktuelle Arbeitsverzeichnis namens .“ enthalten ist. Denn dann kann Java Ihre
”
Klassendatei selbst dann nicht finden, wenn Sie im aktuellen Arbeitsverzeichnis
zu finden ist.
Wenn im Arbeitsverzeichnis die Datei MeineKlasse.java existiert und .“ nicht
”
im CLASSPATH enthalten ist, so erhalten Sie auf den Befehl java MeineKlasse
die Meldung
anschließend entpacken Sie bitte die Datei Turtle.zip hier hinein. Achten
Sie dabei darauf, daß beim Entpacken alle Pfade wiederhergestellt werden.
Wie das geht, ist in der Dokumentation des Entpackers beschrieben.
Sehen Sie nach dem Entpacken nach, ob die Datei
c:\java\turtle\ak\Turtle\Turtle.java
existiert — sonst ist irgendwas schief gegangen.
Anschließend setzen Sie bitte, wie im nächsten Abschnitt beschrieben, den
CLASSPATH und testen die Turtle durch den Befehl
Can’t find class MeineKlasse
In solch einem Fall nehmen Sie das aktuelle Arbeitsverzeichnis in Ihren CLASSPATH
auf.
Weiter unten beschreiben wir, wie man den CLASSPATH erweitern kann.
E.3
Installation der Turtle–Graphik
> java eip.TurtleDemo
E.4
Erweitern des CLASSPATH
Sie können den CLASSPATH wie folgt um weitere Suchpfade erweitern.
• Um die Turtle–Graphik unter Unix zu installieren, holen Sie sich bitte
von unseren WWW–Seiten25 die Datei Turtle.tgz und legen Sie sie in
Ihr Homeverzeichnis.
Legen Sie dann bitte ein Verzeichnis für die Turtle an (z.B. ~/turtle).
Dies geht auf der Unix–Kommandozeile per
> mkdir ~/turtle
Dann entpacken Sie die Datei Turtle.tgz wie folgt:
>
>
>
>
• Wenn Sie unter Unix arbeiten und die bash–Shell verwenden, können Sie
auf der Kommandozeile eingeben
export CLASSPATH=$CLASSPATH:neuerPfad
Angenommen, Sie haben die Turtle–Graphik im Verzeichnis ~/turtle installiert, so sollten Sie den CLASSPATH wie folgt erweitern:
export CLASSPATH=$CLASSPATH:~/turtle
cd ~
gzip -d Turtle.tgz
cd ~/turtle
tar xvf ~/Turtle.tar
26 http://www.tu-bs.de/institute/wir/eip/
27 http://www.cdrom.com/pub/infozip/UnZip.html
28 http://www.winzip.com/
25 http://www.tu-bs.de/institute/wir/eip/
155
156
Diesen Befehl müssen Sie jedesmal erneut eingeben, wenn Sie eine Kommandozeile öffnen. Sie können den Befehl statt dessen auch als letzte Zeile
in die Datei ~/.profile aufnehmen. Dann wird der CLASSPATH bei jedem
anmelden automatisch gesetzt.
• Unter Windows können Sie dazu auf der Kommandozeile eingeben
set CLASSPATH=%CLASSPATH%:neuerPfad
Angenommen, Sie haben die Turtle–Graphik im Verzeichnis C:\java\turtle\
installiert, so sollten Sie den CLASSPATH wie folgt erweitern:
set CLASSPATH=%CLASSPATH%:C:\java\turtle
Diese Zeile müssen Sie jedesmal eingeben, wenn Sie eine Kommandozeile
öffnen. Wenn Sie die obige Zeile als letzte Zeile in die Datei C:\autoexec.bat
aufnhemen, wird der CLASSPATH bei jedem Neustart von Windows automatisch gesetzt.
157