Java-Einführung

Kursunterlage
Hubert Partl
partl@mail.boku.ac.at
Zentraler Informatikdienst
Universitat fur Bodenkultur Wien
Version Februar 2001

Vorwort
Die vorliegende Java-Einfuhrung beschreibt nur kurz die wichtigsten Eigenschaften
von Java, die fur die meisten Anwendungen benotigt werden. Fur daruber hinaus
gehende spezielle Features und Anwendungen sowie fur ausfuhrlichere Informationen
wird auf die Referenzen und auf die Online-Dokumentation verwiesen.
Die vorliegende Fassung beschreibt Java ab der Version JDK 1.1.
Die Java-Einfuhrung besteht aus zwei Teilen:
der eigentlichen Kursunterlage mit Beispielen und Ubungsaufgaben, und
Musterlosungen zu den Ubungsaufgaben.
Wenn Sie Java erfolgreich lernen wollen, empfehle ich Ihnen dringend, die Musterlosungen
erst dann auszudrucken und anzusehen, wenn Sie bereits alle Ubungsbeispiele
selbstandig fertig programmiert haben, also erst am Ende des Kurses.
Diese Kursunterlage enthalt mehr Informationen und mehr Ubungsbeispiele, als innerhalb
eines 5-tagigen Kurses durchgearbeitet werden konnen. Der Kursleiter mu
auswahlen, welche Teile und Kapitel er besprechen will und welche Ubungsaufgaben
er den Teilnehmern stellen will. Die ubrigen Kapitel und Beispiele dienen dann zum
Nachschlagen fur spater, wenn die Teilnehmer das Gelernte praktisch anwenden
wollen.
Wenn Ihnen meine Java-Einfuhrung gefallt, sagen Sie es weiter. Wenn Sie darin
Fehler entdecken oder Verbesserungsvorschlage haben, sagen Sie es bitte mir per
E-Mail an partl@mail.boku.ac.at - ich freue mich immer uber solche Hilfe.
Ich danke Gudio Kruger, Stefan Zeiger, Peter van der Linden, Roedy Green und allen
anderen Internet-Surfern, die mir gute Tips gegeben und Tippfehler korrigiert haben,
sowie den Teilnehmern an meinen Java-Schulungen, die mir interessante Fragen
gestellt haben.
Hubert Partl
Wien, im Janner 1998
P.S.: Diese "Java-Einfuhrung" ist auch uber das Internet verfugbar, unter dem URL
http://www.boku.ac.at/javaeinf/
Copyright Hubert Partl partl@mail.boku.ac.at
Java-Einfuhrung von H. Partl { Kursunterlage 1

Inhaltsverzeichnis
1 Was ist Java? 8
1.1 Insel, Kaee oder Programmiersprache : : : : : : : : : : : : : : : : : 8
1.2 Applikationen (application) : : : : : : : : : : : : : : : : : : : : : : : 9
1.3 Applets : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 9
1.4 JavaScript ist nicht Java : : : : : : : : : : : : : : : : : : : : : : : : : 9
2 Software und Online-Dokumentation 10
2.1 Java Development Kit (JDK) : : : : : : : : : : : : : : : : : : : : : : 10
2.2 Environment-Variable : : : : : : : : : : : : : : : : : : : : : : : : : : 11
2.3 Filenamen : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 12
2.4 Java Compiler (javac) : : : : : : : : : : : : : : : : : : : : : : : : : : 12
2.5 Java Runtime System (java) : : : : : : : : : : : : : : : : : : : : : : : 13
2.6 Web-Browser und Appletviewer : : : : : : : : : : : : : : : : : : : : : 13
2.7 Online-Dokumentation (API) : : : : : : : : : : : : : : : : : : : : : : 14
2.8 Java-Archive (jar) : : : : : : : : : : : : : : : : : : : : : : : : : : : : 15
2.9 Software-Tools : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 15
2.10 Java Beans : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 16
2.11 Vorgangsweise : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 16
2.12 Beispiel: Einfache HelloWorld-Applikation : : : : : : : : : : : : : : : 17
2.13 Ubung: HelloWorld-Applikation : : : : : : : : : : : : : : : : : : : : : 17
2.14 Ubung: Online-Dokumentation : : : : : : : : : : : : : : : : : : : : : 17
2.15 Typische Anfanger-Fehler : : : : : : : : : : : : : : : : : : : : : : : : 18
3 Syntax und Statements 19
3.1 Grundbegrie der Programmierung : : : : : : : : : : : : : : : : : : : 19
3.2 Namenskonventionen : : : : : : : : : : : : : : : : : : : : : : : : : : : 20
3.3 Reservierte Worter : : : : : : : : : : : : : : : : : : : : : : : : : : : : 20
3.4 Datentypen : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 20
3.5 Konstante (Literals) : : : : : : : : : : : : : : : : : : : : : : : : : : : 21
3.6 Deklarationen und Anfangswerte : : : : : : : : : : : : : : : : : : : : 21
3.7 Referenzen (reference) auf Objekte oder Strings : : : : : : : : : : : : 22
3.8 Garbage Collector : : : : : : : : : : : : : : : : : : : : : : : : : : : : 22
3.9 Felder (array) : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 23
3.10 Ausdrucke (expression) und Operatoren : : : : : : : : : : : : : : : : 25
3.11 Text-Operationen (String) : : : : : : : : : : : : : : : : : : : : : : : : 26
3.12 Funktionen (Math) : : : : : : : : : : : : : : : : : : : : : : : : : : : : 27
3.13 Statements und Blocke : : : : : : : : : : : : : : : : : : : : : : : : : : 27
3.14 Kommentare : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 27
Java-Einfuhrung von H. Partl { Kursunterlage 2

3.15 if und else : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 27
3.16 for : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 27
3.17 while und do : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 28
3.18 switch und case : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 28
3.19 break und continue : : : : : : : : : : : : : : : : : : : : : : : : : : : : 28
3.20 System.exit : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 28
3.21 Beispiele fur einfache Programme : : : : : : : : : : : : : : : : : : : : 29
3.22 Fehlersuche und Fehlerbehebung (Debugging) : : : : : : : : : : : : : 32
3.23 Dokumentation von Programmen (javadoc) : : : : : : : : : : : : : : 34
3.24 Ubung: einfaches Rechenbeispiel Quadratzahlen : : : : : : : : : : : : 35
3.25 Ubung: einfaches Rechenbeispiel Sparbuch : : : : : : : : : : : : : : : 35
4 Objekte und Klassen 36
4.1 Objekt-Orientierung : : : : : : : : : : : : : : : : : : : : : : : : : : : 36
4.2 Klassen (class) : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 37
4.3 Beispiel: objekt-orientierte HelloWorld-Applikation : : : : : : : : : : 38
4.4 Datenfelder (member eld) : : : : : : : : : : : : : : : : : : : : : : : 39
4.5 Methoden (method) : : : : : : : : : : : : : : : : : : : : : : : : : : : 40
4.6 Uberladen (overload) : : : : : : : : : : : : : : : : : : : : : : : : : : : 41
4.7 statische Methoden (static) : : : : : : : : : : : : : : : : : : : : : : : 41
4.8 main-Methode : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 42
4.9 Konstruktoren (constructor) : : : : : : : : : : : : : : : : : : : : : : : 42
4.10 Kapselung (Encapsulation, Data Hiding, Java Beans) : : : : : : : : : 44
4.11 Beispiel: schlechte Datums-Klasse : : : : : : : : : : : : : : : : : : : : 45
4.12 Beispiel: bessere Datums-Klasse : : : : : : : : : : : : : : : : : : : : : 46
4.13 Ubung: einfache Kurs-Klasse : : : : : : : : : : : : : : : : : : : : : : 50
4.14 Objekt-orientierte Analyse und Design : : : : : : : : : : : : : : : : : 50
4.15 Beispiel: Analyse Schulungen : : : : : : : : : : : : : : : : : : : : : : 51
4.16 Ubung: Analyse Bucherregal : : : : : : : : : : : : : : : : : : : : : : : 51
4.17 Vererbung (Inheritance, Polymorphismus, override) : : : : : : : : : : 52
4.18 Ubung: Person und Student : : : : : : : : : : : : : : : : : : : : : : : 53
4.19 Mehrfache Vererbung, Interfaces, abstrakte Klassen : : : : : : : : : : 54
4.20 Beispiel: Katzenmusik : : : : : : : : : : : : : : : : : : : : : : : : : : 55
4.21 Innere Klassen (inner class) : : : : : : : : : : : : : : : : : : : : : : : 56
4.22 Zugri auf Objekte von anderen Klassen : : : : : : : : : : : : : : : : 56
4.23 Packages und import : : : : : : : : : : : : : : : : : : : : : : : : : : : 57
5 Fehlerbehandlung (Exceptions) 58
5.1 Fehler erkennen (throw, throws) : : : : : : : : : : : : : : : : : : : : : 58
5.2 Fehler abfangen (try, catch) : : : : : : : : : : : : : : : : : : : : : : : 59
5.3 Mathematische Fehler : : : : : : : : : : : : : : : : : : : : : : : : : : 60
5.4 Ubung: erweitertes Rechenbeispiel Sparbuch : : : : : : : : : : : : : : 61
Java-Einfuhrung von H. Partl { Kursunterlage 3

6 Graphical User Interfaces (GUI) 63
6.1 Abstract Windowing Toolkit (AWT) : : : : : : : : : : : : : : : : : : 63
6.2 AWT-Komponenten (Component) : : : : : : : : : : : : : : : : : : : 64
6.3 Container : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 67
6.4 Layout-Manager : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 68
6.5 Ubung: Layout-Manager : : : : : : : : : : : : : : : : : : : : : : : : : 70
6.6 Farben (Color) : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 70
6.7 Schriften (Font) : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 71
6.8 Groenangaben : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 72
6.9 Zeichenobjekte (Canvas) : : : : : : : : : : : : : : : : : : : : : : : : : 73
6.10 Graphiken (Graphics, paint) : : : : : : : : : : : : : : : : : : : : : : : 73
6.11 mehrzeilige Texte : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 76
6.12 Event-Handling : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 77
6.13 Beispiel: typischer Aufbau einer einfachen GUI-Applikation : : : : : 79
6.14 Beispiel: typischer Aufbau einer komplexen GUI-Applikation : : : : 81
6.15 Ubung: einfache GUI-Applikation : : : : : : : : : : : : : : : : : : : : 84
6.16 Swing-Komponenten (JComponent) : : : : : : : : : : : : : : : : : : 85
7 Applets 89
7.1 Sicherheit (security, sandbox, signed applets) : : : : : : : : : : : : : 89
7.2 HTML-Tags : : : : : : : : : : 90
7.3 Beispiel: einfaches HelloWorld Applet : : : : : : : : : : : : : : : : : 91
7.4 Ubung: einfaches HelloWorld Applet : : : : : : : : : : : : : : : : : : 92
7.5 Methoden init, start, stop : : : : : : : : : : : : : : : : : : : : : : : : 93
7.6 Groenangabe : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 93
7.7 Beenden des Applet : : : : : : : : : : : : : : : : : : : : : : : : : : : 94
7.8 Beispiel: typischer Aufbau eines Applet mit Button-Aktionen : : : : 94
7.9 Beispiel: typischer Aufbau eines Applet mit Maus-Aktionen : : : : : 95
7.10 Beispiel: typischer Aufbau eines Applet mit Text-Eingaben : : : : : 96
7.11 Ubung: einfaches Applet Thermostat : : : : : : : : : : : : : : : : : : 97
7.12 Ubung: Applet einfache Verkehrsampel : : : : : : : : : : : : : : : : : 98
7.13 Ubung: komplexes Applet Sparbuch : : : : : : : : : : : : : : : : : : 99
7.14 Ubung: komplexes Applet: Baume im Garten : : : : : : : : : : : : : 99
7.15 Vermeidung von Flimmern oder Flackern (buered image) : : : : : : 100
7.16 Uniform Resource Locators (URL) : : : : : : : : : : : : : : : : : : : 101
7.17 Bilder (Image, MediaTracker) : : : : : : : : : : : : : : : : : : : : : : 102
7.18 Tone (sound, AudioClip) : : : : : : : : : : : : : : : : : : : : : : : : 103
7.19 Parameter : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 104
7.20 Web-Browser : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 105
7.21 Ubung: Zwei Applets : : : : : : : : : : : : : : : : : : : : : : : : : : : 107
7.22 Applet-Dokumentation : : : : : : : : : : : : : : : : : : : : : : : : : : 107
7.23 Doppelnutzung als Applet und Applikation : : : : : : : : : : : : : : 108
Java-Einfuhrung von H. Partl { Kursunterlage 4

8 Threads 110
8.1 Multithreading, Thread, Runnable : : : : : : : : : : : : : : : : : : : 110
8.2 Starten eines Thread (start) : : : : : : : : : : : : : : : : : : : : : : : 111
8.3 Beenden oder Abbrechen eines Thread : : : : : : : : : : : : : : : : : 112
8.4 Unterbrechungen (sleep) : : : : : : : : : : : : : : : : : : : : : : : : : 113
8.5 Synchronisierung (join, wait, notify, synchronized) : : : : : : : : : : 114
8.6 Beispiel: eine einfache Animation : : : : : : : : : : : : : : : : : : : : 115
8.7 Ubung: einfaches Applet Blinklicht : : : : : : : : : : : : : : : : : : : 116
8.8 Ubung: erweitertes Applet Verkehrsampel mit Blinklicht : : : : : : : 117
9 Ein-Ausgabe (IO) 119
9.1 Dateien (Files) und Directories : : : : : : : : : : : : : : : : : : : : : 119
9.2 Datenstrome (stream) : : : : : : : : : : : : : : : : : : : : : : : : : : 121
9.3 InputStream (Eingabe) : : : : : : : : : : : : : : : : : : : : : : : : : : 122
9.4 Spezielle Input-Streams : : : : : : : : : : : : : : : : : : : : : : : : : 123
9.5 Lesen einer Datei von einem Web-Server (URL) : : : : : : : : : : : : 124
9.6 OutputStream (Ausgabe) : : : : : : : : : : : : : : : : : : : : : : : : 125
9.7 Spezielle Output-Streams : : : : : : : : : : : : : : : : : : : : : : : : 126
9.8 RandomAccessFile (Ein- und Ausgabe) : : : : : : : : : : : : : : : : 128
9.9 Reader und Writer (Text-Files) : : : : : : : : : : : : : : : : : : : : : 129
9.10 Reader : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 132
9.11 Writer : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 133
9.12 Ubung: zeilenweises Ausdrucken eines Files : : : : : : : : : : : : : : 135
9.13 Ubung: zeichenweises Kopieren eines Files : : : : : : : : : : : : : : : 135
9.14 Ubung: Lesen eines Files uber das Internet : : : : : : : : : : : : : : : 135
10 Networking 136
10.1 Java im Web-Server (CGI, Servlets) : : : : : : : : : : : : : : : : : : 136
10.2 Internet-Protokoll, Server und Clients : : : : : : : : : : : : : : : : : 138
10.3 Sockets : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 139
10.4 Beispiel: typischer Aufbau eines Servers : : : : : : : : : : : : : : : : 141
10.5 Beispiel: typischer Aufbau eines Client : : : : : : : : : : : : : : : : : 142
10.6 Ubung: einfache Client-Server-Applikation : : : : : : : : : : : : : : : 143
11 System-Funktionen und Utilities 144
11.1 Datum und Uhrzeit (Date) : : : : : : : : : : : : : : : : : : : : : : : 144
11.2 Date Version 1.0 : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 145
11.3 Date und Calendar Version 1.1 : : : : : : : : : : : : : : : : : : : : : 149
11.4 Zeitmessung : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 151
11.5 Ausdrucken (PrintJob, PrinterJob) : : : : : : : : : : : : : : : : : : : 152
11.6 Ausfuhrung von Programmen (Runtime, exec) : : : : : : : : : : : : 154
11.7 Verwendung von Unterprogrammen (native methods, JNI) : : : : : : 156
Java-Einfuhrung von H. Partl { Kursunterlage 5

12 Datenbanken 158
12.1 Relationale Datenbanken : : : : : : : : : : : : : : : : : : : : : : : : : 158
12.2 Structured Query Language (SQL) : : : : : : : : : : : : : : : : : : : 161
12.3 Datenbank-Zugrie in Java (JDBC) : : : : : : : : : : : : : : : : : : 163
12.4 Driver : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 165
12.5 Connection : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 166
12.6 Statement : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 167
12.7 ResultSet : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : : 168
12.8 PreparedStatement : : : : : : : : : : : : : : : : : : : : : : : : : : : : 170
12.9 DatabaseMetaData und ResultSetMetaData : : : : : : : : : : : : : : 171
12.10Datenbank-Anwendungen uber das Internet : : : : : : : : : : : : : : 172
12.11Ubung: eine kleine Datenbank : : : : : : : : : : : : : : : : : : : : : : 173
13 Referenzen 176
Beilage: Losungen der Ubungsaufgaben
Java-Einfuhrung von H. Partl { Kursunterlage 6

Grundlagen
Was ist Java?
Software und Online-Dokumentation
Syntax und Statements
Objekte und Klassen
Fehlerbehandlung (Exceptions)
Java-Einfuhrung von H. Partl { Kursunterlage 7

1. Was ist Java?
1.1 Insel, Kaee oder Programmiersprache
Java wurde von der Firma Sun entwickelt und erstmals am 23. Mai 1995 als neue,
objekt-orientierte, einfache und plattformunabhangige Programmiersprache vorgestellt.
Sun besitzt weiterhin das Schutzrecht auf den Namen Java, die Sprache ist
aber fur alle Computersysteme verfugbar (im allgemeinen kostenlos) und ist seit
1997 auf dem Weg, eine ozielle ISO-Norm zu werden.
Java geht auf die Sprache Oak zuruck, die 1991 von Bill Joy, James Gosling und
Mike Sheridan im Green-Projekt entwickelt wurde, mit dem Ziel, eine einfache und
plattformunabhangige Programmiersprache zu schaen, mit der nicht nur normale
Computer wie Unix-Workstations, PCs und Apple programmiert werden konnen,
sondern auch die in Haushalts- oder Industriegeraten eingebauten Micro-Computer,
wie z.B. in Waschmaschinen und Videorekordern, Autos und Verkehrsampeln, Kreditkarten
und Sicherheitssystemen und vor allem auch in TV-Settop-Boxes fur "intelligente"
Fernsehapparate.
Allgemein anerkannt wurde Java aber erst seit 1996 in Verbindung mit Web-
Browsern und Internet-Anwendungen sowie mit der Idee eines NC (Network Computer),
der im Gegensatz zum PC (Personal Computer) nicht lokal installierte, maschinenspezische
Software-Programme benotigt, sondern die Software in Form von
Java-Applets uber das Netz (Intranet) von einem zentralen Server laden kann.
Der Name wurde nicht direkt von der sudostasiatischen Insel Java ubernommen
sondern von einer bei amerikanischen Programmierern popularen Bezeichnung fur
Kaee.
Die wichtigsten Eigenschaften von Java sind:
plattformunabhangig
Objekt-orientiert
Syntax ahnlich wie bei C und C++
umfangreiche Klassenbibliothek
Sicherheit von Internet-Anwendungen
Bei Java-Programmen mu zwischen zwei grundsatzlichen Arten unterschieden werden:
Applikationen und Applets.
Java-Einfuhrung von H. Partl { Kursunterlage 8

1.2 Applikationen (application)
1.3 Applets
Java-Applikationen sind Computer-Programme mit dem vollen Funktionsumfang,
wie er auch bei anderen Programmiersprachen gegeben ist. Applikationen konnen
als lokale Programme auf dem Rechner des Benutzers laufen oder als Client-Server-
Systeme uber das Internet bzw. uber ein Intranet oder als Server-Programme (Servlets,
CGI-Programme) auf einem Web-Server.
Technisch gesehen zeichnen sich Java-Applikationen dadurch aus, da sie eine statische
Methode main enthalten.
Java-Applets werden innerhalb einer Web-Page dargestellt und unter der Kontrolle
eines Web-Browsers ausgefuhrt. Sie werden meist uber das Internet von einem Server
geladen, und spezielle Sicherungen innerhalb des Web-Browsers ("Sandkasten",
sandbox) sorgen dafur, da sie keine unerwunschten Wirkungen auf den Client-
Rechner haben konnen. So konnen Applets z.B. im allgemeinen nicht auf lokale
Files, Systemkomponenten oder Programme zugreifen und auch nicht auf Internet-
Verbindungen auer zu dem einen Server, von dem sie geladen wurden.
Technisch gesehen zeichnen sich Java-Applets dadurch aus, da sie Unterklassen der
Klasse Applet sind.
Die meisten in dieser Kursunterlage beschriebenen Regeln gelten gleichermaen fur
Applikationen und Applets. Die Spezialitaten, die nur fur Applets gelten, sind in
einem eigenen Kapitel uber Applets zusammengefat.
1.4 JavaScript ist nicht Java
JavaScript ist eine Skript-Sprache, die in HTML eingebettet werden kann und
bei manchen Web-Browsern (Netscape, Internet-Explorer) die Ausfuhrung von bestimmten
Funktionen und Aktionen innerhalb des Web-Browsers bewirkt.
Im Gegensatz zu Java ist JavaScript
keine selbstandige Programmiersprache,
nicht von der Browser-Version unabhangig,
nicht mit den notwendigen Sicherheitsmechanismen ausgestattet.
Java-Einfuhrung von H. Partl { Kursunterlage 9

2. Software und Online-Dokumentation
2.1 Java Development Kit (JDK)
Das Java Development Kit (JDK) umfat die fur die Erstellung und das Testen
von Java-Applikationen und Applets notwendige Software, die Packages mit den zur
Grundausstattung gehorenden Java-Klassen, und die Online-Dokumentation.
Zur Software gehoren der Java-Compiler, das Java Runtime Environment (die Java
Virtual Machine) fur die Ausfuhrung von Applikationen, der Appletviewer fur die
Ausfuhrung von Applets, ein Java-Debugger und verschiedene Hilfsprogramme.
Die Online-Dokumentation umfat eine Beschreibung aller Sprachelemente und aller
Klassen des Application Program Interface API.
Java ist eine sehr junge Programmiersprache und daher noch immer in Entwicklung,
d.h. es kommen immer wieder neue Versionen mit Erganzungen und Verbesserungen
heraus:
Die Urversion ist JDK 1.0 (1995).
Im Jahr 1997 kam Version 1.1 heraus, das brachte sowohl Anderungen und
neue Konzepte (bei den Methodennamen gema den Beans-Konventionen,
beim Event-Handlung, bei den Text-Files) als auch Erweiterungen durch
zusatzliche Packages (z.B. fur Datenbanken).
Ende 1998 kam Version 1.2 mit umfangreichen Erweiterungen (unter anderem
Swing).
Anfang 2000 folgte Version 1.3 mit Fehlerkorrekturen und Performance-
Verbesserungen.
Fu Ende 2001 oder 2002 kann mit einer neuen Version 1.4 gerechnet werden,
die voraussichtlich wieder groere Erweiterungen bringen wird.
Seit Version 1.2 wird das JDK auch "Java-Plattform 2" genannt, und das "Java 2
Software Development Kit (SDK)" bedeutet dann das jeweils aktuelle JDK 1.x.
Die Browser-Unterstutzung fur Java-Applets hinkt dieser Entwicklung meistens um
1 bis 2 Jahre nach:
Altere Web-Browser unterstutzen (wenn uberhaupt) nur Version 1.0.
Neuere Browser-Versionen unterstutzen wenigstens teilweise Version 1.1 (Netscape
ab Version 4.04-J2 bzw. 4.06, Internet Explorer ab Version 4.0).
Mit Hilfe des "Java Activator" (Java Plug-in) von der Firma Sun kann man
auch altere Browser-Versionen auf die jeweils neueste Java-Version (1.1, 1.2, ...)
aufrusten sowie den Microsoft Internet Explorer, der Java nicht vollstandig unterstutzt,
zu einem 100-prozentig Java-fahigen Browser machen. Bei Netscape
ab Version 6.0, iPlanet und Mozilla ist dies der Standardfall.
Java-Einfuhrung von H. Partl { Kursunterlage 10

Wenn Sie Applets fur die Verwendung durch einen groeren Benutzerkreis uber
das Internet erstellen, mussen Sie diese Einschrankungen berucksichtigen. Der mit
dem JDK mitgelieferte Appletviewer unterstutzt die jeweilige Version ohne Einschrankungen.
Das JDK fur ein bestimmtes System erhalt man meist kostenlos (z.B. zum Download
uber das Internet) vom jeweiligen Hersteller, also die Solaris-Version von Sun,
die HP-Version von HP, die IBM-Version von IBM. Versionen fur Windows-PC,
Macintosh und Linux kann man von Sun oder IBM bekommen.
2.2 Environment-Variable
Normalerweise genugt es, das Directory, in dem sich die Java-Software bendet,
in die PATH-Variable einzufugen. Die anderen Variablen (CLASSPATH,
JAVA HOME) werden nur in Spezialfallen oder innerhalb der Software benotigt
und mussen normalerweise nicht gesetzt werden. Die folgenden Hinweise sind also
in den meisten Fallen nicht notwendig.
Die Variable CLASSPATH gibt an, in welchen Directories nach Klassen und Packages
gesucht werden soll, getrennt durch Doppelpunkte (Unix) bzw. Strichpunkte
(Windows). Im allgemeinen gibt man hier den Punkt (fur das jeweils aktuelle Directory)
und das Start-Directory der im JDK enthaltenen Packages an. Bei neueren
JDK-Versionen ist das jedoch der Standard und der CLASSPATH soll daher gar
nicht gesetzt werden.
Die Variable JAVA HOME gibt an, in welchem Directory die Komponenten des
JDK zu nden sind. Die explizite Angabe ist meistens ebenfalls nicht notwendig.
Damit man den Java-Compiler, das Runtime-System, den Appletviewer etc. einfach
aufrufen kann, sollte das entsprechende bin-Directory in der PATH-Variablen
enthalten sein.
Beispiele fur die eventuelle Denition dieser Environment-Variablen (die Details
hangen von der jeweiligen Software-Version und deren Konguration und Installation
ab):
Unix, C-Shell, im File .cshrc:
setenv PATH ${PATH}:/opt/java/bin
setenv CLASSPATH .:/opt/java/src
setenv JAVA_HOME /opt/java
Unix, Korn-Shell oder Bourne-Shell, im File .prole oder .java wrapper:
export PATH=${PATH}:/opt/java/bin
export CLASSPATH=.:/opt/java/src
export JAVA_HOME=/opt/java
MS-Windows, im File autoexec.bat:
set PATH=%PATH%;C:\jdk1.1.5\bin
set CLASSPATH=.;C:\jdk1.1.5\lib\classes.zip;
set JAVA_HOME=C:\jdk1.1.5
Java-Einfuhrung von H. Partl { Kursunterlage 11

2.3 Filenamen
Jedes Java-Source-File darf nur eine public Klasse enthalten, und der Filename
mu dann der Name dieser Klasse (mit der richtigen Gro-Kleinschreibung) mit der
Extension .java sein, hat also die Form
Xxxxx.java
Wenn man das Source-File auf einem PC mit MS-Word, Wordpad oder Notepad
erstellt, mu man darauf achten, da es mit dem Dateityp Text-File (nicht Word-
File) erstellt wird und da nicht automatisch eine Extension .txt angehangt wird.
Eventuell mu man also beim Speichern den Filenamen mit Quotes in der Form
"Xxxxx.java"
schreiben, damit man nicht einen Filenamen der Form Xxxxx.java.txt erhalt.
Der Java-Compiler erzeugt fur jede Klasse ein eigenes File, das den Bytecode dieser
Klasse enthalt. Der Filename ist dann der Name der Klasse mit der Extension .class,
hat also die Form
Xxxxx.class
Man kann auch mehrere Klassen-Files in ein komprimiertes Archiv-File zusammenfassen,
das dann weniger Ubertragungszeit uber das Internet benotigt. Solche Java-
Archiv-Files haben Namen der Form
xxx.jar
2.4 Java Compiler (javac)
Der Aufruf des Java-Compilers erfolgt im einfachsten Fall in der Form
javac Xxxxx.java
Der Name des Source-Files mu mit der Extension .java angegeben werden, und es
konnen auch mehrere Source-Files angegeben werden:
javac Xxxxx.java Yyyyy.java
Falls die Klasse andere Klassen verwendet, die neu ubersetzt werden mussen, werden
diese automatisch ebenfalls ubersetzt, ahnlich wie bei der Unix-Utility make.
Der Compiler erzeugt fur jede Klasse ein File Xxxxx.class, das den Bytecode enthalt.
Dieser Bytecode ist plattformunabhangig: Egal auf was fur einem System der Java-
Compiler aufgerufen wurde, der Bytecode kann auch auf jedem anderen Computersystem
ausgefuhrt werden, zumindest wenn es sich um "100% pure Java" handelt,
was bei manchen Microsoft-Produkten leider nicht garantiert ist.
Java-Einfuhrung von H. Partl { Kursunterlage 12

2.5 Java Runtime System (java)
Die Ausfuhrung des Bytecodes einer Java-Applikation erfolgt durch Aufruf der Java
Virtual Machine JVM (im Java Runtime Environment JRE) in der Form
java Xxxxx
oder
java Xxxxx parameter parameter
Der Bytecode der Klasse Xxxxx mu im File Xxxxx.class oder in einem Archiv-File
(zip, jar) liegen, der Klassenname mu aber ohne die Extension .class angegeben
werden.
Altere Versionen der JVM waren noch reine Bytecode-Interpreter und daher relativ
langsam. Neuere Versionen erzeugen mit Hilfe von Just-in-Time-Compilation
(JIT) und Hotspot-Technologie (Analyse des Laufzeitverhaltens) eine weitgehende
Optimierung und Beschleunigung der Ausfuhrungszeit.
2.6 Web-Browser und Appletviewer
Die Darstellung und Ausfuhrung eines Java-Applet erfolgt durch Aufrufen der entsprechenden
Web-Page (HTML-File) mit einem Java-fahigen Web-Browser wie z.B.
Netscape, Internet-Explorer oder HotJava.
Fur Tests und innerhalb von Java-Schulungen empehlt sich die Verwendung des
mit dem JDK mitgelieferten Appletviewer. Dies ist ein einfacher Browser, der alle
HTML-Tags auer und ignoriert und nur das im HTML-File
angefuhrte Applet ohne den Rest der Web-Page anzeigt. Der Aufruf erfolgt in der
Form
appletviewer xxxx.html
oder
appletviewer URL
Java-Einfuhrung von H. Partl { Kursunterlage 13

2.7 Online-Dokumentation (API)
Die Online-Dokumentation wird als API (application programmers interface) bezeichnet
und kann zusatzlich zum JDK am eigenen Rechner installiert oder auf
einem Web-Server gespeichert werden. Sie liegt in der Form von Web-Pages (HTML-
Files mit Hypertext-Links) vor und kann mit jedem beliebigen Web-Browser gelesen
werden, z.B. mit Netscape. Man kann den jeweiligen lokalen Filenamen direkt als
Aufrufparameter angeben, oder man kann sich zum File "durchklicken" und es dann
in die Bookmarks eintragen und spater von dort wiederum aufrufen.
Beispiele (die Details hangen von der Konguration und Installation ab):
Unix:
netscape /opt/java/docs/api/tree.html &
Windows:
netscape.exe C:njdk1.x.xndocsnapintree.html
Die wichtigsten Files innerhalb dieser Dokumentation sind:
Class Hierarchy fur die Suche nach einer bestimmten Klasse und deren
Konstruktoren, Datenfeldern und Methoden.
All Names (Index of Fields and Methods) fur die Suche nach Datenfeldern
und Methoden, wenn man nicht wei, in welcher Klasse sie deniert
sind.
In jedem dieser Files kann man mit dem "Find-in-current" Befehl des Web-Browsers
(je nach Browser im Edit-Menu oder dergleichen) nach Namen oder Substrings suchen.
Das All-Names-File ist sehr gro, es ist daher meistens schneller, die Suche
im Class-Hierarchy-File zu beginnen.
Wenn Sie einen Klassennamen anklicken, erhalten Sie die komplette Beschreibung
dieser Klasse und ihrer Konstruktoren, Datenfelder und Methoden sowie eine
Angabe ihrer Oberklassen. Falls Sie eine Methode in der Dokumentation einer Unterklasse
nicht nden, dann sehen Sie in ihren Oberklassen nach (siehe Vererbung).
Wenn Sie den Namen einer Methode (oder eines Konstruktors oder Datenfeldes)
anklicken, erhalten Sie sofort die Beschreibung dieser Methode (bzw. des Konstruktors
oder Datenfeldes). Dabei mussen Sie aber beachten, da es mehrere gleichnamige
Methoden und Konstruktoren sowohl innerhalb einer Klasse (siehe Overloading)
als auch in verschiedenen Klassen (siehe Overriding) geben kann.
Java-Einfuhrung von H. Partl { Kursunterlage 14

2.8 Java-Archive (jar)
2.9 Software-Tools
Ein Java-Archiv enthalt Dateien und eventuell auch ganze Directory-Strukturen
(siehe Packages) in demselben komprimierten Format, das auch von PKZIP und
Win-Zip verwendet wird. Sie werden mit dem Programm jar (java archiver) verwaltet,
der Aufruf erfolgt ahnlich wie beim Unix-Programm tar (tape archiver):
Archiv-File erstellen (create):
tar -cvf xxx.jar *.class
Inhalt eines Archiv-Files anzeigen (table of contents):
tar -tvf xxx.jar
einzelen Dateien aus einem Archiv-File herausholen (extract):
tar -xvf xxx.jar Yyyy.class
Der Herausholen bzw. "Auspacken" von Archiv-Files ist meistens gar nicht notig:
Der Java-Compiler und die Java Virtual Machine konnen die Class-Files direkt aus
dem Archiv-File lesen und laden. Zu diesem Zweck mu der Filename des Archiv-
Files im Classpath angegeben sein bzw. bei Applets im ARCHIVE-Paremeter des
Applet-Tag im HTML-File.
Von mehreren Firmen werden Editoren, GUI-Builder, Entwicklungsumgebungen
(Integrated Development Environments IDE) und andere Hilfsmittel angeboten, mit
denen man Java-Applikationen und Applets moglichst bequem und einfach erstellen
kann. Beispiele sind Kawa, NetBeans, Forte, JBuilder, JDeveloper, SuperCede,
Visual Age, Visual Cafe, Visual J++ und viele andere. Alle diese Hilfsmittel haben
Vor- und Nachteile. Manche von ihnen enthalten auch "native Compiler", die den
plattformunabhangigen Java-Bytecode in ein Binarprogramm in der lokalen Maschinensprache
ubersetzen.
Ubersichten uber die verfugbaren Software-Tools und deren Bezugsquellen nden
Sie auf den in den Referenzen angefuhrten Web-Servern, Erfahrungsberichte in den
einschlagigen Usenet-Newsgruppen.
Java-Einfuhrung von H. Partl { Kursunterlage 15

2.10 Java Beans
2.11 Vorgangsweise
Unter Java Beans ("Kaeebohnen") vesteht man kleine Java-Programme (Klassen)
mit genau festgelegten Konventionen fur die Schnittstellen, die eine Wiederverwendung
in mehreren Anwendungen (Applikationen und Applets) ermoglichen, ahnlich
wie bei Unterprogramm-Bibliotheken in anderen Programmiersprachen. Dies ist vor
allem in Hinblick auf das Software-Engineering von komplexen Programmsystemen
interessant. Dafur gibt es ein eigenes Beans Development Kit BDK, das man zusaetzlich
zum JDK installieren kann, und ein Package java.beans, das ab Version 1.1
im JDK enthalten ist,
Beans werden auch von vielen der oben erwahnten Software-Tools (IDE) unterstuetzt.
Auch die Klassenbibliothek des JDK ist seit Version 1.2 weitgehend nach
den Beans-Konventionen geschrieben, und manche Software-Firmen verkaufen spezielle
Java-Beans fur bestimmte Anwendungen.
Es ist empfehlenswert, auch beim Schreiben eigener Java-Programme moglichst die
Konventionen von Java-Beans einzuhalten, also z.B. da jede Klasse einen Default-
Konstruktor mit leerer Parameterliste haben soll, da die Methoden fur das Setzen
und Abfragen von Datenfeldern Namen der Form setXxxxx und getXxxxx bzw.
isXxxxx haben sollen, oder da alle Klassen so "selbstandig" programmiert werden
sollen, da sie unabhang davon funktionieren, wie andere Klassen programmiert
wurden.
Mehr uber diese Grundsatze und Empfehlungen nden Sie im Kapitel uber Objekte
und Klassen. Fur genauere Informationen uber Beans und BeanInfos wird auf die
Referenzen verwiesen.
Vorgangsweise bei Programmen (Applikationen)
notepad "Xxxxx.java"
javac Xxxxx.java
java Xxxxx
Vorgangsweise bei Applets
notepad "Xxxxx.java"
notepad "Xxxxx.html"
javac Xxxxx.java
appletviewer Xxxxx.html
Java-Einfuhrung von H. Partl { Kursunterlage 16

2.12 Beispiel: Einfache HelloWorld-Applikation
Es ist ublich, einen ersten Eindruck fur eine neue Programmiersprache zu geben,
indem man ein extrem einfaches Programm zeigt, das den freundlichen Text "Hello
World!" auf die Standard-Ausgabe schreibt.
So sieht dieses Minimal-Programm als Java-Applikation aus:
public class HelloWorld {
public static void main (String[] args) {
}
}
System.out.println("Hello World!");
Dieses Java-Source-Programm mu in einem File mit dem Namen HelloWorld.java
liegen. Die Ubersetzung und Ausfuhrung erfolgt dann mit
javac HelloWorld.java
java HelloWorld
Ein als Muster fur objekt-orientierte Java-Programme besser geeignetes Beispiel fur
eine HelloWorld-Applikation nden Sie im Kapitel uber Objekte und Klassen.
Ein analoges Beispiel fur ein minimales HelloWorld-Applet nden Sie im Kapitel
uber Applets.
2.13 Ubung: HelloWorld-Applikation
Schreiben Sie die oben angefuhrte HelloWorld-Applikation (oder eine Variante davon
mit einem anderen Text) in ein Java-Source-File und ubersetzen Sie es und fuhren
Sie es aus.
2.14 Ubung: Online-Dokumentation
Suchen Sie in der Online-Dokumentation (API) nach der Beschreibung der Methode
println und des Objekts System.out.
Java-Einfuhrung von H. Partl { Kursunterlage 17

2.15 Typische Anfanger-Fehler
Newbie: Ich habe das HelloWorld-Programm aus meinem Java-Buch abgeschrieben,
aber es funktioniert nicht. :-(
Oldie: Das ist schon richtig :-) so, das HelloWorld-Beispiel dient dazu, da Du die
typischen Anfanger-Fehler kennenlernst und in Zukunft vermeiden kannst. Der erste
Fehler war schon: Wenn Du uns nicht den genauen Wortlaut der Fehlermeldung, die
Version Deiner Java-Software (JDK, IDE) und die relevanten Teile Deines Source-
Programms dazusagst, konnen wir den Fehler nicht sehen und Dir nicht helfen. In
diesem Fall kann ich nur raten. Du hast wahrscheinlich einen der folgenden typischen
Newbie-Fehler gemacht:
Du hast das Programm nicht genau genug abgeschrieben (Tippfehler, Gro-
Kleinschreibung, Sonderzeichen, Leerstellen), lies doch die Fehlermeldungen
und Korrekturhinweise, die der Compiler Dir gibt.
Du hast das Programm nicht unter dem richtigen Filenamen abgespeichert.
Wenn die Klasse HelloWorld heit, mu das File HelloWorld.java heien, nicht
helloworld.java und auch nicht HelloWorld.java.txt, im letzteren Fall versuch
es mit
notepad "HelloWorld.java"
Du hast beim Compiler nicht den kompletten Filenamen mit der Extension
angegeben (wieder mit der richtigen Gro-Kleinschreibung):
javac HelloWorld.java
Du hast bei der Ausfuhrung nicht den Klassennamen ohne die Extension angegeben
(wieder mit der richtigen Gro-Kleinschreibung):
java HelloWorld
In der Umgebungsvariable PATH ist das Directory, in dem sich die JDK-
Software bendet, nicht neben den anderen Software-Directories enthalten,
versuch
set PATH=%PATH%;C:njdk1.2nbin
oder wie immer das auf Deinem Rechner heien mu.
Die Umgebungsvariable CLASSPATH ist (auf einen falschen Wert) gesetzt.
Diese Variable sollte uberhaupt nicht gesetzt sein, nur in seltenen Spezialfallen
und dann so, da sie sowohl die Stellen enthalt, wo die Java-
Klassenbibliotheken liegen, als auch den Punkt fur das jeweils aktuelle Directory.
Du hast den Compiler nicht in dem Directory bzw. Folder aufgerufen, in dem
Du das Java-File gespeichert hast.
Du hast ein Applet als Applikation aufgerufen, oder umgekehrt.
Applikatonen, die eine main-Methode enthalten, mut Du mit
java Classname
aufrufen.
Applets, die ein "extends Applet" oder "extends JApplet" enthalten, mut
Du innerhalb eines geeigneten HTML-Files mit
appletviewer xxxxx.html
oder mit Netscape oder Internet-Explorer aufrufen.
Java-Einfuhrung von H. Partl { Kursunterlage 18

3. Syntax und Statements
Wie sage ich dem Computer, was er tun soll?
Die Syntax und die Grundregeln der Sprache Java sind weitgehend identisch mit
denen von C und C++. Es fehlen jedoch Sprachelemente, die leicht zu Programmfehlern
fuhren konnen, wie Pointer-Arithmetik, Operator-Overloading und Goto.
3.1 Grundbegrie der Programmierung
Programm-Elemente
Fur diejenigen, die noch keine Erfahrung mit Programmiersprachen haben, hier eine
kurze Zusammenstellung der wichtigsten Elemente, die in Computer-Programmen
vorkommen, und der wichtigsten Konzepte fur die Programmierung. In den folgenden
Abschnitten lernen Sie dann, wie Sie diese Elemente in der Programmiersprache
Java formulieren konnen.
Variable = Datenfelder
Konstante = Datenwerte
Dateien (Files) = Ein- und Ausgabe von Daten
Anweisungen (Statements) = Aktionen
{ eine nach der anderen ;
{ Abzweigungen (if, switch)
{ Schleifen (for, while, do)
strukturierte Programmierung:
{ Blocke von Statements fg
{ Unterprogramme (Methoden)
{ Hauptprogramm (main)
Konzepte bei der Programmierung
strukturierte Programmierung: moglichst kleine Einheiten
objekt-orientierte Programmierung: Daten & Aktionen
top-down: zuerst das Grundgerust, dann die Details
bottom-up: zuerst die Einzelteile, dann zusammenbauen
model-view-controller (bei Graphical User Interfaces): zuerst die Daten,
dann die Darstellung der Daten, dann die Steuerung ( Anderung der Daten)
Java-Einfuhrung von H. Partl { Kursunterlage 19

3.2 Namenskonventionen
Es wird dringend empfohlen, die folgenden Konventionen bei der Wahl von Namen
strikt einzuhalten und ausfuhrliche, gut verstandliche Namen zu verwenden:
Namen von Klassen und Interfaces beginnen mit einem Grobuchstaben und
bestehen aus Gro- und Kleinbuchstaben und Ziern. Beispiel: HelloWorld, Button2.
Namen von Konstanten beginnen mit einem Grobuchstaben und bestehen nur aus
Grobuchstaben, Ziern und Underlines. Beispiel: MAX SPEED.
Alle anderen Namen (Datenfelder, Methoden, Objekte, Packages etc.) beginnen
mit einem Kleinbuchstaben und bestehen aus Gro- und Kleinbuchstaben und
Ziern. Beispiele: openFileButton, button2, addActionListener, setSize, getSize.
Vom System intern generierte Namen konnen auch Dollarzeichen enthalten.
Gro- und Kleinbuchstaben haben in jedem Fall verschiedene Bedeutung (casesensitive).
3.3 Reservierte Worter
3.4 Datentypen
Die folgenden Namen sind reserviert und durfen nicht neu deklariert werden:
abstract, boolean, break, byte, case, catch, char, class, continue, default, do, double,
else, extends, false, nal, nally, oat, for, generic, goto, if, implements, import,
instanceof, int, interface, long, native, new, null, package, private, protected, public,
return, short, static, super, switch, synchronized, this, throw, throws, transient, true,
try, void, volatile, while.
Die Datentypen und ihre Eigenschaften (Lange, Genauigkeit) hangen nicht vom
jeweiligen Computersystem ab sondern sind in Java einheitlich festgelegt. Es wird
zwischen primitiven Datentypen und Objekt-Typen (Klassen) unterschieden.
Primitive Datentypen:
ganze Zahlen: byte, short, int, long
Gleitkomma-Zahlen: float, double
Logischer Typ (true oder false): boolean
Zeichen (Unicode, Zahlenwert ohne Vorzeichen): char
Objekt-Typen:
Zeichenketten (Unicode): String
sowie alle als Klassen denierten Typen
Java-Einfuhrung von H. Partl { Kursunterlage 20

3.5 Konstante (Literals)
Normale ganze Zahlen haben den Typ int und werden dezimal interpretiert. Den
Typ long kann man durch Anhangen von L erzeugen. Oktale Zahlen beginnen mit
0 (Null), hexadezimale mit 0x (Null und x).
Normale Zahlen mit Dezimalpunkt (oder mit D fur den Exponent) haben den Typ
double. Den Typ oat kann man durch Anhangen von F oder durch die Angabe von
Efur den Exponent erzeugen.
Logische Konstanten sind die Worter true und false.
char-Konstanten werden zwischen einfachen Apostrohpen geschrieben, Beispiel: 'A'.
String-Konstanten werden zwischen Double-Quotes geschrieben, Beispiel: "Hubert
Partl". Double-Quotes innerhalb des Strings mussem mit einem Backslash maskiert
werden. Sonderzeichen konnen mit Backslash und u und dem Unicode-Wert angegeben
werden, also z.B. 'nu20ac' fur das Euro-Zeichen.
Beispiele:
byte b; b=123;
short i; i=-1234;
int i; i=-1234;
long i; i=-1234L;
float x; x=-123.45F; x=1.0E-23;
double x; x=-123.45; x=1.0D-23;
boolean b; b=true; b=false;
char c; c='A';
String s; s="Abc"; s=null;
3.6 Deklarationen und Anfangswerte
Deklaration eines Datenfeldes:
typ name;
Deklaration von mehreren Datenfeldern desselben Typs:
typ name1, name2, name3;
Zuweisung eines Wertes:
name = wert;
Zuweisung eines Wertes mit Typumwandlung (casting):
name = (typ) wert;
Deklaration mit Zuweisung eines Anfangswertes:
typ name = wert;
Achtung! Die Deklaration gilt immer nur fur den Bereich (Klasse, Methode, Block
innerhalb einer Methode), innerhalb dessen die Deklaration steht. Es kann verwirrend
sein, wenn man innerhalb eines Blockes denselben Namen, der bereits fur eine
globale Variable gewahlt wurde, fur eine gleichnamige lokale Variable verwendet.
Wenn man vor die Typangabe das Wort final setzt, handelt es sich um eine Konstante,
d.h. der Wert dieses Datenfeldes kann nicht nachtraglich verandert werden.
Java-Einfuhrung von H. Partl { Kursunterlage 21

3.7 Referenzen (reference) auf Objekte oder Strings
Deklaration einer Variablen, die eine Referenz auf Objekte einer bestimmten Klasse
enthalten kann:
ClassName name;
ClassName name = null;
Anlegen eines Objekts (einer Instanz) dieser Klasse und Zuweisung der Referenz
auf dieses Objekt an die deklarierte Variable:
name = new ClassName();
wobei ClassName() fur einen Konstruktor (constructor) der Klasse steht.
Deklaration, Anlegen und Zuweisen in einem:
ClassName name = new ClassName();
Deklaration und Anlegen von Strings:
String s;
String s = null;
s = "Hubert Partl";
String myName = "Hubert Partl";
3.8 Garbage Collector
Objekte werden mit den Operator new und dem Konstruktor explizit angelegt und
dabei der Speicherplatz fur das Objekt reserviert und mit den Anfangswerten belegt.
Sobald es keine Referenz mehr auf das Objekt gibt (z.B. durch Zuweisen von null
auf die einzige Referenz-Variable), wird der vom Objekt belegte Speicherplatz durch
den im Hintergrund laufenden Garbage-Collector automatisch zuruckgegeben und
fur neuerliche Verwendung frei gemacht.
Java-Einfuhrung von H. Partl { Kursunterlage 22

3.9 Felder (array)
Deklaration einer Variablen, die eine Referenz auf ein Feld enthalten kann:
typ[] name;
Anlegen eines Feldes von n Elementen dieses Typs und Zuweisung der Referenz
auf dieses Feld an die Referenz-Variable:
name = new typ [n];
Deklaration und Anlegen in einem:
typ[] name = new typ [n];
Beispiel:
double[] monatsUmsatz = new double[12];
...
Eine Array-Referenz kann nacheinander Felder verschiedener Lange (aber nur gleichen
Typs) enthalten. Beispiel:
double[] tagesUmsatz;
...
tagesUmsatz = new double[31];
...
tagesUmsatz = new double[28];
...
Zuweisen von Werten zu den Feldelementen:
for (int i=0; i

Feld von Objekten
Classname[] name = new Classname [n];
for (int i=0; i

3.10 Ausdrucke (expression) und Operatoren
Objekt-Operatoren: new .
Mathematische Operatoren: + - * / %
Mathematische Zuweisungen: ++ -- = *= /= %= += -=
Logische Operatoren: < > = == != instanceof && ||
Bit-Operatoren: > >>> & |
Bit-Zuweisungen: = >>>= &= |=
String-Operatoren:
+ equals
Achtung! Bei Referenzen auf Objekte oder Strings vergleichen die Operatoren ==
und != nur, ob die Referenz dieselbe ist, nicht, ob der Inhalt des Strings oder des
Objekts gleich ist. Dafur mu die equals-Methode des Objekts verwendet werden.
Beispiel:
String vorName;
...
if ( vorName.equals("Hubert") )
...
Typ-Umwandlungen (Casting)
In manchen Fallen kann der Compiler Typen automatisch umwandeln, z.B. bei der
Zuweisung von int auf long oder double:
int i = ...;
double d = i + 1;
In vielen Fallen mu man dem Compiler aber mitteilen, in welchen Datentyp ein
Wert umgewandelt werden soll. Dies wird als Casting bezeichnet, dazu wird der
neue Typ zwischen Klammern angegeben:
typ1 name1 = ...;
typ2 name2 = (typ2) name1;
Dies ist inbesondere dann wichtig, wenn man sicherstellen will, da eine Multiplikation
mit der vollen Genauigkeit von long oder double erfolgt statt mit der geringeren
Genauigkeit von int oder oat, oder da eine Division mit Bruchteilen (oat oder
double) statt nur ganzzahlig mit Abschneiden des Restes erfolgt. Beispiel:
int i = ... ;
double d = ( (double) i ) / 100.0 ;
Fur die Umwandlung von oat oder double auf int oder long gibt es die Methoden
Math.oor, Math.ceil, Math.round, je nachdem, ob man abrunden, aufrunden oder
kommerziell runden will.
Java-Einfuhrung von H. Partl { Kursunterlage 25

3.11 Text-Operationen (String)
Die Lange eines Strings erhalt man mit der Methode
length()
Beispiel:
String name="Hubert Partl";
int len=name.length();
Fur das Zusammenfugen von mehreren Strings zu einem langeren String gibt es den
Operator +. Beispiel:
String name = vorName + " " + zuName;
Fur die Abfrage auf Gleichheit gibt es die Methode equals (siehe oben). Beispiel:
if (vorName.equals("Hubert") ...
Auerdem enthalt die Klasse String zahlreiche weitere Methoden fur das Erzeugen
von Substrings oder von veranderten Strings (z.B. Zeichenersetzung, Umwandlung
auf Gro- oder Kleinbuchstaben), sowie fur die Abfrage von Zeichen und Substrings
innerhalb eines Strings und fur die alphabetische Reihenfolge von 2 Strings. Die
Details entnehmen Sie bitte der Online-Dokumentation der Klasse String.
Fur komplexere Anwendungen, bei denen ein Text-String in Einzelteile (z.B. Worter)
zerlegt werden soll, gibt es eine eigene Klasse StringTokenizer.
Fur die Umwandlung von Strings, die Ziern enthalten, in entsprechende Zahlenwerte
gibt es eigene statische Methoden wie z.B.
int Integer.parseInt(String)
long Long.parseLong(String)
float Float.valueOf(String).floatValue()
double Double.valueOf(String).doubleValue()
Ab JDK 1.2 wird das einheitlicher, dann gibt es auch
float Float.parseFloat(String)
double Double.parseDouble(String)
Wie Sie die dabei eventuell auftretenden Fehler abfangen mussen, ist im Kapitel
uber Exceptions beschrieben.
Fur die umgekehrte Umwandlung von Zahlen in Strings kann man die Methode
String s = String.valueOf(zahl);
oder auch den folgenden Trick verwenden:
String s = "" + zahl;
Java-Einfuhrung von H. Partl { Kursunterlage 26

3.12 Funktionen (Math)
Mathematische Funktionen konnen mit Hilfe der statischen Methoden in der Klasse
Math aufgerufen werden. Beispiel:
x = Math.sqrt(y);
Die Details nden Sie in der Online-Dokumentation (API). Mehr uber Methoden
und statische Methoden nden Sie im Kapitel uber Objekte und Klassen.
3.13 Statements und Blocke
Statements werden mit ; (Strichpunkt, Semicolon) beendet.
Blocke von Statements werden zwischen f und g (geschwungene Klammern, braces)
eingeschlossen und konnen leer sein oder ein oder mehrere Statements enthalten, die
jeweils mit ; beendet werden.
3.14 Kommentare
Alles, was zwischen /* und */ oder zwischen // und dem Zeilenende steht, wird
vom Java-Compiler ignoriert und gilt als Kommentar.
Beispiele:
... // Kommentar bis Zeilenende
... /* Kommentar */ ...
Mit /** in der ersten Zeile, * am Beginn aller weiteren Zeilen und */ am Ende
kann man Dokumentations-Kommentar schreiben, der dann mit Hilfsprogrammen
extrahiert und ausgedruckt werden kann (siehe javadoc).
3.15 if und else
if ( logischer Ausdruck ) {
Statements;
}
if ( logischer Ausdruck ) {
Statements;
}
else {
Statements;
}
3.16 for
for ( int name=Anfangswert ; logischer Ausdruck ; Wertaenderung ) {
Statements;
}
Java-Einfuhrung von H. Partl { Kursunterlage 27

3.17 while und do
while ( logischer Ausdruck ) {
Statements;
}
do {
Statements;
} while ( logischer Ausdruck );
3.18 switch und case
switch ( ganzzahliger Ausdruck ) {
case wert1:
Statements;
break;
case wert2:
Statements;
break;
...
default:
Statements;
}
Achtung! Falls die auf eine case-Angabe folgenden Statements nicht mit break; enden
oder dort uberhaupt keine Statements stehen, werden auch die bei der folgenden
case-Angabe stehenden Statements ausgefuhrt.
3.19 break und continue
Mit continue; kann man den aktuellen Schleifendurchgang vorzeitig beenden und
den nachsten Schleifendurchgang beginnen.
Mit break; kann man eine Schleife oder einen case-Block verlassen und zum Statement
nach Ende der Schleife bzw. des switch-Blockes springen.
Mit labelname: kann man einen Label vor ein for-, while- oder do-Statement setzen
und dann mit continue labelname; bzw. break labelname; diese (auere) Schleife
vorzeitig beenden.
Es gibt in Java kein goto-Statement zum Sprung an beliebige Stellen.
3.20 System.exit
Mit System.exit(0); oder System.exit(n); kann man die Applikation vorzeitig
beenden. Bei Erreichen des Endes der main-Methode wird das Programm automatisch
beendet.
Bei erfolgreicher Beendigung gibt man als Exit-Code 0 an, bei einer nicht erfolgreichen
Beendigung eine positive ganze Zahl als Fehler-Code, im einfachsten Fall
den Wert 1.
Java-Einfuhrung von H. Partl { Kursunterlage 28

3.21 Beispiele fur einfache Programme
Wertzuweisungen
public class ProgExpr {
public static void main (String[] args) {
int guthaben = 1000;
System.out.println("Guthaben = " + guthaben);
int einzahlung = 500;
System.out.println("Einzahlung = " + einzahlung);
guthaben = guthaben + einzahlung;
System.out.println("Guthaben = " + guthaben);
}
}
if
for
while
public class ProgIf {
public static void main (String[] args) {
int guthaben = 2000000;
System.out.println("Guthaben = " + guthaben);
if ( guthaben >= 1000000 ) {
System.out.println("Gratuliere, Du bist Millionaer!");
}
}
}
public class ProgFor {
public static void main (String[] args) {
int guthaben = 1000;
int einzahlung = 500;
System.out.println("Guthaben = " + guthaben);
System.out.println("Einzahlung = " + einzahlung
+ " pro Monat");
for ( int monat=1; monat

}
System.out.println ("Sparziel = " + sparziel);
while ( guthaben < sparziel ) {
guthaben = guthaben + einzahlung;
System.out.println ("neues Guthaben = " + guthaben);
}
System.out.println( "Sparziel erreicht.");
}
switch
public class ProgSwitch {
public static void main (String[] args) {
int note = 2;
switch (note) {
case 1:
System.out.println("sehr gut");
break;
case 2:
System.out.println("gut");
break;
case 3:
System.out.println("befriedigend");
break;
case 4:
System.out.println("genuegend");
break;
case 5:
System.out.println("nicht genuegend");
break;
}
}
}
switch (note) {
case 1:
System.out.print("mit Auszeichnung ");
case 2:
case 3:
case 4:
System.out.println("bestanden");
break;
case 5:
System.out.println("nicht bestanden");
break;
}
Blocke
public class ProgBlock {
Java-Einfuhrung von H. Partl { Kursunterlage 30

}
Ein- und Ausgabe
public static void main (String[] args) {
int note;
String beurteilung;
System.out.println ("Notentabelle:");
for ( note = 1; note

}
}
alter = Integer.parseInt ( zeile.trim() );
System.out.println ("Du bist " + alter + " Jahre alt.");
} catch (Exception e) {
System.out.println("falsche Eingabe - " + e);
}
3.22 Fehlersuche und Fehlerbehebung (Debugging)
Computer sind unglaublich dumme Gerate,
die unglaublich intelligente Sachen konnen.
Programmierer sind unglaublich intelligente Leute,
die unglaublich dumme Sachen produzieren.
("Die Presse", 30.8.1999)
Programmfehler (auf englisch bugs = Wanzen, Ungeziefer genannt) gehoren zum
taglichen Brot jedes Programmierers. Nur wer nichts arbeitet, macht keine Fehler.
Der gute Programmierer ist nicht der, der keine Fehler macht, sondern der, der seine
Fehler rasch ndet und behebt.
Es gibt eigene Software-Tools, die bei der Fehlersuche helfen konnen. In den meisten
Fallen genugt es aber, an allen wichtigen Stellen im Programm mit System.out.println
oder System.err.println Informationen uber das Erreichen dieser
Programmstelle und uber den Inhalt von wichtigen Variablen auszugeben. Damit
kann man dann meistens sehr rasch nden, wo, wann und warum ein Programmfehler
aufgetreten ist und was man tun mu, im ihn zu vermeiden. Beispielskizze:
...
System.out.println("* Beginn der Schleife");
System.out.println("n = " + n);
for (int i=0; i

mit TEST = false komplett weggelassen werden und weder Speicherplatz noch Abfragezeit
kosten. Beispielskizze:
public class Classname {
private static final boolean TEST = false;
...
public ... methodName () {
...
if (TEST) {
System.err.println( ... test information ... );
}
...
}
}
Wenn man ein Paket von mehreren Klassen testen will, kann es gunstiger sein, alle
Denitionen in einer eigenen Klasse (Dened) festzulegen und dann in allen Klassen
in der Form Dened.TEST zu verwenden. Beispielskizze:
public class Defined {
public static final boolean TEST = false;
public static final boolean XXXX = true;
...
}
public class Classname {
...
if (Defined.TEST) {
...
}
...
}
Auerdem ist es fur das Verstehen und die (eventuell erst Jahre spater erfolgende)
Wartung der Programme wichtig, mit Kommentaren innerhalb der Programme
moglichst ausfuhrliche Hinweise auf den Zweck und die Funktionsweise des Programmes
und der einzelnen Programmabschnitte sowie Erklarungen zu allen programmtechnischen
Tricks anzugeben.
Java-Einfuhrung von H. Partl { Kursunterlage 33

3.23 Dokumentation von Programmen (javadoc)
Mit dem Hilfsprogramm javadoc, das Teil des JDK ist, kann eine Dokumentation
der Java-Programme im HTML-Format erzeugt werden, so wie die Online-
Dokumentation (API) der Klassenbibliothek.
Der Aufruf von
javadoc Xxxx.java
fur einzelne Source-Programme oder
javadoc *.java
fur alle Java-Programme im aktuellen Directory erzeugt fur jedes Source-Programm
ein Dokumentations-File Xxxx.html sowie einen Package-Index packages.html, einen
Klassen-Index tree.html und einen Namens-Index AllNames.html. Vorsicht, bereits
existierende gleichnamige Dateien werden dabei uberschrieben.
Javadoc extrahiert automatisch alle public und protected Deklarationen von Klassen,
Datenfeldern, Konstruktoren und Methoden. Zusatzliche Informationen kann
man in Form von speziellen Kommentaren hinzufugen, die jeweils in
/** ... */
eingeschlossen werden, vor der jeweiligen Deklaration stehen und einfachen HTML-
Text enthalten.
Beispiel:
/**
* ein einfaches Hello-World-Programm.
*
* Im Gegensatz zum kurzen, rein statischen "HelloWorld"
* ist dieses Programm ein Musterbeispiel
* f&uuml;r eine objekt-orientierte Java-Applikation.
*
* @author Hubert Partl
* @version 99.9
* @since JDK 1.0
* @see HelloWorld
*/
public class HelloDoc {
/** der Text, der gedruckt werden soll.
*/
public String messageText = "Hello World!";
/** druckt den Text messageText auf System.out aus.
* @see #messageText
*/
public void printText() {
System.out.println (messageText);
}
/** Test des HelloDoc-Objekts.
*/
public static void main (String[] args) {
Java-Einfuhrung von H. Partl { Kursunterlage 34

}
}
HelloDoc h = new HelloDoc();
h.printText();
Die von javadoc erstellte Dokumentation nden Sie im File HelloDoc.html.
3.24 Ubung: einfaches Rechenbeispiel Quadratzahlen
Schreiben Sie eine einfache Applikation, in der Sie die Quadratzahlen von ein paar
ganzen Zahlen berechnen und ausgeben:
1*1=1
2*2=4
3*3=9
usw. bis
20 * 20 = 400
3.25 Ubung: einfaches Rechenbeispiel Sparbuch
Schreiben Sie eine Applikation, die fur einen bestimmten Geldbetrag und einen
bestimmten Zinssatz ausgibt, wie sich dieser Wert Jahr fur Jahr erhoht (fur 10
Jahre, jeweils Jahr und Wert).
Anmerkung: Der Wert erhoht sich jedes Jahr um den Faktor
(100.0 + zinssatz) / 100.0
Erweiterte Versionen dieses Beispiels als Applikation mit Fehlerbehandlung und als
Applet mit graphischem User-Interface folgen in den Kapiteln uber Fehlerbehandlungen
und Applets.
Java-Einfuhrung von H. Partl { Kursunterlage 35

4. Objekte und Klassen
4.1 Objekt-Orientierung
Objekt = ( Daten & Aktionen )
Bei der konventionellen Programmierung erfolgt die Denition der Datenstrukturen
und der mit den Daten ausgefuhrten Prozeduren (Aktionen) unabhangig voneinander.
Das Wissen um die Bedeutung der Daten und die zwischen ihnen bestehenden
Beziehungen ist nicht einfach bei den Daten sondern mehrfach in allen Programmen,
die auf diese Daten zugreifen, gespeichert.
Bei der objekt-orientierten Programmierung (OOP) werden Objekte ganzheitlich
beschrieben, d.h. die Festlegung der Datenstrukturen und der mit den Daten ausgefuhrten
Aktionen erfolgt in einem.
Die wichtigsten Vorteile der objekt-orientierten Programmierung sind:
Aufspaltung von komplexen Software-Systemen in kleine, einfache, in sich geschlossene
Einzelteile,
einfache und klar verstandliche Schnittstellen zwischen den einzelnen Komponenten,
weitgehende Vermeidung von Programmierfehlern beim Zusammenspiel zwischen
den Komponenten,
geringer Programmieraufwand durch die Wiederverwendung von Elementen
(Vererbung).
Je kleiner und einfacher die Objekte und Klassen und die Schnittstellen zwischen
ihnen gewahlt werden (Kapselung, Vererbung), desto besser werden diese Ziele erreicht.
Mehr daruber folgt spater im Kapitel uber Objekt-orientierte Analyse und
Design.
prozeduraler Programmaufbau (Beispiel COBOL)
DATA DIVISION.
01 DDD1.
... Datenblock 1 ...
01 DDD2.
... Datenblock 2 ...
...
PROCEDURE DIVISON.
AAA1 SECTION.
... Aktionen Teil 1 ...
AAA2 SECTION.
... Aktionen Teil 2 ...
...
Java-Einfuhrung von H. Partl { Kursunterlage 36

prozeduraler Programmaufbau (Beispiel C)
struct ddd1 {
... Datenblock 1 ...
}
struct ddd2 {
... Datenblock 2 ...
}
...
aaa1() {
... Aktionen Teil 1 ...
}
aaa2() {
... Aktionen Teil 2 ...
}
...
objekt-orientierter Programmaufbau (Beispiel Java)
public class Ccc1 {
... Daten von Objekt-Typ 1 ...
... Aktionen von Objekt-Typ 1 ...
}
public class Ccc2 {
... Daten von Objekt-Typ 2 ...
... Aktionen von Objekt-Typ 2 ...
}
...
4.2 Klassen (class)
Als Klasse (class) bezeichnet man die Denition einer Idee, eines Konzepts, einer
Art von Objekten.
Als Objekt (object) bzw. Instanz (instance) bezeichnet man eine konkrete
Auspragung eines Objekts, also ein Stuck aus der Menge der Objekte dieser Klasse.
Beispiele: Hubert Partl und Monika Kleiber sind Objekte der Klasse Mitarbeiter.
Die Universitat fur Bodenkultur ist ein Objekt der Klasse Universitat.
Je einfacher die Klassen gewahlt werden, desto besser. Komplexe Objekte konnen
aus einfacheren Objekten zusammengesetzt werden (z.B. ein Bucherregal enthalt
Bucher, ein Buch enthalt Seiten, ein Atlas enthalt Landkarten). Spezielle komplizierte
Eigenschaften konnen auf grundlegende einfache Eigenschaften zuruckgefuhrt
werden (Vererbung, z.B. ein Atlas ist eine spezielle Art von Buch).
Denition von Klassen - Aufbau von Java-Programmen
Java-Programme sind grundsatzlich Denitionen von Klassen. Sie haben typisch
den folgenden Aufbau:
Java-Einfuhrung von H. Partl { Kursunterlage 37

public class ClassName {
// Definition von Datenfeldern
// Definition von Konstruktoren
// Definition von Methoden
}
Die Reihenfolge der Denitionen innerhalb der Klasse ist grundsatzlich egal, aber
ich empfehle, immer eine Konvention wie z.B. die hier angefuhrte Reihenfolge einzuhalten.
Verwendung von Klassen - Anlegen von Objekten
Objekte werden in Java-Programmen mit dem Operator new und einem Konstruktor
der Klasse angelegt. Beispiel:
House myNewHome = new House();
Innerhalb der Klasse kann man das aktuelle Objekt dieser Klasse mit dem symbolischen
Namen this ansprechen.
4.3 Beispiel: objekt-orientierte HelloWorld-Applikation
public class HelloText {
public String messageText = "Hello World!";
// or: private ...
public void printText() {
System.out.println (messageText);
}
}
public static void main (String[] args) {
HelloText h = new HelloText();
h.printText();
}
Im Gegensatz zum statischen Hello-World-Programm lat sich das objekt-orientierte
Programm leicht erweitern. Beispiel:
public class MultiText {
public static void main (String[] args) {
HelloText engl = new HelloText();
HelloText germ = new HelloText();
germ.messageText = "Hallo, liebe Leute!";
HelloText cat = new HelloText();
cat.messageText = "Meow!";
engl.printText();
germ.printText();
engl.printText();
Java-Einfuhrung von H. Partl { Kursunterlage 38

}
}
cat.printText();
engl.printText();
4.4 Datenfelder (member eld)
Datenfelder der Klasse werden typisch in der folgenden Form deklariert:
public typ name;
public typ name = anfangswert;
Nachdem ein Objekt dieser Klasse angelegt wurde, konnen seine Datenfelder in der
Form
object.name
angesprochen werden. Wenn private statt public angegeben wurde, konnen sie
jedoch von auen nicht direkt angesprochen werden (siehe Kapselung).
Datenfelder der Klasse sind eine Art von "globalen Variablen" fur alle Methoden
der Klasse und fur eventuelle innere Klassen.
Innerhalb der Klasse kann man die Datenfelder einfach mit
name
ansprechen, oder in der Form
this.name
wenn eine Unterscheidung von gleichnamigen lokalen Variablen oder Parametern
notwendig ist.
Java-Einfuhrung von H. Partl { Kursunterlage 39

4.5 Methoden (method)
Methoden entsprechen den Funktionen oder Prozeduren in konventionellen Programmiersprachen.
Die Deklaration erfolgt in der folgenden Form:
Methode mit Ruckgabewert:
public typ name () {
Statements;
return wert;
}
Methode ohne Ruckgabewert:
public void name () {
Statements;
}
Methode mit Parametern:
public typ name (typ name, typ name, typ name) {
Statements;
return wert;
}
Mit return; bzw. return wert; innerhalb der Statements kann man die Methode
vorzeitig verlassen (beenden).
Nachdem ein Objekt der Klasse angelegt wurde, konnen seine Methoden in einer
der folgenden Formen ausgefuhrt werden:
x = object.name();
object.name();
x = object.name (a, b, c);
object.name (a, b, c);
Man spricht in diesem Fall vom Aufruf der Methode fur das Objekt oder vom Senden
einer Message an das Objekt. Wenn private statt public angegeben wurde, kann
die Methode von auen nicht direkt angesprochen werden (siehe Kapselung).
Innerhalb der Klasse kann man die Methoden mit
name (parmeterliste)
oder
this.name (parmeterliste)
aufrufen.
Lokale Variable, die nur innerhalb einer Methode deklariert sind, konnen von auen
nicht angesprochen werden. Bei der Deklaration von lokalen Variablen darf daher
(im Gegensatz zu Datenfeldern der Klasse) weder public noch private angegeben
werden.
Die Parameter werden grundsatzlich als Wert ("by value"), nicht als Name ("by
reference") ubergeben. Primitive Datentypen, die innerhalb der aufgerufenen Methode
verandert werden, behalten also in der aufrufenden Methode ihren alten Wert.
Java-Einfuhrung von H. Partl { Kursunterlage 40

Bei Objekten und Strings wird aber nur die Referenz als Wert ubergeben, nicht
das Objekt selbst. Wenn das Objekt innerhalb der aufgerufenen Methode mit Hilfe
dieser Referenz verandert wird, dann wirkt diese Anderung direkt auf das Objekt,
also praktisch wie bei einer Ubergabe als Name.
4.6 Uberladen (overload)
Man kann auch mehrere Methoden denieren, die denselben Namen, aber verschiedene
Parameterlisten haben. Dies wird als Uberladen (overloading) von Methoden
auf Grund ihrer verschiedenen "Signatures" bezeichnet.
Man sollte das aber nur dann tun, wenn diese Methoden ahnliche Aktionen
ausfuhren, die sich nur durch den Typ oder die Anzahl der Parameter unterscheiden.
So sind z.B. verschiedene Varianten der Methode println deniert, die je nach dem
Typ des Parameters dessen Wert in einen lesbaren String umwandeln und dann
diesen ausdrucken.
4.7 statische Methoden (static)
Wenn man vor dem Typ einer Methode das Wort static angibt, dann kann diese
Methode aufgerufen werden, ohne da vorher ein Objekt der Klasse erzeugt werden
mu. Der Aufruf erfolgt dann in der Form
ClassName.name();
Statische Methoden konnen freilich nicht auf (nicht-statische) Datenfelder oder
nicht-statische Methoden der Klasse oder auf "this" zugreifen. Innerhalb von statischen
Methoden konnen aber Objekte mit new angelegt und dann deren Datenfelder
und Methoden angesprochen werden.
Die beiden wichtigsten Anwendungsfalle fur statische Methoden sind
die main-Methode, mit der die Ausfuhrung einer Java-Applikation beginnt,
und
mathematische Funktionen, die nicht mit Objekten sondern mit primitiven
Datentypen arbeiten.
Beispielskizze fur die Denition und Verwendung einer mathematischen Funktion:
public class Classname {
public static int diff (int a, int b) {
int c;
c = a - b;
return c;
}
...
}
Der Aufruf erfolgt dann in der Form
z = Classname.diff (x, y);
Beispiele fur statische Variable und statische Methoden sind System.out, System.exit(0),
Label.CENTER, Math.sin(x) usw.
Java-Einfuhrung von H. Partl { Kursunterlage 41

4.8 main-Methode
Jede Java-Applikation mu eine statische Methode mit der folgenden Signature enthalten:
public static void main (String[] args)
Diese main-Methode wird beim Starten der Applikation mit dem Befehl java aufgerufen
und kann ein oder mehrere Objekte der Klasse oder auch von anderen Klassen
anlegen und verwenden. Der Parameter args enthalt die beim Aufruf eventuell angegebenen
Parameter, mit args.length erhalt man deren Anzahl.
4.9 Konstruktoren (constructor)
Konstruktoren dienen zum Anlegen von Objekten der Klasse mit den new-Operator.
Sie legen den fur das Objekt benotigten Speicherplatz an und initialisieren das
Objekt, d.h. sie setzen es in einen gultigen Anfangszustand.
Laut Tov Are Jacobsen erfullt der Konstruktor die Funktion eines Baumeisters, der
ein Objekt mit den im Plan festgelegten Eigenschaften errichtet:
When you write a class you describe the behaviour of potential objects.
Much like designing a house on paper: you can't live in it unless you
construct it rst.
And to do that you say "I wantanew house, so I'll call the constructor":
House myNewHome;
myNewHome = new House();
(Tov Are Jacobsen, comp.lang.java.help, 1998)
Im einfachsten Fall enthalt die Denition der Klasse keine explizite Denition von
Konstruktoren. Dann wird vom Java-Compiler ein Default-Konstruktor mit leerer
Parameterliste erzeugt, der in der Form
ClassName object = new ClassName();
aufgerufen werden kann und nur den Speicherplatz anlegt und alle Datenfelder auf
ihre Anfangswerte setzt.
Wenn man will, da im Konstruktor weitere Aktionen erfolgen sollen (z.B. durch
Aufruf von Methoden), so mu man den Konstruktor selbst denieren. Dies erfolgt
in der Form
public ClassName() {
Statements;
}
Man kann auch einen oder mehrere Konstruktoren mit verschiedenen Parameterlisten
denieren (Overloading). In diesem Fall wird vom Compiler kein Default-
Konstruktor automatisch erzeugt: Entweder man deniert gar keinen Konstruktor
oder man deniert alle explizit. Beispiel:
Java-Einfuhrung von H. Partl { Kursunterlage 42

public class BookShelf {
public Book[] book;
public BookShelf (int maxBooks) {
book = new Book[maxBooks];
for (int i=0; i

4.10 Kapselung (Encapsulation, Data Hiding, Java Beans)
Statt der Angabe von public in den obigen Beispielen sind bei Klassen, Datenfeldern
und Methoden jeweils vier verschiedene Angaben moglich:
public
das Element kann uberall angesprochen werden (oentlich).
protected
das Element kann nur in Klassen innerhalb desselben Package oder in Subklassen
(siehe Vererbung) angesprochen werden, aber nicht von fremden Klassen
(geschutzt).
(keine Angabe)
das Element kann nur in Klassen innerhalb desselben Package angesprochen
werden, aber nicht von fremden Klassen (default).
private
das Element kann nur innerhalb dieser Klasse angesprochen werden (privat).
public protected default private
selbe Klasse ja ja ja ja
selbes Package ja ja ja nein
Unterklasse (extends) ja ja nein nein
uberall ja nein nein nein
Es wird dringend empfohlen, bei jeder Klasse genau zu uberlegen, welche Datenfelder
und Methoden "von auen" direkt angesprochen werden mussen und welche nur
innerhalb der Klasse oder des Package benotigt werden. Alles, was nicht fur die
Verwendung von auen sondern nur fur die Programmierung im Inneren notwendig
ist, sollte im Inneren "verborgen" werden. Dies wird als Encapsulation oder Data
Hiding bezeichnet und hat vor allem die folgenden Vorteile:
einfache und klare Schnittstelle fur die Verwendung dieser Klasse bzw. ihrer
Objekte,
Sicherung, da die Datenfelder stets gultige Werte haben,
weitgehende Unabhangigkeit der internen Programmierung dieser Klasse von
der Programmierung anderer Klassen,
weitgehende Vermeidung von Programmierfehlern beim Zusammenspiel zwischen
den verschiedenen Klassen und Programmen.
Um ungultige Datenwerte in den Datenfeldern zu vermeiden, ist es empfehlenswert,
alle Datenfelder als private oder protected zu denieren und eigene public Methoden
fur das Setzen und Abfragen der Werte vorzusehen, die schon bei der Speicherung
der Daten alle Fehler verhindern.
Per Konvention ("Java-Beans") sollen diese Methoden Namen der Form setXxxx
und getXxxx haben und nach folgendem Schema deniert werden:
public class ClassName {
private typ xxxx = anfangswert;
Java-Einfuhrung von H. Partl { Kursunterlage 44

}
public void setXxxx (typ xxxx) {
// Gueltigkeit des Wertes kontrollieren
this.xxxx = xxxx;
}
public typ getXxxx() {
return xxxx;
}
Bei boolean Datenfeldern soll die Methode isXxxxx statt getXxxxx genannt werden.
Bei Arrays (Feldern) sollen solche Methoden sowohl fur das ganze Feld als auch (mit
einem int-Parameter fur den Index) fur die einzelnen Feldelemente vorhanden sein.
Mehr uber die Programmierung der Fehlerbehandlung nden Sie im Kapitel uber
Exceptions.
4.11 Beispiel: schlechte Datums-Klasse
Eine sehr ungunstige Moglichkeit, eine Klasse fur Datum-Objekte zu denieren,
bestunde darin, einfach nur die 3 int-Felder als public zu denieren und dann alles
Weitere den Anwendungsprogrammierern zu uberlassen:
public class Date1 { // very bad, don't do this!
public int year;
public int month;
public int day;
In der main-Methode konnen dann Objekte dieser Klasse angelegt und verwendet
werden. Dabei kann es passieren, da ungultige Werte erzeugt werden (frei nach
Erich Kastner):
public static void main (String[] args) {
Date1 today = new Date1();
today.day = 35;
today.month = 5;
today.year = 1997;
Auerdem konnen verschiedene Programmierer verschiedene Ansichten daruber haben,
in welcher Reihenfolge Tag und Monat angezeigt werden sollen, und damit die
Benutzer verwirren:
System.out.println ("Today is " +
today.day + ". " +
today.month + ". " +
today.year);
System.out.println ("Today is " +
today.month + ". " +
today.day + ". " +
today.year);
Java-Einfuhrung von H. Partl { Kursunterlage 45

Auch bei der Berechnung von Zeitraumen konnen manche Details ubersehen werden,
z.B. da 1996 ein Schaltjahr war, 2021 aber keines ist:
Date1 marriage = new Date1();
marriage.day = 29;
marriage.month = 2;
marriage.year = 1996;
System.out.println ("Married on " +
marriage.day + ". " +
marriage.month + ". " +
marriage.year);
Date1 silverMarriage = new Date1();
silverMarriage.day = marriage.day;
silverMarriage.month = marriage.month;
silverMarriage.year = marriage.year + 25;
System.out.println ("Silver marriage on " +
silverMarriage.day + ". " +
silverMarriage.month + ". " +
silverMarriage.year);
Schlielich gestaltet sich auch die Programmierung von Vergleichen recht aufwendig:
if ( silverMarriage.day == today.day &&
silverMarriage.month == today.month &&
silverMarriage.year == today.year )
System.out.println ("Congratulations!");
}
}
4.12 Beispiel: bessere Datums-Klasse
Besser im Sinne der Kapselung ware es, die 3 Datenfelder als private zu denieren,
damit sie nicht auf falsche Werte gesetzt werden konnen, und public Methoden und
Konstruktoren vorzusehen, mit denen diese Werte gesetzt, verandert und verwendet
werden:
public class Date2 { // better, but incomplete
private int year;
private int month;
private int day;
Hier drei Konstruktoren (overloading), mit denen das Datum auf einen gultigen
Anfangswert gesetzt wird. Diese Konstruktoren verwenden die unten erlauterte Methode
setDate2, die die Gultigkeit der Werte sicherstellt.
public Date2() {
setDate2();
}
}
public Date2 (int year, int month, int day) {
setDate2 (year, month, day);
Java-Einfuhrung von H. Partl { Kursunterlage 46

}
public Date2 (Date2 other) {
setDate2 (other);
Hier nun die drei Varianten (overloading) der public Methode setDate2:
Die Variante mit leerer Parameterliste setzt das Datum auf das heutige Datum
(durch Aufruf einer geeigneten Systemfunktion, hier nur skizziert, aber nicht gezeigt):
public void setDate2() {
// set to today's date via system function
}
Die zweite Variante erlaubt die Angabe des Datums mit 3 Parametern fur Jahr,
Monat und Tag und uberpruft, ob diese Zahlen tatsachlich ein gultiges Datum darstellen
(mit Berucksichtigung von eventuellen Schaltjahren, hier nicht gezeigt). Was
hier auch noch fehlt, ist die Reaktion auf solche Fehler (siehe das Kapitel uber
Exceptions).
public void setDate2 (int year, int month, int day) {
// check for valid ranges of day and month for this year
this.day = day;
this.month = month;
this.year = year;
}
Die dritte Variante setzt das Datum auf das gleiche wie ein bereits erstelltes Objekt
desselben Typs. Hier ist keine neuerliche Fehlerbehandlung notwendig, da dieses
Objekt ohnedies nur ein gultiges Datum enthalten kann.
public void setDate2 (Date2 other) {
this.day = other.day;
this.month = other.month;
this.year = other.year;
}
Fur den Zugri auf die privaten Datenfelder werden eigene public get-Methoden
geschrieben:
public int getDay() {
return day;
}
public int getMonth() {
return month;
}
public int getYear() {
return year;
}
Anmerkung: Bei der in Java 1.0 eingebauten Date-Klasse gibt es zwei getrennte Methoden
getDate und getDay fur den Tag innerhalb des Monats und den Wochentag.
Java-Einfuhrung von H. Partl { Kursunterlage 47

Auerdem kann man auch weitere Methoden vorsehen, z.B. um den Monat als Wort
statt als Nummer zu erhalten. Hier die englische Variante, bei der deutschsprachigen
mute man auch noch den Unterschied zwischen "Januar" in Deutschland und
"Janner" in Osterreich berucksichtigen:
public String getMonthName() {
String s = null;
switch (month) {
case 1: s = "January"; break;
case 2: s = "February"; break;
case 3: s = "March"; break;
case 4: s = "April"; break;
case 5: s = "May"; break;
case 6: s = "June"; break;
case 7: s = "July"; break;
case 8: s = "August"; break;
case 9: s = "September"; break;
case 10: s = "October"; break;
case 11: s = "November"; break;
case 12: s = "December"; break;
}
return s;
}
Hier noch 3 Methoden zur Berechnung von Zeitintervallen in die Zukunft oder (bei
negativem Argument) in die Vergangenheit, wobei die komplizierten Details von
Monats- und Jahresgrenzen und Schaltjahren hier nicht gezeigt werden. Gerade weil
diese Berechnung kompliziert ist, ist es wichtig, sie innerhalb der Klasse zu programmieren
und es nicht jedem einzelnen Anwender zu uberlassen, sich das jedesmal neu
zu uberlegen.
public void addDays (int days) {
// compute new date with correct day, month, and year
}
public void addMonths (int months) {
// compute new date with correct day, month, and year
}
public void addYears (int years) {
this.year += years;
// correct day and month, if leap year problem
}
Alle Klassen mussen die beiden Methoden equals (fur die Abfrage auf Gleichheit
von 2 Objekten dieses Typs) und toString (fur die menschenlesbare Darstellung des
Objekts als Textstring) enthalten:
public boolean equals (Object other) {
if (other instanceof Date2 &&
( (Date2) other).day == this.day &&
( (Date2) other).month == this.month &&
Java-Einfuhrung von H. Partl { Kursunterlage 48

}
( (Date2) other).year == this.year)
return true;
else
return false;
public String toString() {
String s = day + " " +
getMonthName() + " " +
year;
return s;
}
Anmerkung: Die Angabe von this. ist hier nicht notwendig, macht aber die Bedeutung
in diesem Beispiel klarer verstandlich.
Die Verwendung dieser Klasse ist nun sehr viel einfacher, und gleichzeitig sind alle
Fehlermoglichkeiten und Miverstandnisse ausgeschlossen:
public static void main (String[] args) {
Date2 today = new Date2();
System.out.println ("Today is " + today );
Anmerkung: Die Angabe von today.toString() ist innerhalb der println-Methode
bzw. der String-Concatenation nicht notig, die wird bei der Typ-Umwandlung automatisch
aufgerufen.
Date2 yesterday = new Date2 (today);
yesterday.addDays(-1);
System.out.println ("Yesterday was " + yesterday );
Date2 marriage = new Date2 (1996, 2, 29);
System.out.println ("Married on " + marriage );
Date2 silverMarriage = new Date2 (marriage);
silverMarriage.addYears(25);
System.out.println ("Silver marriage on " +
silverMarriage );
if ( silverMarriage.equals(today) )
System.out.println ("Congratulations!");
}
}
In Wirklichkeit ist es naturlich nicht notwendig, eine eigene Klasse fur Datumsangaben
zu schreiben, die ist bereits im API vorhanden und ist noch um einige
Stufen komplexer als das hier gezeigte Beispiel: Die Klasse Date enthalt nicht nur
das Datum sondern auch die Uhrzeit, und man kann in Verbindung mit entsprechenden
weiteren Klassen auch die verschiedenen Kalender, Zeitzonen, Datumsformate
und Sprachen berucksichtigen (siehe das Kapitel uber Datum und Uhrzeit).
Java-Einfuhrung von H. Partl { Kursunterlage 49

4.13 Ubung: einfache Kurs-Klasse
Schreiben Sie eine einfache Klasse "Kurs" mit den folgenden Datenfeldern:
Kurs-Titel (String)
kostenlos (boolean)
Namen der Teilnehmer (Array von Strings)
Anzahl der angemeldeten Teilnehmer
und mit allen benotigten set- und get-Methoden, nach den Konventionen fur Beans,
sowie einer Methode addTeilnehmer zum Anmelden eines Teilnehmers.
Fugen Sie eine main-Methode an, in der Sie diese Methoden kurz testen, indem Sie
zwei oder drei Kurs-Objekte anlegen, ein paar Teilnehmer anmelden und dann die
gespeicherten Informationen auf den Bildschirm ausgeben.
4.14 Objekt-orientierte Analyse und Design
Die objekt-orientierte Programmierung besteht aus folgenden Schritten:
Objekt-orientierte Analyse (OOA)
Objekt-orientiertes Design (OOD)
Objekt-orientierte Programmierung (OOP)
Die Analyse erfolgt zunachst unabhangig von der verwendeten Programmiersprache
und soll die logisch richtige Sicht des Problems und damit die Grundlage fur das
Design liefern.
Das Design, also das Konzept fur die Programmierung, berucksichtigt dann die
Eigenschaften der Programmiersprache (z.B. Einfach- oder Mehrfachvererbung)
und die verfugbaren Klassenbibliotheken (z.B. Schnittstellen zu Graphischen User-
Interfaces oder zu Datenbanken).
Um komplexe Systeme fur die objekt-orientierte Programmierung in den Gri zu
bekommen, mussen sie also analysiert werden, aus welchen Objekten sie bestehen
und welche Beziehungen zwischen den Objekten bestehen, welche Eigenschaften die
Objekte haben und welche Aktionen mit ihnen ablaufen.
Die wichtigsten Design-Regeln fur das Zerlegen von komplexen Systemen in einzelne
Objekte sind:
Die Objekte sollen moglichst einfach sein, d.h. ein kompliziertes Objekt soll
in mehrere einfache Objekte zerlegt werden.
Die Objekte sollen moglichst abgeschlossen sein, d.h. jedes Objekte soll
moglichst wenig uber die anderen Objekte wissen mussen.
Die Analyse und das Design ergeben sich am einfachsten, indem man versucht, das
System bzw. die Aufgabenstellung mit einfachen deutschen Satzen zu beschreiben:
Hauptworter (Nomen) bedeuten Objekte oder primitive Datenfelder.
Java-Einfuhrung von H. Partl { Kursunterlage 50

Eigenschaftsworter (Adjektiv) bedeuten Datenfelder oder get-Methoden.
Zeitworter (Verb) bedeuten Methoden.
Satze der Form "A hat ein B" bedeuten Datenfelder (Eigenschaften).
Satze der Form "A ist ein B" bedeuten Oberklassen (Vererbung).
4.15 Beispiel: Analyse Schulungen
Aufgabenstellung: Analyse und Design des Systems "Schulungsunternehmen, Schulungen,
Teilnehmer und Trainer".
Losungs-Skizze:
1. Objekte und Aktionen:
Ein Schulungsunternehmen bietet Schulungen an.
Eine Schulung ndet an Schulungsterminen statt.
Ein Schulungsunternehmen veroentlicht eine Liste der Schulungstermine.
Ein Teilnehmer meldet sich zu einem Schulungstermin an und bezahlt die
Schulungsgebuhr.
Ein Trainer halt einen Schulungstermin ab und bekommt dafur ein Honorar.
2. Eigenschaften der Objekte:
Eine Schulung hat Titel, Inhalt, Lange, Preis.
Ein Schulungstermin hat Schulung, Termin, Ort, Trainer, maximale Teilnehmerzahl,
tatsachliche Teilnehmerzahl, angemeldete Teilnehmer.
Ein Teilnehmer ist eine Person.
Eine Person hat Name, Adresse, Telefon, Konto ...
Ein Trainer ist eine Person und hat einen Tagessatz.
Ein Schulungsunternehmen ist wie eine Person und hat Schulungen und
Schulungstermine.
4.16 Ubung: Analyse Bucherregal
Uberlegen Sie, aus welchen Objekten das System "Bucherregal mit Buchern" besteht
und welche Datenfelder und Methoden die Klasse Bucherregal enthalten mu.
Es geht dabei nur um die Analyse und das Design des Systems, nicht um die konkrete
Programmierung. Schreiben Sie das Ergebnis daher bitte nur in der Form von
Stichworten oder graphischen Skizzen auf einem Blatt Papier auf, nicht als Java-
Programm.
Java-Einfuhrung von H. Partl { Kursunterlage 51

4.17 Vererbung (Inheritance, Polymorphismus, override)
Eine der wichtigsten Eigenschaften von objekt-orientierten Systemen stellt die sogenannte
"Vererbung" von Oberklassen (Superklassen) auf Unterklassen (Subklassen)
dar. Dies stellt eine wesentliche Vereinfachung der Programmierung dar und ist immer
dann moglich, wenn eine Beziehung der Form "A ist ein B" besteht.
Beispiele: Ein Auto ist ein Fahrzeug (hier ist Fahrzeug der Oberbegri, also die
Superklasse, und Auto ist die spezielle Subklasse). Ein Bilderbuch ist ein Buch. Ein
Mitarbeiter ist eine Person...
Keine Vererbung ist in den folgenden Fallen gegeben: Ein Bucherregal enthalt
Bucher. Ein Bilderbuch enthalt Bilder. Ein Mitarbeiter liest ein Buch.
Der Vorteil der Vererbung besteht darin, da man dieselben Konzepte nicht mehrfach
programmieren mu, sondern auf einfache Grundbegrie zuruckfuhren und wiederverwenden
kann.
Dazu wird zunachst die Oberklasse, die den allgemeinen Grundbegri moglichst
einfach beschreibt, mit den fur alle Falle gemeinsam geltenden Datenfeldern und
Methoden deniert.
Dann gibt man bei der Denition der Unterklasse mit extends an, da es sich um
einen Spezialfall der Oberklasse handelt, und braucht jetzt nur die Datenfelder und
Methoden zu denieren, die zusatzlich zu denen der Oberklasse notwendig sind. Alle
anderen Denitionen werden automatisch von der Oberklasse ubernommen.
Beispiel:
public class Person {
public String name;
public Date geburtsDatum;
...
}
public class Beamter extends Person {
public int dienstKlasse;
public Date eintrittsDatum;
...
}
Dann enthalten Objekte vom Typ Person die beiden Felder name und geburts-
Datum, und Objekte vom Typ Beamter enthalten die vier Felder name, geburts-
Datum, dienstKlasse und eintrittsDatum. Das analoge gilt fur die hier nicht gezeigten
Methoden.
Man kann auch Methoden, die bereits in der Oberklasse deniert sind, in der Unterklasse
neu denieren und damit die alte Bedeutung fur Objekte des neuen Typs
uberschreiben (override). Dabei braucht man eventuell nur die Teile neu zu schreiben,
die zur entsprechenden Methode der Oberklasse hinzukommen, und kann fur
den gleichbleibenden Teil die Methode der Oberklasse mit super.name() aufrufen.
Wenn eine Methode in der Oberklasse als final deklariert ist, kann sie von Unterklassen
nicht uberschrieben werden.
Java-Einfuhrung von H. Partl { Kursunterlage 52

Konstruktoren werden nicht automatisch von der Oberklasse ubernommen sondern
mussen neu deniert werden, wenn man mehr als den Default-Konstruktor mit der
leeren Parameterliste braucht. Allerdings braucht man in diesen Konstruktoren nur
diejenigen Aktionen zu denieren, die gegenuber der Oberklasse neu sind, und kann
vorher - als erstes Statement - mit super(); oder super(parameterliste); den
Konstruktor der Oberklasse aufrufen. Wenn man das nicht tut, wird vom Compiler
automatisch der Default-Konstruktor super(); an den Anfang hinzugefugt.
Referenzen auf ein Objekt der Unterklasse konnen sowohl in Variablen vom Typ
der Unterklasse als auch vom Typ der Oberklasse abgespeichert werden. Das gilt
auch bei der Verwendung in Parameterlisten. Erlaubt sind also z.B. die folgenden
Zuweisungen:
Person mutter;
Person vater;
mutter = new Person();
vater = new Beamter();
Allerdings konnen in diesem Fall auch fur das Objekt vater nur die Datenfelder
und Methoden aufgerufen werden, die fur Personen deniert sind, andernfalls erhalt
man einen Compiler-Fehler. Man kann aber mit instanceof abfragen, um welchen
Typ (Ober- oder Unterklasse) es sich zur Laufzeit handelt, und dann mit Casting
die Typumwandlung durchfuhren. Beispiel:
public void printName (Person p) {
System.out.print(p.name);
if (p instanceof Beamter) {
System.out.print(", " + ((Beamter)p).dienstKlasse );
}
System.out.println();
}
Solche Konstruktionen sind aber nur sehr selten notwendig, denn nach den Prinzipien
der objekt-orientierten Programmierung sollten die Oberklassen von den Unterklassen
unabhangig sein und alles, was eine Unterklasse betrit, sollte nur in dieser
Unterklasse programmiert werden, z.B. durch Uberschreiben der entsprechenden
Methoden.
4.18 Ubung: Person und Student
Schreiben Sie 3 Klassen:
1. eine einfache Klasse "Person" mit den Datenfeldern und Methoden vorname,
zuname, getVorname, setVorname, getZuname, setZuname, und einer Methode
toString, die einen String liefert, der den Vor- und Zunamen anzeigt.
2. eine einfache Klasse "Student" mit den zusatzlichen Datenfeldern und Methoden
uni, getUni, setUni, und einer entsprechend erweiterten Methode toString,
die Vorname, Zuname und Universitat anzeigt.
3. eine Klasse mit einer main-Methode, in der ein paar Objekte von Person und
Student angelegt werden und deren Inhalt mit Hilfe der toString-Methode auf
den Bildschirm ausgegeben wird.
Java-Einfuhrung von H. Partl { Kursunterlage 53

4.19 Mehrfache Vererbung, Interfaces, abstrakte Klassen
Interfaces
Abstrakte Klassen
Unter mehrfacher Vererbung versteht man die Moglichkeit, da eine Klasse Unterklasse
von zwei verschiedenen Oberklassen ist, also z.B. ein Dreirad ist ein Fahrzeug
und ein Kinderspielzeug.
Java unterstutzt keine mehrfache Vererbung, in extends kann nur eine Oberklasse
angegeben werden. Eine mehrfache Angabe ist aber bei Interfaces moglich.
Interfaces sind etwas ahnliches wie Klassen, die aber nur das Konzept fur die Unterklassen
skizzieren, das dann von diesen "implementiert" werden mu. Interfaces
enthalten keine Datenfelder und nur die "Signaturen" von Methoden, statt der De-
nition des Methoden-Inhalts zwischen f und g enthalten sie nur einen Strichpunkt.
Die Denition eines Interface folgt dem folgenden Schema:
public interface InterfaceName {
public typ name1 (parameterliste) ;
public void name2 (parameterliste) ;
}
Die Subklasse, die dieses Interface implementiert, mu dann alle darin skizzierten
Methoden enthalten, mit genau derselben Signature (Typ, Name und Parameterliste)
und einem konkreten Block von Statements oder zumindest einem leeren Block.
Beispiel:
public class ClassName implements InterfaceName {
...
public typ name1 (parameterliste) {
Statements;
}
public void name2 (parameterliste) {
}
}
Nach dem Wort implements konnen auch mehrere Interfaces angefuhrt werden
(durch Komma getrennt), dann mu die Klasse alle in diesen Interfaces denierten
Methoden implementieren. Zusatzlich kann auch noch mit extends eine Oberklasse
angegeben werden. Beispiel:
public class SubClass extends SuperClass
implements Interface1, Interface2
Abstrakte Klassen (abstract class) stellen eine Mischung aus Superklassen und Interfaces
dar: ein Teil der Methoden ist in der abstrakten Klasse konkret deniert wie
bei Superklassen, und von einem anderen Teil ist nur die Signature der Methoden
skizziert, wie bei Interfaces. Die Denition beginnt mit
public abstract class SuperClassName
und die Vererbung in der Subklasse wie gewohnt mit
Java-Einfuhrung von H. Partl { Kursunterlage 54

public class SubClassName extends SuperClassName
Die Subklasse mu dann konkrete Implementierungen von allen in der Superklasse
nur skizzierten Methoden enthalten und kann die dort konkret denierten Methoden
entweder ubernehmen (Vererbung) oder uberschreiben (override).
4.20 Beispiel: Katzenmusik
Eine kleine Ubungsaufgabe zum Vestandnis fur die Anwendung von Interfaces.
Das folgende einfache Programm soll funktionieren:
public class Katzenmusik {
public static void main (String[] args) {
LautesTier tier1 = new Katze();
LautesTier tier2 = new Hund();
for (int i=1; i

4.21 Innere Klassen (inner class)
Ab JDK 1.1. kann man Klassen auch innerhalb von anderen Klassen denieren,
sie konnen dann nur innerhalb dieser Klasse verwendet werden, haben aber (im
Gegensatz zu separat denierten Klassen) Zugri auf alle in der aueren Klasse
denierten Datenfelder und Methoden.
4.22 Zugri auf Objekte von anderen Klassen
Wie kann man ein Objekt, das in einer Klasse angelegt wurde, auch in einer anderen
Klasse ansprechen?
Dazu mu man die Referenz auf das Objekt vom Objekt der einen Klasse an das
Objekt der anderen Klasse ubergeben, entweder mit Hilfe einer Methode oder mit
Hilfe eines Konstruktors.
Ubergabe von A an B mit einer Methode:
public class A {
...
B b = new B();
b.setA(this); // tell b "I am your A"
...
}
public class B {
private A a = null; // reference to object of class A
public void setA (A a) {
this.a=a;
}
...
a.xxx(); // method of object of class A
...
}
Ubergabe von A an B mit einem Konstruktor:
public class A {
...
B b = new B(this); // tell b "I am your A"
...
}
public class B {
private A a = null; // reference to object of class A
public B() {
this(null);
}
public B (A a) {
this.a=a;
}
Java-Einfuhrung von H. Partl { Kursunterlage 56

}
...
a.xxx(); // method of object of class A
...
4.23 Packages und import
Unter einem Package versteht man eine Menge von zusammengehorenden Klassen,
ahnlich wie bei einer Programmbibliothek. Package ist im wesentlichen identisch mit
Directory: Alle Klassen, die im selben Directory liegen, gehoren zu diesem Package.
In Java werden Packages einheitlich und plattformunabhangig mit Punkten zwischen
den Directory-Namen geschrieben, egal, ob auf der jeweiligen Plattform
Schragstriche / oder Backslashes n oder sonst etwas als File-Separator verwendet
wird.
Wenn man in einer Java-Klasse andere Klassen oder Interfaces ansprechen will, mu
man diese im allgemeinen "importieren". Dazu gibt man am Beginn des Source-Files
mit import den Namen der Klasse (meist mit ihrem Package-Namen) an, oder man
importiert gleich alle Klassen eines Package, indem man einen Stern * angibt:
import aaa.bbb.Xxxx ;
import aaa.bbb.* ;
Im ersten Fall wird die Klasse Xxxx aus dem Package aaa.bbb verfugbar gemacht,
im zweiten Fall alle Klassen aus dem Package aaa.bbb. Bitte, vergessen Sie nicht
den Strichpunkt, der das import-Statement beenden mu.
Die Angabe der Packages (Directories) erfolgt immer relativ zu den Directories, die
in der Environment-Variablen CLASSPATH angefuhrt sind.
Wenn der Punkt . fur das jeweilige Directory in CLASSPATH enthalten ist, dann
braucht man fur Klassen, die im selben Directory liegen, kein import-Statement
anzugeben, sondern alle Klassen, die im selben Directory liegen, stehen automatisch
zur Verfugung.
Das zur Grundausstattung von Java gehorende Package java.lang und das "eigene"
Package (eigenes Directory oder package-Angabe) werden vom Compiler automatisch
gefunden und mussen nicht explizit importiert werden, wohl aber alle anderen
wie z.B. java.util, java.text, java.awt, java.awt.event etc.
Selbstverstandlich kann man Klassen und deren Datenfelder und Methoden nur dann
ansprechen, wenn man die Erlaubnis dazu hat (siehe Kapselung).
Java-Einfuhrung von H. Partl { Kursunterlage 57

5. Fehlerbehandlung (Exceptions)
normaler Programmablauf
Ausnahmen (Fehlersituationen, Exceptions)
Java bietet eine sehr bequeme Moglichkeit, etwaige Fehlersituationen zu erkennen
und dann entsprechend zu reagieren, ohne gleich das ganze Programm abzubrechen.
Dabei werden die Fehler von einer aufgerufenen Methode erkannt und "geworfen"
(throw) und mussen dann von der aufrufenden Methode "aufgefangen" oder "abgefangen"
(catch) werden.
Es gibt mehrere Arten von Fehlerbedingungen, die entweder abgefangen werden
mussen oder abgefangen werden konnen:
Exception und RuntimeException fur Benutzungsfehler,
Error fur Softwarefehler,
Throwable als Oberbegri fur Exception und Error.
Im folgenden werden Exceptions beschrieben, die abgefangen werden mussen.
5.1 Fehler erkennen (throw, throws)
Wenn eine aufgerufene Methode eine Fehlersituation erkennt, dann generiert sie ein
Objekt, das den aufgetretenen Fehler beschreibt (exception) und "wirft" diese Exception
mit throw. Dies passiert meist innerhalb eines if-Blockes irgendwo innerhalb
der Methode.
Damit sofort klar ist, welche Fehlersituationen in einer Methode auftreten konnen
und daher von den aufrufenden Methoden abgefangen werden mussen, mu man
schon bei der Deklaration der Methode mit throws angeben, welche Exceptions in
ihr eventuell geworfen werden (eventuell mehrere, durch Komma getrennt). Falls
man dies vergit, wird man vom Compiler mit einer Fehlermeldung daran erinnert,
welche Exceptions man in throws angeben mu.
Beispiel:
public void xxxMethod (parameterliste)
throws XxxxException {
...
if (...)
throw new XxxxException();
...
}
Man kann
Java-Einfuhrung von H. Partl { Kursunterlage 58

entweder eine der vordenierten Exceptions verwenden (wie z.B. ArrayIndex-
OutOfBoundsException, IOException, IllegalArgumentException oder No-
SuchElementException, siehe die Klassen-Hierarchie der Klasse Exception)
oder eine eigene Exception denieren, die diese spezielle Fehlersituation beschreibt.
Mit
public class XxxxException extends YyyyException { }
deniert man eine neue Exception, die den neuen Namen XxxxException und die
gleichen Datenfelder und Methoden wie die bereits denierte Exception YyyyException
hat. Diese Oberklasse sollte moglichst passend gewahlt werden, damit die
neue Exception richtig in die Hierarchie der Ober- und Unterklassen eingeordnet
wird. Beispiele:
public class SalaryTooLowException
extends IllegalArgumentException { }
public class StudentNotFoundException
extends NoSuchElementException { }
public class LVANumberFormatException
extends DataFormatException { }
5.2 Fehler abfangen (try, catch)
Die aufrufende Methode hat nun zwei Moglichkeiten:
Entweder sie "wirft" die Fehlersituation weiter an die Methode, von der sie
aufgerufen wird, indem Sie die Exceptions mit throws anfuhrt,
oder sie fangt den Fehler ab und reagiert selbst. Zu diesem Zweck mussen alle
Statements, die eine Fehlersituation bewirken konnen, in einem try-Block stehen,
und anschlieend mit einem oder mehreren catch-Blocken die moglichen
Fehler abgefangen werden.
Beispiel:
try {
Statements;
xxxObject.xxxMethod();
Statements;
} catch (XxxxException e) {
System.out.println("*** error: " + e);
}
Der try-Block kann ein oder mehrere Statements enthalten, und es konnen auch
mehrere catch-Blocke fur verschiedene Fehlersituationen angegeben werden.
Wann immer eines der Statements irgendeinen Fehler "wirft", werden die restlichen
Statements des try-Blocks nicht ausgefuhrt und es wird der (erste) catch-Block
ausgefuhrt, der den aufgetretenen Fehler auangt. Dann wird die Verarbeitung mit
den Statements nach dem letzten catch-Block fortgesetzt oder der Fehler, falls er
Java-Einfuhrung von H. Partl { Kursunterlage 59

nicht abgefangen wurde, an die aufrufende Methode weitergeworfen. (Falls man
einen nally-Block angibt, wird dieser jedenfalls auch noch ausgefuhrt.)
Wenn man mehrere catch-Blocke angibt, ist die Reihenfolge wichtig, man mu zuerst
die spezielleren Exceptions (Unterklassen) und dann die allgemeineren Exceptions
(Oberklassen) angeben.
Im Catch-Block kann man die folgenden Methoden der Exception verwenden:
String toString()
fur eine kurze Angabe, welcher Fehler aufgetreten ist
String getMessage()
fur einen erklarenden Text
printStackTrace()
printStackTrace(filename)
fur das Ausdrucken der Information, welcher Fehler wo in welchem Programm
aufgetreten ist.
Was man im Catch-Block ausfuhrt, hangt von der jeweiligen Anwendung ab. Meistens
wird man
eine Fehlermeldung an den Benutzer ausgeben
und dann
entweder den Fehler selbstandig korrigieren und die Verarbeitung mit dem
korrigierten Datenwert fortsetzen
oder die Verarbeitung abbrechen.
Wenn man vergit, da eine bestimmte Anweisung "gefahrlich" ist und eine Fehlersituation
bewirken kann, dann sagt einem der Compiler meistens mit einer Fehlermeldung,
da man sie in einen try-Block einbauen soll, und gibt auch gleich an,
welche Exception man im catch-Block abfangen soll. Man mu dann entweder diesen
catch-Block anfugen oder - wenn man sich mit den Details nicht beschaftigen will -
die folgende Oberklasse fur alle moglichen Fehler:
catch (Exception e) {
System.out.println(e);
}
oder eventuell sogar
catch (Throwable e) { }
5.3 Mathematische Fehler
Division durch Null und andere "verbotene" mathematische Berechnungen bewirken
nur bei ganzzahligen Typen wie int, long etc. eine entsprechende Exception.
Bei oat- und double-Zahlen bewirken Division durch Null, Logarithmus einer negativen
Zahl und ahnliche "falsche" Operationen hingegen keine Exception sondern
liefern als Ergebnis die speziellen Werte "unendlich" (innite) bzw. "unbestimmt"
(keine Zahl, not a number). Fur die Abfrage dieser Werte und Bedingungen gibt es
eigene Konstanten und Methoden in den Klassen Float und Double.
Java-Einfuhrung von H. Partl { Kursunterlage 60

5.4 Ubung: erweitertes Rechenbeispiel Sparbuch
Schreiben Sie eine Applikation, die wie beim einfachen Sparbuch-Beispiel im Kapitel
Syntax und Statements die Wertentwicklung eines Geldbetrages uber 10 Jahre
ausgibt, aber mit folgenden Erweiterungen:
Geldbetrag und Zinssatz werden nicht in der main-Methode festgelegt sondern
vom Benutzer beim Aufruf in der Parameterliste ubergeben.
Die Zahlenausgabe soll mit der Klasse DecimalFormat in ein "schones" Format
gebracht werden.
Java-Einfuhrung von H. Partl { Kursunterlage 61

User-Interfaces
Graphical User Interfaces (GUI)
Applets
Threads
Java-Einfuhrung von H. Partl { Kursunterlage 62

6. Graphical User Interfaces (GUI)
Fenster, Texte und Bilder, Tastatur und Maus
Ablauf vom Benutzer gesteuert, nicht vom Programm
Bei Programmen mit graphischen Benutzungsoberachen (GUI) kommt es auf das
Zusammenspiel von 3 Bereichen an:
Model = die Datenstruktur
View = die graphische Darstellung (Mensch-Maschine-Interface, Renderer)
Controller = die Verarbeitung der Daten (Ausfuhrung von Aktionen)
In sehr einfachen Fallen konnen alle diese Aspekte innerhalb desselben Programms
(derselben Klasse) behandelt werden.
Fur komplexere Anwendungen wird aber empfohlen, diese 3 Bereiche getrennt zu
programmieren und damit die Vorteile der objekt-orientierten Programmierung auszunutzen
(siehe das Kapitel uber Objekte und Klassen). Professionelle Software-
Hersteller setzen fur die Programmierung der drei Bereiche oft sogar verschiedene
Personen ein, die jeweils Spezialisten fur ihren Bereich sind.
6.1 Abstract Windowing Toolkit (AWT)
Das Abstract Windowing Toolkit (AWT) ist ein Package, das Klassen fur die Zusammenstellung
und Verwendung von graphischen Benutzungsoberachen (GUI)
enthalt. Solche GUIs bestehen aus Fenstern, Menus, Eingabefeldern, Buttons und
dergleichen, und die Steuerung durch den Benutzer erfolgt meistens mit Tastatur
(Keyboard) und Maus oder mit ahnlichen Hardware-Komponenten wie z.B. Trackballs,
Touchscreen oder Spracheingabe.
Das Wort abstrakt (abstract) im Namen AWT deutet darauf hin, da in diesen
Klassen nur die plattformunabhangigen wesentlichen Eigenschaften der Komponenten
deniert sind und fur die konkrete Darstellung dann die am jeweiligen Rechner
vorhandenen Systemkomponenten ("Peers") mit den auf diesem Rechner ublichen
Layouts, Aussehen und Funktionalitaten ("look and feel") verwendet werden. Ein
im Java-Programm mit AWT denierter Button wird also auf einem PC wie normale
Windows-Buttons, auf einem Macintosh wie normale Apple-Buttons und unter Unix
wie normale Motif- oder CDE-Buttons aussehen, und das gleiche gilt fur Fenster,
Scrollbars, Menus etc.
Dies hat fur den Benutzer den Vorteil, da er auf seinem Computersystem immer dieselben,
gewohnten GUI-Komponenten vorndet, unabhangig von der Applikation.
Es hat aber den Nachteil, da die gleiche Applikation auf verschiedenen Computersystemen
dadurch in den Details verschieden aussieht und da im Fall von Applets
keine genaue Anpassung der Groen, Farben, Schriftarten und Graphik-Elemente
an die umgebende Web-Page moglich ist.
Java-Einfuhrung von H. Partl { Kursunterlage 63

Deshalb unterstutzen neuere Java-Versionen (Swing, JDK 1.2) zusatzlich zu den
Peer-Komponenten auch sogenannte "leichte" (light weight) Komponenten, die komplett
in Java geschrieben sind und bei denen die Layout-Details genauer deniert
werden konnen. Damit kann man Applets und Applikationen so gestalten, da jede
Anwendung plattformubergreifend ihr eigenes Look-and-Feel hat.
Beide Methoden haben ihre Vor- und Nachteile.
Die Swing-Komponenten sind Teil der sogenannten Java Foundation Classes (JFC).
Sie konnen beim JDK 1.1 zusatzlich installiert werden und sind ab JDK 1.2 Teil des
JDK. Sie werden von den meisten Web-Browsern noch nicht unterstutzt.
Fur AWT Version 1.1 mussen die Packages java.awt und java.awt.event importiert
werden, fur Swing zusatzlich das Package javax.swing.
6.2 AWT-Komponenten (Component)
Frame
Panel
Canvas
Label
Die folgenden Komponenten stehen in allen AWT-Versionen zur Verfugung. Sie sind
Peer-Komponenten, d.h. das Aussehen und die Funktionalitat entsprechen immer
dem jeweiligen Rechnersystem.
ein Fenster mit Rahmen, das also vom Benutzer vergroert, verkleinert, verschoben,
geschlossen werden kann (hat nichts mit dem gleichnamigen HTML-Tag zu tun).
Konstruktor:
new Frame(String)
ein Bereich innerhalb eines Fensters oder eines anderen Panels, ohne eigenen Rahmen.
Dies dient vor allem dazu, ein Fenster oder Applet in mehrere Bereiche zu unterteilen,
in denen dann weitere Komponenten mit verschiedenen Layout-Managern
angeordnet werden. Konstruktor:
new Panel()
oder new Panel(LayoutManager)
eine Flache, die fur graphische Ein- und Ausgabe verwendet werden kann. Der Inhalt
und die Groe mussen vom Programmierer deniert werden, zu diesem Zweck wird
meist eine Subklasse von Canvas deniert, in der die entsprechenden Methoden
uberschrieben werden, insbesondere die paint-Methode (siehe unten). Konstruktor:
new Canvas()
ein einfaches Feld fur die Darstellung eines einzeiligen Textes. Konstruktor:
new Label(String)
Java-Einfuhrung von H. Partl { Kursunterlage 64

Button
ein Knopf mit Text, der vom Benutzer mit der Maus gedruckt oder angeklickt werden
kann. Es wird dringend empfohlen, Buttons nur dann zu verwenden, wenn das
Anklicken tatsachlich etwas bewirkt, und fur Texte, die man nicht anklicken soll,
stattdessen Labels zu verwenden. Auerdem wird empfohlen, Buttons immer in ihrer
naturlichen Groe anzulegen (also z.B. mit dem Flow-Layout-Manager) und nicht
groer werden zu lassen, damit sie vom Benutzer immer sofort als typische Buttons
erkannt werden. Konstruktor:
new Button(String)
Checkbox
ein Schalter mit Beschriftung, der ein- oder ausgeschaltet werden kann. Checkboxes
konnen auch in einer CheckboxGroup zusammengefat werden, dann bewirkt das
Einschalten einer Checkbox automatisch das Ausschalten der anderen (radio button).
Konstruktoren:
new Checkbox (String, boolean)
new CheckboxGroup()
new Checkbox (String, boolean, CheckboxGroup)
Choice, List
Listen von Texten, von denen einer bzw. mehrere ausgewahlt werden konnen. Konstruktoren:
new Choice()
new List(int)
TextField
ein einzeiliges Feld fur Tastatur-Eingaben. Konstruktor:
new TextField (columns)
oder new TextField (String, columns)
TextArea
ein mehrzeiliges Feld fur Tastatur-Eingaben. Konstruktor:
new TextArea (rows, columns)
oder new TextArea (String, rows, columns)
Dialog
ein kleines Fenster mit einem Text, das eventuell auf eine Aktion des Benutzers
wartet (z.B. eine Fehlermeldung, die erst dann verschwindet, wenn der Benutzer sie
anklickt). Konstruktor:
new Dialog (Frame, String, true)
FileDialog
ein Menu zum Auswahlen einer Datei. Konstruktoren:
new FileDialog (Frame, String, FileDialog.LOAD)
new FileDialog (Frame, String, FileDialog.SAVE)
Java-Einfuhrung von H. Partl { Kursunterlage 65

MenuBar, Menu, MenuItem, CheckboxMenuItem, PopupMenu
ScrollBar
ScrollPane
Methoden
Komponenten zum Anlegen einer Menu-Leiste in einem Frame und von Haupt-
Menus, Unter-Menus, Help-Menus oder Popup-Menus sowie von Menu-Items, die
ausgewahlt werden konnen. Konstruktoren:
new MenuBar()
new Menu(String)
new MenuItem(String)
new MenuItem (String, MenuShortcut)
new MenuShortcut(keycode)
new MenuShortcut (keycode, shift)
new CheckboxMenuItem (String, boolean)
new PopupMenu(String)
ein horizontaler oder vertikaler Scrollbar. Konstruktoren:
new ScrollBar (Scrollbar.HORIZONTAL)
new ScrollBar (Scrollbar.VERTICAL)
new ScrollBar (orientation, value, size, min, max)
ein Rahmen mit Scrollbars zu einem zu groen Panel oder Canvas. Konstruktor:
new ScrollPane()
oder new ScrollPane (ScrollPane.policy)
Alle Komponenten haben die folgenden Methoden:
setForeground, setBackground (siehe Farben)
setFont (siehe Schriften)
setSize, getSize, getPreferredSize, getMinimumSize (siehe Groe)
addXxxxListener (siehe Event-Handling)
setVisible(true) und setVisible(false) fur die Sichtbarkeit
dispose() fur das endgultige Beenden
paint, update und repaint fur die Darstellung auf dem Bildschirm des Benutzers
(siehe Graphiken)
Fur die einzelnen Komponenten gibt es meist noch weitere, spezielle Methoden, wie
z.B.
getText() und setText(String) bei den Komponenten, die einen Text enthalten,
getFile() fur den im FileDialog ausgewahlten Filenamen,
getTitle() und setTitle(String) fur den Text im Titlebar eines Frame,
Java-Einfuhrung von H. Partl { Kursunterlage 66

Andere Komponenten:
6.3 Container
setEnabled(boolean) oder setEditable(boolean) fur das Aktivieren und
Deaktivieren eines Button oder Eingabefeldes,
und andere. Die Details nden Sie in der Online-Dokumentation (API).
Frames, Panels, Menus und dergleichen sind Container, d.h. sie konnen andere Komponenten
enthalten (eventuell auch mehrfach geschachtelt), und enthalten zu diesem
Zweck weitere Methoden, siehe das Kapitel uber Container.
Falls Sie mit dem Layout oder der Funktionsweise der im AWT bzw. in Swing vorgesehenen
Komponenten nicht zufrieden sind, konnen Sie mit Hilfe eines Canvas
beliebige eigene Komponenten denieren, z.B. spezielle Buttons, die ein Bild statt
der Beschriftung enthalten oder die ihr Aussehen oder ihre Beschriftung verandern,
wenn sie von der Maus erreicht, gedruckt oder angeklickt werden oder wenn bestimmte
andere Aktionen erfolgreich oder nicht erfolgreich abgelaufen sind.
Frames, Panels, ScrollPanes, Menus und dergleichen sind Container, d.h. sie konnen
andere Komponenten enthalten (eventuell auch mehrfach geschachtelt), die dann
in einer bestimmten Anordnung innerhalb des Containers dargestellt werden. Zu
diesem Zweck enthalten Container - zusatzlich zu den oben angefuhrten, fur alle
Komponenten gultigen Methoden - die folgenden Methoden:
setLayout (LayoutManager) fur den Layout-Manager
add (Component) oder add (Component, Zusatzangabe) fur das Hinzufugen
einer Komponente in den Container
remove (Component) und removeAll() fur das Entfernen einer Komponente
bzw. von allen Komponenten aus dem Container
validate() fur das Sichtbarmachen des neuen Zustands mit dem Layout-
Manager
Ein typisches Beispiel fur die Anwendung dieser Methoden nden Sie weiter unten.
Hier nur eine kurze Skizze:
Frame f = new Frame("Titlebar");
f.setLayout( new FlowLayout() );
Button b = new Button("Press me!");
f.add(b);
Java-Einfuhrung von H. Partl { Kursunterlage 67

6.4 Layout-Manager
FlowLayout
BorderLayout
Der Layout-Manager dient dazu, die einzelnen Komponenten innerhalb eines Containers
anzuordnen und die Groe des Containers zu bestimmen. Er wird mit
setLayout ( new LayoutManagerName() )
vereinbart. Wenn man mit keinem der vordenierten Layout-Manager zufrieden ist,
kann man
setLayout(null)
angeben und mu dann alle Komponenten selbst mit setLocation, setSize, SetBounds
innerhalb des Containers positionieren.
Die wichtigsten und einfachsten Layout-Manager sind:
setLayout ( new FlowLayout() )
Die Elemente werden zeilenweise nebeneinander angeordnet, der Reihe nach von
links nach rechts; falls die Breite nicht ausreicht, dann in mehreren Zeilen. Standardmaig
werden die Zeilen zentriert, man kann aber im Konstruktor auch mit
einem Parameter angeben, da sie links- oder rechtsbundig ausgerichtet werden sollen,
z.B. mit
setLayout ( new FlowLayout(FlowLayout.LEFT) )
setLayout ( new BorderLayout() )
Der Container wird in 4 Randbereiche und einen Bereich fur den restlichen Platz
in der Mitte eingeteilt, kann also hochstens 5 Elemente aufnehmen. Diese Elemente
sind meistens Panels, die dann ihrerseits einzelne Komponenten enthalten und diese
mit geeigneten Layout-Managern anordnen.
Im add-Befehl mu mit einem zusatzlichen Parameter angegeben werden, welchen
der 5 Bereiche die Komponente ausfullen soll:
add (Component, "North")
setzt die Komponente an den oberen Rand des Containers, mit minimaler
Hohe und der vollen Container-Breite.
add (Component, "South")
setzt die Komponente an den unteren Rand des Containers, mit minimaler
Hohe und der vollen Container-Breite.
add (Component, "West")
setzt die Komponente an den linken Rand des Containers, mit minimaler
Breite und der vollen im Container zur Verfugung stehenden Hohe.
add (Component, "East")
setzt die Komponente an den rechten Rand des Containers, mit minimaler
Breite und der vollen im Container zur Verfugung stehenden Hohe.
Java-Einfuhrung von H. Partl { Kursunterlage 68

add (Component, "Center")
setzt die Komponente in den zwischen den anderen Komponenten verbleibenden
Platz in der Mitte des Containers, mit der vollen dort zur Verfugung
stehenden Hohe und Breite.
Man mu nicht immer alle 5 Bereiche verwenden, oft wird das Border-Layout nur
dazu verwendet, 2 oder 3 Komponenten neben- oder ubereinander anzuordnen.
GridLayout
setLayout ( new GridLayout (n, m) )
Der Container wird in n mal m gleich groe Bereiche in n Zeilen und m Spalten
aufgeteilt, und die Komponenten werden in der Reihenfolge der add-Befehle Zeile
fur Zeile in dieses Gitter eingefugt und alle auf die gleiche Groe vergroert.
Damit kann man z.B. eine Zeile oder eine Spalte von gleich groen Buttons erzeugen.
Ab JDK 1.1 gibt es auch ein GridBagLayout, mit dem man komplexere Gitter-
Strukturen denieren kann.
Ab JDK 1.2 gibt es auch ein BoxLayout, mit dem man verschieden groe Komponenten
in Zeilen, Spalten oder Gitter-Strukturen anordnen kann. Dazu mu man
deren Groen jeweils mit getPreferredSize angeben.
CardLayout
CardLayout cards = new CardLayout();
container.setLayout (cards);
Es wird jeweils nur eine der Komponenten im Container angezeigt, alle anderen
Komponenten sind unsichtbar, wie beim Aufschlagen von Spielkarten oder bei einem
Dia-Vortrag.
Mit add (Component, String) wird mit dem String-Parameter ein Name fur die
Komponente vereinbart. Die Reihenfolge der add-Befehle ist relevant.
Mit cards.show(container, String) wird die Komponente mit dem angegebenen
Namen angezeigt.
Mit cards.next(container) wird die jeweils nachste Komponente (in der Reihenfolge
der add-Befehle) angezeigt.
Mit cards.first(container) und cards.last(container) wird die erste
bzw. letzte Komponente angezeigt.
Dynamische Layout- Anderungen
Wenn sich die Groe des Containers andert, ordnet der Layout-Manager die darin
enthaltenen Komponenten automatisch neu an.
Wenn sich die Groe einer Komponente andert, kann man nach dem folgenden
Schema erreichen, da der Layout-Manager die Komponenten im Container richtig
anordnet und anzeigt:
Java-Einfuhrung von H. Partl { Kursunterlage 69

component.invalidate();
// change component
container.validate();
Dabei kann man den Container entweder direkt angeben oder mit component.getParent()
erhalten. Das validate() im Container bewirkt auch ein validate() fur die Komponente
und ein doLayout() fur den Container.
6.5 Ubung: Layout-Manager
6.6 Farben (Color)
Erstellen Sie ein einfaches GUI (1 Frame mit 2 Buttons, 1 Label, 1 TextField) und
probieren Sie 3 verschiedene Layout-Manager aus; vorerst ohne Event-Handling,
Abbruch mit Ctrl-C im Befehlsfenster.
Die Vordergrundfarbe (fur Texte und Linien) und Hintergrundfarbe von Komponenten
konnen mit den folgenden Methoden festgelegt werden:
setForeground (Color.xxx);
setBackground (Color.xxx);
Diese Methoden mussen immer paarweise aufgerufen werden, d.h. man mu immer
beide Farben festlegen, man kann sich nicht darauf verlassen, da der Benutzer eine
bestimmte Hintergrundfarbe wie wei oder hellgrau eingestellt hat. Wenn man z.B.
nur den Vordergrund auf blau setzt, ein Benutzer aber aus irgendwelchen Grunden
fur seinen Bildschirm weie Schrift auf blauem Grund eingestellt hat, dann bekommt
er blau auf blau.
Die Farbe kann auf 3 Arten angegeben werden:
entweder mit einem der vordenierten Color-Objekte wie z.B. Color.black
oder Color.white,
oder mit einem selbst erzeugten Objekt wie z.B. new Color(255,151,0) fur
orange, wobei die 3 Zahlen den Rot-, Grun- und Blau-Anteil zwischen 0 und
255 angeben,
oder mit einem selbst erzeugten Objekt wie z.B. Color.decode("#FF9900")
mit einem String-Parameter, der die Farbe wie in HTML deniert.
Die Farben von Flachen, Linien und Schriften in Graphics-Objekten werden nicht
mit setForeground und setBackground sondern mit setColor angegeben (siehe unten).
Nach dem folgenden Schema konnen Sie die Farben im Applet auf die Farben der
Web-Page abstimmen: Der HTML-Angabe
entsprechen zum Beispiel die Java-Angaben
Color backColor = new Color (0xFF, 0xCC, 0x99);
Color textColor = new Color (0x00, 0x66, 0x33);
setBackground (backColor);
setForeground (textColor);
Java-Einfuhrung von H. Partl { Kursunterlage 70

6.7 Schriften (Font)
oder analog mit den dezimalen Angaben 0, 51, 102, 153, 204, 255, oder gleich mit
den String-Angaben:
Color backColor = Color.decode ("#FFCC99");
Color textColor = Color.decode (#006633);
setBackground (backColor);
setForeground (textColor);
Ab JDK 1.1 kann man mit statischen Feldern der Klasse SystemColor auf die vom
Benutzer jeweils auf seinem Rechner eingestellten Standardfarben zugreifen und die
Farben im Applet auf die Farben in den anderen Bildschirmfenstern abstimmen.
Beispiele:
fur Frame, Panel, Applet, Label:
setBackground (SystemColor.window);
setForeground (SystemColor.windowText);
fur TextField, TextArea:
setBackground (SystemColor.text);
setForeground (SystemColor.textText);
fur Button u.dgl.:
setBackground (SystemColor.control);
setForeground (SystemColor.controlText);
und analog fur Menus, Scrollbars und andere Komponenten sowie fur spezielle Farbgebungen
(highlight, inactive u.dgl.).
Die Schriftart und Schriftgroe von Komponenten kann mit der folgenden Methode
festgelegt werden:
Font f = new Font (Fontname, Fonttyp, Fontsize);
setFont (f);
Fontnamen sind "Serif", "SansSerif" und "Monospaced" (in Java 1.0: "TimesRoman",
"Helvetica" und "Courier").
Fonttypen sind Font.PLAIN (normal), Font.BOLD (fett), Font.ITALIC (kursiv)
oder die Summe Font.BOLD+Font.ITALIC.
Die Fontgroe wird als ganze Zahl in Points (nicht in Pixels) angegeben, eine typische
Fontgroe ist 12.
Java-Einfuhrung von H. Partl { Kursunterlage 71

6.8 Groenangaben
Bei den meisten Komponenten ergibt sich ihre richtige Groe aus ihrem Inhalt (Textstring
bei einem Label oder Button, Summe der Komponenten bei einem Container)
und mu daher vom Programmierer nicht explizit angegeben werden.
Bei einem Fenster (Frame oder Dialog) mu die Groe explizit angegeben werden:
entweder mit setSize( breite, hohe );
oder mit pack();
Dies bedeutet, da das Fenster mit Hilfe des Layout-Managers so klein wie
moglich gemacht wird, da gerade noch alle Komponenten darin Platz haben.
Bei einem Zeichenobjekt (Canvas) mu die Groe ebenfalls explizit angegeben
werden, und zwar mit Hilfe der folgenden Methoden, die vom Layout-Manager abgefragt
werden, um den benotigten Platz festzustellen:
getMinimumSize()
getPreferredSize()
getMaximumSize()
Es gibt auch weitere Spezialfalle, in denen man dem Layout-Manager mit solchen
expliziten Groenangaben helfen kann, die richtige Groe zu nden. Es hangt vom
jeweils verwendeten Layout-Manager ab, ob und wie er diese Groenangaben verwendet
und umsetzt.
Bei allen Komponenten und Containern kann man jederzeit mit
getSize()
abfragen, wie gro die Komponente tatsachlich ist. Diese Methode liefert ein Objekt
vom Typ Dimension, das die beiden Datenfelder width und height enthalt (Breite
und Hohe in Pixeln).
Java-Einfuhrung von H. Partl { Kursunterlage 72

6.9 Zeichenobjekte (Canvas)
Die Klasse Canvas beschreibt eine leere Zeichenache der Groe null mal null Pixels.
Fur konkrete Zeichenobjekte mu man deshalb jeweils eine Subklasse der Klasse
Canvas denieren und in ihr die folgenden Methoden uberschreiben:
getMinimumSize etc. fur die Groe
(wird vom Layout-Manager abgefragt, um die Groe und Position innerhalb
des Containers festzustellen),
paint fur den graphischen Inhalt
(wird vom Window-System aufgerufen, um das Objekt am Bildschirm sichtbar
zu machen).
Beispielskizze:
public class Xxxxx extends Canvas {
}
public Dimension getMinimumSize() {
return new Dimension (300, 200);
}
public Dimension getPreferredSize() {
return getMinimumSize();
}
public void paint (Graphics g) {
g.setColor (...);
g.draw... (...);
g.fill... (...);
}
6.10 Graphiken (Graphics, paint)
Bei fast allen Komponenten ist das Aussehen bereits festgelegt, die paint-Methode
soll daher nicht uberschrieben und die repaint-Methode nicht aufgerufen werden.
Nur bei Komponenten des Typs Canvas mu explizit mit der paint-Methode angegeben
werden, welche graphischen Elemente dargestellt werden sollen. Zu diesem
Zweck wird eine Subklasse der Klasse Canvas deniert und in ihr die paint-Methode
uberschrieben.
Die paint-Methode arbeitet mit einem Objekt des Typs Graphics und hat den folgenden
Aufbau:
public void paint (Graphics g) {
g.setColor (...);
g.draw... (...);
g.fill... (...);
}
Die wichtigsten Methoden des Graphics-Objekts sind:
Java-Einfuhrung von H. Partl { Kursunterlage 73

Farbe und Schrift:
Linien:
Flachen:
Texte (String):
Bevor man Linien zeichnet, Flachen fullt oder Strings ausgibt, mu man die Farbe
und eventuell auch die Schriftart fur die unmittelbar folgenden Graphik-Befehle
festlegen.
Die Festlegung der Farbe erfolgt hier also nicht mit setForeground und setBackground
sondern Schritt fur Schritt mit
setColor ( Color );
Die Festlegung der Schriftart erfolgt wie gewohnt mit
setFont ( Font );
drawLine (x1, y1, x2, y2);
zeichnet eine gerade Linie vom ersten Punkt zum zweiten Punkt. Wenn die beiden
Punkte identisch sind, wird nur ein Punkt gezeichnet (1 Pixel). Die Linienbreite
ist immer 1 Pixel. Breitere Linien kann man erzeugen, indem man mehrere parallele
Linien, jeweils um 1 Pixel verschoben, nebeneinander zeichnet, oder mit llPolygon
(siehe unten).
Mit den folgenden Methoden werden Linienzuge oder Kurven gezeichnet. Die Parameterliste
gibt meistens zuerst den linken oberen Eckpunkt und dann die Breite
und Hohe der Figur bzw. des sie umschreibenden Rechtecks an (Genauer: Das Rechteck
hat eine Breite von (width+1) Pixels und eine Hohe von (height+1) Pixels).
Kreise erhalt man als Spezialfall von Ellipsen mit gleicher Breite und Hohe.
drawRect (x1, y1, width, height);
drawPolygon (x[], y[], n);
drawPolyLine (x[], y[], n);
drawOval (x1, y1, width, height);
drawArc (x1, y1, width, height, startangle, angle);
Mit den folgenden Methoden werden Flachen farbig gefullt. Die ll-Methoden haben
stets die gleichen Parameter wie die entsprechenden draw-Methoden.
fillRect (x1, y1, width, height);
fillPolygon (x[], y[], n);
fillOval (x1, y1, width, height);
fillArc (x1, y1, width, height, startangle, angle);
drawString (String, x1, y1);
stellt einen einzeiligen Textstring dar. Ein automatischer Zeilenumbruch ist hier
nicht moglich.
Java-Einfuhrung von H. Partl { Kursunterlage 74

Bilder (Image)
drawImage (Image, x1, y1, this);
Programmtechnische Details:
Die Koordinaten werden in Bildpunkten (Pixels) angegeben. Der Ursprung (0,0)
des Koordinatensystems liegt links oben, die x-Achse geht von links nach rechts, die
y-Achse von oben nach unten (also umgekehrt wie in der Mathematik).
Winkelangaben erfolgen hier in Grad (im Gegensatz zu den mathematischen Funktionen
in der Klasse Math, wo sie in Radiant erfolgen). Winkel werden von "Osten"
aus gegen den Uhrzeigersinn gezahlt.
Die Reihenfolge der Aufrufe der einzelnen Methoden fur das Graphics-Objekt ist
wichtig: Spatere Aufrufe uberschreiben die von fruheren Aufrufen eventuell bereits
gesetzten Bildelemente (Pixels), d.h. die Reihenfolge der Befehle beginnt mit dem
Hintergrund und endet mit dem Vordergrund.
Die paint-Methode wird in verschiedenen Situationen aufgerufen:
1. explizit beim Aufruf der Methode repaint() sowie bei setVisible(true)
2. automatisch immer dann, wenn sich die Sichtbarkeit des Fensters am Bildschirm
des Benutzers andert, also z.B. wenn der Benutzer das Fenster verschiebt,
vergroert oder verkleinert, oder wenn das Fenster ganz oder teilweise
durch ein anderes Fenster verdeckt wird bzw. wieder zum Vorschein kommt.
Da man den zweiten Fall vom Programm aus nicht kontrollieren kann, ist es wichtig,
da die gesamte Graphik-Ausgabe innerhalb der paint-Methode deniert ist und
nicht in irgendwelchen anderen Methoden, die nur explizit aufgerufen werden.
Wenn sich die dargestellte Graphik in Abhangigkeit von bestimmten Aktionen
verandern soll, dann empehlt sich folgende Vorgangsweise: Man legt globale Datenfelder
an, die die verschiedenen Situationen beschreiben und die von der paint-
Methode abgefragt werden. Wenn sich das ausgegebene Bild andern soll, dann
verandert man diese Datenfelder und ruft repaint() auf, soda die paint-Methode
den neuen Zustand der Ausgabe erzeugt.
Java-2D und 3D (ab JDK 1.2)
Ab JDK 1.2 gibt es das sogenannte Java-2D-API, also eine Gruppe von Packages und
Klassen, mit denen 2-dimensionale graphische Objekte genauer und bequemer konstruiert
werden: die Klasse Graphics2DObject und eine Reihe von weiteren Klassen
in den Packages java.awt.color, java.awt.geom und java.awt.image. Damit konnen
z.B. Linien mit beliebiger Strichstarke gezeichnet sowie geometrische Figuren um
beliebige Winkel gedreht werden.
Fur die Zukunft wird auch an einer Java-3D-API fur die Darstellung von 3-
dimensionalen Objekten gearbeitet. Genauere Informationen daruber ndet man
auf dem Java-Web-Server (siehe die Referenzen).
Java-Einfuhrung von H. Partl { Kursunterlage 75

Zeichnen in einem Container
Die Klasse Container ist eine Unterklasse von Component, man kann daher die Container
(wie z.B. Frame oder Applet), wenn man will, wie eine einzelne Komponente
behandeln, so wie einen Canvas. Man kann also
entweder mit add einzelne Komponenten zum Container hinzufugen
oder den Inhalt des kompletten Container mit paint selbst festlegen,
aber man sollte diese beiden Moglichkeiten nicht gleichzeitig verwenden, weil sonst
die eine die andere stort.
Wenn man Graphiken und Standard-Komponenten in einem Container haben will,
ist es am besten, wenn man fur die Graphiken eigene Canvas-Komponenten erzeugt,
die die entsprechende paint-Methode enthalten, und dann alle diese Komponenten
mit add zum Container hinzufugt.
Wenn man doch beides kombinieren will, z.B um mit der paint-Methode den Hintegrund
des Containers hinter den Komponenten festzulegen, dann mu man in der
paint-Methode nach dem Zeichnen der Hintergrund-Graphik mit
super.paint(g)
fur das richtige Zeichnen der Komponenten sorgen.
6.11 mehrzeilige Texte
Mit Label und TextField und mit der Graphics-Methode drawString kann jeweils
immer nur eine Textzeile ausgegeben werden. Wenn man will, da ein langerer Text
automatisch je nach dem verfugbaren Platz in mehrere Zeilen umgebrochen wird,
kann man eine TextArea ohne horizontalen Scrollbar verwenden. Beispiel:
TextArea t1 = new TextArea( longString, 5, 20,
TextArea.SCROLLBARS_VERTICAL_ONLY );
Bei JTextArea (Swing) kann man dafur eine eigene Methode setWrap(boolean) verwenden,
unabhangig vom Scrollbar. In Swing bzw. JDK 1.2 gibt es auch noch weitergehende
Moglichkeiten, z.B. fur die formatierte Darstellung von Texten, HTMLoder
RTF-Dokumenten in einer JEditorPane oder JTextPane. Beispiel:
JEditorPane pane = new JEditorPane();
String somehtml = "
Hello
Hello!
Some Java-generated long text
";
pane.setContentPane("text/html");
pane.setText(somehtml);
add(pane);
Java-Einfuhrung von H. Partl { Kursunterlage 76

6.12 Event-Handling
Listener-Interfaces
Graphische User-Interfaces bieten mehrere Moglichkeiten fur Eingaben und sonstige
steuernde Aktivitaten des Benutzers: Er kann eine oder mehrere Tasten auf
der Tastatur drucken, die Maus bewegen, eine Maustaste drucken oder loslassen
oder klicken, und er kann Kombinationen davon ausfuhren. Das Programm kann
nicht vorhersagen, was er wann tun wird, sondern mu darauf warten, welche der
moglichen Aktivitaten er in welchen Komponenten des GUI durchfuhrt, und dann
jeweils darauf reagieren. Diese Reaktion auf vom Benutzer ausgeloste Ereignisse wird
als Event-Handling bezeichnet.
Mit JDK 1.1 wurde eine komplett neue Version des Event-Handling eingefuhrt. Dazu
mu das Package java.awt.event importiert werden. Die alte Version 1.0 des Event-
Handling ist weiterhin im Package java.awt verfugbar und wird vom Compiler nur
mit der Warnung "deprecated" versehen (kein Fehler).
Hier wird die Version 1.1 beschrieben.
Fur die verschiedenen Arten von Ereignissen (Events) sind Interfaces mit Namen
der Form XxxxListener vorgesehen. Zu jeder Komponente, die auf solche Events
reagieren soll (z.B. Mausklicks auf einen Button oder innerhalb eines Canvas), mu
mit addXxxxListener ein Listener-Objekt vereinbart werden, das die Methoden des
jeweiligen Interfaces implementiert und damit die gewunschten Aktionen ausfuhrt.
Beispiel:
...
Button b = new Button("B");
ActionListener ali = new MyListener();
b.addActionListener(ali);
...
public class MyListener implements ActionListener {
public void actionPerformed (ActionEvent e) {
...
}
}
Es gibt zwei Arten von Listenern bzw. Events:
logische Listener, die einfach die durchgefuhrte Aktion beschreiben (z.B. der
ActionListener, der angibt, da ein Button ausgelost oder ein Textfeld ausgefullt
wurde), und
physische Listener, die genau beschreiben, was der Benutzer mit welchem Eingabegerat
getan hat (z.B. der MouseListener, der angibt, an welcher Position
die Maustaste langsam gedruckt oder schnell geklickt wurde).
Die folgenden Interfaces stehen zur Verfugung und besitzen die folgenden Methoden,
die implementiert werden mussen:
ActionListener: actionPerformed
Java-Einfuhrung von H. Partl { Kursunterlage 77

ItemListener: itemStateChanged
TextListener: textValueChanged
AdjustmentListener: adjustmentValueChanged
MouseListener: mousePressed, mouseReleased, mouseEntered, mouse-
Exited, mouseClicked
MouseMotionListener: mouseDragged, mouseMoved
KeyListener: keyPressed, keyReleased, keyTyped
WindowListener: windowClosing, windowClosed, windowOpened, window-
Iconied, windowDeiconied, windowActivated, windowDeactivated
ComponentListener: componentMoved, componentResized, component-
Hidden, componentShown
ContainerListener: componentAdded, componentRemoved
FocusListener: focusGained, focusLost
Event-Klassen
Die Methoden haben jeweils einen Parameter vom Typ XxxxEvent (also Action-
Event, ItemEvent, MouseEvent etc., nur beim MouseMotionListener wird ebenfalls
der MouseEvent verwendet), und diese Objekte haben Methoden, mit denen man
abfragen kann, welcher Button angeklickt wurde, welcher Text in ein Textfeld eingegeben
wurde, an welcher Position die Maustaste gedruckt oder losgelassen wurde,
welche Taste auf der Tastatur gedruckt wurde etc.
Alle Events haben die folgende Methode:
Object getSource()
fur die Komponente, in der das Ereignis ausgelost wurde.
Die wichtigsten weiteren Methoden in den einzelnen Event-Arten sind:
im ActionEvent: getActionCommand() fur den Namen der angeklickten
Komponente (des Button)
im ItemEvent: getItem() fur die Komponente (das ausgewahlte Item)
im TextEvent: getSource() fur die Komponente (das Texteingabefeld)
im AdjustmentEvent: getAdjustable() fur die Komponente (den Scrollbar)
und getValue() fur den eingestellten Wert
im MouseEvent: getX() und getY() fur die Position der Maus, getClick-
Count() fur die Unterscheidung von Einfach- und Doppelklick, isShiftDown(),
isCtrlDown(), isAltDown() fur gleichzeitig festgehaltene Tasten
im KeyEvent: getKeyChar(), getKeyCode(), getKeyText() fur die gedruckte
Taste, isShiftDown(), isCtrlDown(), isAltDown() fur gleichzeitig festgehaltene
Tasten
im WindowEvent: getWindow() fur die Komponente (das Fenster)
Java-Einfuhrung von H. Partl { Kursunterlage 78

im ComponentEvent: getComponent() fur die Komponente
im ContainerEvent: getContainer() fur den Container, getChild() fur die
hinzugefugte oder entfernte Komponente
im FocusEvent: getComponent() fur die Komponente
Wenn diese Methoden "nur" ein Objekt (die Komponente, die das Ereignis ausgelost
hat) liefern, dann kann man in diesem Objekt die genaueren Informationen nden,
z.B. welcher Text im Texteingabefeld steht. Fur die Details wird auf die Online-
Dokumentation (API) verwiesen. Beispiel:
String s = null;
if (e.getSource() instanceof TextField) }
s = ( (TextField)(e.getSource()) ).getText();
}
6.13 Beispiel: typischer Aufbau einer einfachen GUI-Applikation
Bei sehr einfachen GUI-Applikationen kann man alles in einer Klasse denieren, wie
hier skizziert. Bei komplexeren GUI-Applikationen ist es aber besser, die Anwendung
nach den Grundsatzen der objekt-orientierten Programmierung in mehrere kleinere
Klassen aufzuteilen (siehe den nachfolgenden Abschnitt).
import java.awt.* ;
import java.awt.event.* ;
public class TestFrame extends Frame
implements ActionListener, WindowListener {
private Button b1;
// ... more Components ...
public TestFrame (String s) {
super(s);
}
public void init() {
setLayout (new FlowLayout() );
b1 = new Button("Press me! ");
b1.addActionListener (this);
add(b1);
// ... more Components ...
addWindowListener(this);
setSize(300,200); // or: pack();
setVisible(true);
}
public static void main (String[] args) {
TestFrame f = new TestFrame("Test");
f.init();
}
Java-Einfuhrung von H. Partl { Kursunterlage 79

}
public void actionPerformed (ActionEvent e) {
System.out.println("Button was pressed.");
}
public void windowClosing (WindowEvent e) {
dispose();
System.exit(0);
}
public void windowClosed (WindowEvent e) { }
public void windowOpened (WindowEvent e) { }
public void windowIconified (WindowEvent e) { }
public void windowDeiconified (WindowEvent e) { }
public void windowActivated (WindowEvent e) { }
public void windowDeactivated (WindowEvent e) { }
Anmerkungen:
Im Sinn der objekt-orientierten Programmierung erfolgen die wesentlichen Aktionen
nicht direkt in der statischen main-Methode erfolgen sondern in der nicht-statischen
Methode init. Der Name dieser Methode wurde so gewahlt, da eine Umwandlung
der Applikation in ein Applet bei Bedarf leicht moglich ist. Der Aufruf dieser
init-Methode kann entweder, wie oben, explizit in der main-Methode oder, wie im
nachsten Beispiel unten, im Konstruktor erfolgen.
Bei Fenstern (Frames) soll immer ein WindowListener aktiv sein, der das im Fenster
laufende Programm beendet, wenn der Benutzer das Fenster schliet - dies gehort
zum normalen Verhalten von Fenstern in jedem System.
Weitere Beispiele fur typische GUI-Komponenten und Event-Handlung nden Sie
im Kapitel uber Applets:
Button-Aktionen (Button, Label, ActionListener)
Maus-Aktionen (Graphics, MouseListener, MouseMotionListener)
Text-Aktionen (TextField, Label, ActionListener)
Das Event-Handling ist in allen diesen Beispielen der Einfachheit halber mit public
Methoden in den public Klassen realisiert. Wenn man den Zugri auf diese Methoden
von fremden Klassen aus verhindern will, kann man stattdessen sogenannte
"anonyme innere Klassen" verwenden, Beispiele dafur ndet man in den Referenzen.
Java-Einfuhrung von H. Partl { Kursunterlage 80

6.14 Beispiel: typischer Aufbau einer komplexen GUI-Applikation
Applikation
Datenmodell (Model)
Bei sehr einfachen GUI-Applikationen kann man alles in einer Klasse denieren
(siehe oben). Bei komplexeren GUI-Applikationen ist es aber besser, die Anwendung
nach den Grundsatzen der objekt-orientierten Programmierung in mehrere kleinere
Klassen fur die einzelnen Objekte aufzuteilen. In Sinne des MVC-Konzepts (Model,
View, Controller) sollte man zumindest die folgenden Klassen bzw. Gruppen von
Klassen verwenden:
Applikation (main-Methode)
Datenmodell (model)
Ansicht (view)
Steuerung (controller)
Von den vielen Moglichkeiten, wie man das gestalten kann, wird im folgenden eine
Moglichkeit skizziert:
Die Applikation legt zuerst ein Objekt des Datenmodells an und dann ein Objekt
der Ansicht. Die Referenz auf das Datenobjekt wird der Ansicht im Konstruktor
ubergeben. Die init-Methode der Ansicht wird gleich vom Konstruktor ausgefuhrt:
public class XxxApplication {
public static void main (String[] args] {
XxxModel model = new XxxModel();
String title = "Title String";
XxxView view = new XxxView (model, title);
}
}
Das Datenmodell enthalt die Datenfelder, die get- und set-Methoden fur alle Datenfelder,
sowie Berechnungsmethoden, mit denen die Ergebnisse aus den Eingabewerten
berechnet werden:
public class XxxModel {
private type xxx;
...
public void setXxx (type xxx) {
this.xxx = xxx;
}
public type getXxx() {
return xxx;
}
...
}
Java-Einfuhrung von H. Partl { Kursunterlage 81

Ansicht (View)
Die Ansicht baut in der init-Methode das graphische User-Interface auf. Das Eventhandling
wird jedoch nicht von dieser Klasse sondern von einem Objekt der Steuerungsklasse
oder von mehreren solchen Objekten durchgefuhrt. Dem Steuerungsobjekt
werden die Referenzen sowohl auf das Datenobjekt als auch auf die Ansicht
(this) als Parameter ubergeben.
Im Konstruktor der Ansicht wird nicht nur der Title-String des Frame sondern auch
die Referenz auf das Datenobjekt ubergeben. Die Datenfelder konnen dann mit den
get-Methoden des Datenmodells abgefragt und in den GUI-Komponenten graphisch
dargestellt werden.
Fur komplexere Anwendungen ist es eventuell besser, da sich alle View-Klassen
bei der zugehorigen Model-Klasse "registrieren". Eine Skizze dazu nden Sie weiter
unten am Ende dieses Beispiels.
Auerdem wird im Konstruktor auch gleich die init-Methode aufgerufen, die den
Frame komplett aufbaut.
Die Komponenten werden hier nicht als private sondern als protected oder packagefriendly
deklariert, damit sie vom Steuerungsobjekt angesprochen werden konnen.
Die im Beans-Konzept verlangten set- und get-Methoden fehlen in dieser Skizze.
import java.awt.* ;
import java.awt.event.* ;
public class XxxView extends Frame {
private XxxModel model;
private XxxController controller;
protected TextField field1;
protected Label label1;
...
public XxxView (XxxModel m, String s) {
super(s);
this.model = m;
this.init();
}
public void init() {
controller = new XxxController (this, model);
setLayout ( new FlowLayout() );
field1 = new TextField (30);
field1.addActionListener (controller);
add(field1);
label1 = new Label ( model.getYyy() );
add (label1);
...
addWindowListener (controller);
setSize (300, 200);
setVisible (true);
Java-Einfuhrung von H. Partl { Kursunterlage 82

}
}
Steuerung (Controller)
Wenn das GUI aus mehreren Objekten besteht, werden dafur wiederum eigene Klassen
deniert. So werden z.B. fur die graphische Darstellung von Datenfeldern Subklassen
von Canvas (oder dergleichen) verwendet, denen ebenfalls die Referenz auf
das Datenobjekt im Konstruktor ubergeben wird.
Die Steuerungsklasse implementiert die Listener-Interfaces und fuhrt die entsprechenden
Aktionen durch. Sie erhalt im Konstruktor die Referenzen sowohl auf das
Datenobjekt als auch auf das Ansichtobjekt ubergeben und kann dann je nach den
Benutzer-Aktionen die Datenfelder mit den set-Methoden des "Model" setzen und
die Anzeige der Daten und Ergebnisse mit den set- und repaint-Methoden der GUI-
Komponenten im "View" bewirken.
import java.awt.* ;
import java.awt.event.* ;
public class XxxController
implements YyyListener {
private XxxModel model;
private XxxView view;
public XxxController (XxxView v, XxxModel m) {
this.view = v;
this.model = m;
}
}
... // Methoden der Listener-Interfaces
Hier eine Beispielskizze, wie die Aktionen innerhalb der Methoden des Listener-
Interface aussehen konnen:
public void actionPerformed (ActionEvent e) {
Object which = e.getSource();
if (which == view.field1) {
model.setXxx ( view.field1.getText() );
view.label1.setText ( model.getYyy() );
}
...
}
Wenn mehrere, verschiedene Aktionen von verschiedenen GUI-Komponenten ausgelost
werden, dann konnen dafur jeweils eigene Steuerungsklassen deniert und
entsprechend mehrere Steuerungsobjekte angelegt werden.
In dem hier skizzierten Fall mu der Controller "wissen", welche Ansichten (View-
Klassen) welche Daten (Model-Klassen) darstellen. Eine bessere Losung ware es, da
Java-Einfuhrung von H. Partl { Kursunterlage 83

sich alle View-Klassen bei der Model-Klasse registrieren und dann von der Model-
Klasse automatisch benachrichtigt werden, wenn die Daten sich geandert haben und
daher von der View-Klasse neu dargestellt werden mussen. Beispielskizze:
import java.util.*;
public class XxxModel extends Observable {
...
// change some data in the model
setChanged();
notifyObservers (arg);
...
}
import java.util.*;
public class XxxView extends Xxx implements Observer {
XxxModel m;
...
public XxxView (XxxModel m) {
this.m = m;
m.addObserver(this);
}
...
public void update (Observable o, Object arg) {
// show the new data in the view
...
}
...
}
6.15 Ubung: einfache GUI-Applikation
Schreiben Sie eine einfache GUI-Applikation, die ein Fenster mit folgendem Inhalt
anzeigt:
Am oberen Rand soll in der Mitte ein kurzer Text stehen.
Am unteren Rand sollen 2 Buttons nebeneinander zu sehen sein:
{ ein Open-Button, der keine Aktion bewirkt, und
{ ein Close-Button, der die Beendigung der Applikation bewirkt.
Fuhren Sie diese Applikation aus und testen Sie auch, was passiert, wenn Sie das
Fenster vergroern oder verkleinern.
Anmerkung: Diese Ubung stellt gleichzeitig eine Vorarbeit fur die Ubung im Kapitel
Applets dar.
Java-Einfuhrung von H. Partl { Kursunterlage 84

6.16 Swing-Komponenten (JComponent)
In Swing (Java Foundation Classes JFC) stehen als Alternative zu den AWT-
Komponenten die folgenden "light weight" Komponenten zur Verfugung. Sie verwenden
keine Peers vom Betriebssystem, sondern sind komplett in Java deniert.
Man kann das Aussehen und die Funktionalitat (look and feel) fur diese Komponenten
im Java-Programm genau festlegen:
entweder, indem man eines der vorgefertigten Designs auswahlt (z.B. wie bei
Motif oder wie bei Windows)
oder, indem man alle Details selbst festlegt und damit ein produktspezisches
Look-and-Feel erzeugt.
Swing-Komponenten sollten niemals mit Peer-Komponenten gemischt verwendet
werden.
Fur Swing mu das Package javax.swing importiert werden. Dieses Package bzw.
die Java Foundation Classes JFC mussen bei JDK 1.1 zusatzlich installiert werden
und sind ab JDK 1.2 Teil des JDK.
Die Swing-Komponenten werden von den meisten Web-Browsern noch nicht unterstutzt.
Komponenten und Datenmodelle
Die wichtigsten Swing-Kompontenten sind:
JFrame mit ContentPane, fur ein Fenster mit Rahmen (wie Frame)
JPanel, JInternalFrame, JDesktopPane, JLayeredPane, JTabbed-
Pane, JApplet fur einen Bereich (wie Panel bzw. Applet)
JComponent als Oberklasse fur alle Swing-Komponenten und Container,
und fur eine Zeichenache (wie Canvas und Panel)
JLabel fur einen Text oder ein Icon (wie Label)
JButton fur einen Knopf mit Text oder Icon (wie Button)
JCheckbox, JRadioButton, JToggleButton fur einen Schalter (wie
Checkbox)
JList, JComboBox in Verbindung mit einem Vector oder einem ListModel
bzw. ComboBoxModel und ListCellRenderer fur Auswahllisten (wie Choice
bzw. List)
JTextField, JPasswordField, JTextArea in Verbindung mit String oder
Document, fur Text-Eingaben (wie TextField bzw. TextArea)
JDialog, JOptionPane fur Dialogfenster (wie Dialog)
JFileDialog, JFileChooser fur die Auswahl einer Datei (wie FileDialog)
JMenuBar, JMenu, JMenuItem, JCheckboxMenuItem,
Menu, JSeparator fur Menus (wie MenuBar, Menu etc.)
JPopup-
JScrollBar, JScrollPane fur Scrollbars (wie ScrollBar bzw. ScrollPane)
Java-Einfuhrung von H. Partl { Kursunterlage 85

ImageIcon fur ein kleines Bild
JProgressBar fur die graphische Darstellung eines Zahlenwertes
JSlider fur die graphische Eingabe eines Zahlenwertes
JColorChooser fur die Auswahl einer Farbe
JToolBar fur eine Button-Leiste
JToolTip bzw. setToolTipText() fur eine Zusatzinformation zu jeder Komponente
JTable in Verbindung mit TableModel und TableCellRenderer fur die Anordnung
von Komponenten in Tabellenform
JTree in Verbindung mit TreeModel, TreePath, TreeNode und TreeCellRenderer
oder TreeCellEditor sowie TreeSelectionModel und TreeSelectionListener
fur die Darstellung eines hierarchischen Baums von Elementen wie z.B. ein
Directory mit Subdirectories und Files
JEditorPane, JTextPane in Verbindung mit einem String oder einem
InputStream oder Reader oder einem Document wie PlainDocument, Default-
StyledDocument oder HTMLDocument mit HyperlinkListener, und mit einem
EditorKit wie DefaultEditorKit, HTMLEditorKit oder RTFEditorKit, fur die
formatierte Darstellung von Text. Die HTML-Unterstutzung ist dabei nur relativ
einfach, fur "besseres" HTML gibt es, alleridngs nicht kostenlos, eine
HotJava-Bean von der Firma Sun.
Beispielskizze
Hier ein kurze Skizze fur die Verwendung von einfachen Swing-Komponenten. Die
Beschreibung der verwendeten Klassen und Methoden nden Sie in der Online-
Dokumentation von Swing (im JDK ab 1.2).
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class SwingTest {
public static void main (String[] args) {
JFrame f = new JFrame ("Swing Test");
Container inhalt = f.getContentPane();
inhalt.setLayout (new FlowLayout() );
String labText =
"Lautst&auml;rke(volume)" ;
JLabel lab = new JLabel ("" + labText + "");
inhalt.add(lab);
JSlider slid = new JSlider (0, 100, 50);
// slid.addChangeListener ( ... );
slid.setToolTipText("Stellt die Lautstrke ein.");
Java-Einfuhrung von H. Partl { Kursunterlage 86

inhalt.add(slid);
ImageIcon stopIcon = new ImageIcon ("images/stop.gif");
JButton but = new JButton ( "Stop", stopIcon );
// but.addActionListener ( ... );
but.setToolTipText("Stoppt das Abspielen.");
inhalt.add(but);
}
}
f.setDefaultCloseOperation (JFrame.DISPOSE_ON_CLOSE);
f.setSize(400,150);
f.setVisible(true);
Model, View, Controller
Die Swing-Klassen unterstutzen das Prinzip von Model, View und Controller.
Zu den sichtbaren Komponenten (View) gibt es jeweils geeignete Datenobjekte (Model,
siehe die Hinweise in der obigen Klassenliste).
Die Verbindung vom View zum Controller erfolgt wie beim AWT durch das Event-
Handling mit den add-Listener-Methoden.
Der Controller mu nur die Daten im Model-Objekt verandern (set-Methoden).
Die Verbindung zwischen Model und View erfolgt automatisch nach dem Konzept
von Observer und Observable. Dafur mu man nur im Konstruktor des View-Objekts
das entsprechende Model-Objekt angeben. Die Registrierung des View als Observer
des Model (addObserver) wird vom Konstruktor erledigt, und das automatische Update
der Daten-Darstellung im View (notifyObservers) wird von den set-Methoden
des Model erledigt.
Wie die Darstellung der Daten im View aussehen soll, wird mit Renderern festgelegt.
Beispiel:
Die Klasse JTree ist eine Komponente, mit der bestimmte Informationen (Knoten
und Blatter) am Bildschirm in einer Baum-Struktur sichtbar gemacht werden
sollen.
Die im JTree dargestellten Informationen (Model) werden mit einem TreeModel
beschrieben, das aus TreePaths und TreeNodes besteht. Fur die meisten
Anwendungsfalle kann man die Klassen DefaultTreeModel und DefaultMutableTreeNode
verwenden.
Die Darstellung von TreeNodes im JTree (View) erfolgt mit einem TreeCell-
Renderer.
Die Steuerung der Aktionen, die der Benutzer mit dem JTree durchfuhrt (Controller),
z.B. durch Auswahl oder Doppelklick auf Elemente darin, erfolgt mit
dem in diesen Klassen vorgesehenen Event-Handling. Auerdem generieren
die Methoden des TreeModel eigene Events, die dafur sorgen, da sich die
Darstellung im JTree andert, wenn sich die Daten im TreeModel andern.
Java-Einfuhrung von H. Partl { Kursunterlage 87

Analoges gilt fur andere Komponenten wie JList, JTable usw.
Fur genauere Informationen uber die Swing-Klassen fur Komponenten, Models, Renderer,
Events, LookAndFeels etc. und uber die Konstruktoren und Methoden dieser
Klassen wird auf die Online-Dokumentation (API) und auf die Referenzen verwiesen.
Java-Einfuhrung von H. Partl { Kursunterlage 88

7. Applets
Applet = Panel innerhalb einer Web-Page
lauft innerhalb des Web-Browsers
Java-Applets werden innerhalb einer Web-Page dargestellt und unter der Kontrolle
eines Web-Browsers ausgefuhrt.
Technisch gesehen zeichnen sich Java-Applets dadurch aus, da sie Unterklassen
der Klasse Applet sind. Die Klasse Applet ist ihrerseits eine Unterklasse von Panel.
Applets sind also Panels, die innerhalb des Browser-Fensters (das eine Art von Frame
ist) dargestellt werden.
Ausgaben auf System.out oder System.err werden bei Web-Browsern in einem eigenen
Bereich, der "Java-Console", ausgegeben, der den Benutzern meist nur auf Umwegen
zuganglich ist; beim Appletviewer erscheinen sie in dem Terminal-Fenster, in
dem der Appletviewer aufgerufen wird. Dies eignet sich also nur fur Test-Meldungen,
aber nicht fur die normale Interaktion mit dem Benutzer. Diese sollte ausschlielich
uber die graphische Benutzungsoberache (GUI) des Applet erfolgen.
Bei der Deklaration von Applets mussen die Packages java.applet sowie java.awt
und java.awt.event importiert werden.
7.1 Sicherheit (security, sandbox, signed applets)
Applets werden meist uber das Internet von einem Server geladen, und spezielle
Sicherungen innerhalb des Web-Browser ("Sandkasten", sandbox) sorgen dafur, da
sie keine unerwunschten Wirkungen auf den Client-Rechner haben konnen.
So konnen Applets im allgemeinen
nicht auf lokale Files zugreifen,
nicht auf Systemkomponenten oder andere Programme zugreifen,
keine Befehle oder Programme am Client starten,
keine Internet-Verbindungen aufbauen auer zu dem einen Server, von dem
das Applet geladen wurde.
Bei signierten und zertizierten Applets (signed Applets) kann der Benutzer, wenn er
sie fur vertrauenswurdig halt, auch Ausnahmen von den strengen Sicherheitsregeln
zulassen. Er kann z.B. vereinbaren, da ein bestimmtes Applet auf ein bestimmtes
File oder ein bestimmtes Subdirectory seiner Harddisk zugreifen darf (nur lesend,
oder lesend und schreibend), oder da ein anderes Applet E-Mail an fremde Internet-
Rechner senden darf.
Wie man die Applets bzw. ein Archiv-File, in dem sie gespeichert sind, mit einer
verschlusselten Unterschrift (Signatur) versieht, wie man diesen Schlussel von einer
Java-Einfuhrung von H. Partl { Kursunterlage 89

vertrauenswurdigen Person oder Institution beglaubigen (zertizieren) lat, und wie
das Applet dann den Benutzer bittet, da dieser die Erlaubnis fur die normalerweise
verbotenen Aktionen erteilt, mu leider fur jeden Web-Browser anders gemacht werden.
Genauere Informationen uber die Version von Sun (javakey) ndet man in der
Online-Dokumentation von Java, die Informationen fur die Versionen von Netscape
und Microsoft ndet man auf den Web-Servern dieser Firmen.
Fur die Zertizierung von Applets innerhalb eines kleinen Benutzerkreises wie z.B.
innerhalb des Intranet einer Firma braucht man keine weltweite Zertizierung, sondern
es genugt eine Gruppen- bzw. Firmen-interne Beglaubigung der Signatur durch
eine personlich bekannte vertrauenswurdige Person.
Beim Testen von Applets in einem lokalen HTML-File mit dem Appletviewer sind
nicht alle diese Einschrankungen aktiv. Zum Testen der Security-Einschrankungen
empehlt sich die Angabe eines URL im Appletviewer oder die Verwendung eines
Web-Browsers.
7.2 HTML-Tags
Innerhalb der Web-Page werden Applets mit dem HTML-Tag eingefugt
und aufgerufen. Dies erfolgt nach dem folgenden Schema:
Text
Im Applet-Tag mu mit dem Parameter code der Name des Java-Applet angegeben
werden (Class-File mit dem plattformunabhangigen Bytecode), und mit width und
height die Breite und Hohe des Applet in Pixels.
In diesem Fall mu sich das Class-File im selben Directory am selben Server wie das
HTML-File benden. Wenn dies nicht der Fall ist, mu man mit einem zusatzlichen
Parameter codebase den URL des Directory angeben, aus dem das Class-File geladen
werden soll. Der URL (Uniform Resource Locator) gibt im allgemeinen das
Protokoll, die Internet-Adresse des Servers und den Namen des Directory innerhalb
des Servers an. Dieses Directory ist dann auch das Package, aus dem eventuell weitere
Klassen geladen werden, und dieser Server ist derjenige, auf den das Applet
uber das Internet zugreifen darf. Beispiel:
Falls das Class-File kein einzelnes File ist sondern in einem komprimierten Archiv
(ZIP- oder JAR-File) enthalten ist, ist der Name dieses Archiv-Files mit dem Parameter
archive anzugeben:
Mit einem oder mehreren Param-Tags konnen Parameter an das Applet ubergeben
werden, die innerhalb des Applet mit der Methode getParameter abgefragt werden
konnen. Ein Beispiel dafur folgt im Kapitel uber Parameter.
Java-Einfuhrung von H. Partl { Kursunterlage 90

Der (abgesehen von den Param-Tags) zwischen und stehende
Text wird von den Browser-Versionen, die Java nicht unterstutzen, an Stelle des
Java-Applet dargestellt. Dies kann beliebig formatierter HTML-Text sein, also z.B.
auch Bilder enthalten.
In der neuen HTML-Norm HTML 4.0 ist vorgesehen, da statt dem Tag
der Tag verwendet werden soll. Dies wird aber von dem meisten Browsern
noch nicht unterstutzt.
Ausfuhrlichere Informationen uber Web-Pages und die Hypertext Markup Language
HTML nden Sie in der HTML-Einfuhrung und in den Referenzen.
Java Plug-in
Als Alternative zu den in die Web-Browser integrierten Java Virtual Machines, die
die neueste Java-Version meist noch nicht oder nur unvollstandig unterstutzen, bietet
die Firma Sun ein "Java Plug-in" an (auch Java Activator genannt), das von den
Benutzern kostenlos in den Internet-Explorer oder in den Netscape-Navigator unter
MS-Windows oder Sun Solaris oder HP-UX eingebaut werden kann und dann die
jeweils neueste Version des JDK voll unterstutzt. Bei Netscape Version 6, iPlanet
und Mozilla ist dies sogar der Standard.
Dazu genugt allerdings nicht die Installation der entsprechenden Software am Client,
sondern es mu auch das HTML-File am Web-Server verandert werden: Je nach
der Browser-Version mu der Aufruf des Applet in diesem Fall nicht mit
sondern mit oder erfolgen. Wenn man als Autor einer Web-Page
erreichen will, da die Web-Page mit allen Web-Browsern funktioniert, mu man
dafur eine geeignete Kombination der HTML-Befehle , und
angeben. Genauere Informationen daruber nden Sie on-line an der Adresse
http://java.sun.com/products/plugin/
7.3 Beispiel: einfaches HelloWorld Applet
Um einen ersten Eindruck zu geben, wie ein Applet aussieht, hier das Gegenstuck
zur primitiven Hello-World-Applikation aus dem ersten Teil dieser Kursunterlage.
Eine Erklarung der darin vorkommenden Methoden folgt weiter unten.
Applet (Java-Source)
import java.awt.*;
import java.applet.*;
public class HelloApp extends Applet {
}
private String s = "Hello World!";
public void paint (Graphics g) {
g.drawString (s, 25, 25);
}
Dieses Java-Programm mu in einem File mit dem Filenamen HelloApp.java stehen.
Java-Einfuhrung von H. Partl { Kursunterlage 91

Web-Page (HTML-File)
Ein einfaches HTML-File, das dieses Applet enthalt, konnte so aussehen:
Example
Example
Hello World!
Fur Tests mit dem Appletviewer genugt die folgende Minimalversion:
Wenn dieses HTML-File den Filenamen hello.html hat, dann erfolgen Compilation
und Ausfuhrung des Applet mit den folgenden Befehlen:
javac HelloApp.java
appletviewer hello.html
Wenn Sie sehen wollen, wie das Applet funktioniert, probieren Sie es in Ihrem Browser
aus (falls er das kann).
7.4 Ubung: einfaches HelloWorld Applet
Schreiben Sie das oben angefuhrte HelloWorld-Applet (oder eine Variante davon mit
einem anderen Text) und ein entsprechendes HTML-File, ubersetzen Sie das Applet
und rufen es mit dem Appletviewer auf.
Falls Sie einen Java-fahigen Web-Browser zur Verfugung haben, probieren Sie auch
aus, ob dieser Ihr Applet richtig verarbeiten kann.
Java-Einfuhrung von H. Partl { Kursunterlage 92

7.5 Methoden init, start, stop
7.6 Groenangabe
Analog zur main-Methode von Applikationen werden in Applets die folgenden Methoden
automatisch ausgefuhrt:
public void init()
public void start()
public void stop()
Die Methode init wird ausgefuhrt, wenn die Web-Page und das Applet geladen
werden.
Die Methode start wird immer dann ausgefuhrt, wenn die Web-Page mit dem Applet
im Browser sichtbar gemacht wird, also sowohl beim ersten Laden als auch bei
jeder Ruckkehr in die Seite (z.B. mit dem Back-Button des Browsers, wenn man
inzwischen eine andere Web-Page angesehen hat).
Die Methode stop wird immer dann ausgefuhrt, wenn die Web-Page verlassen wird,
also beim Anklicken einer anderen Web-Page oder beim Beenden des Web-Browsers.
Im allgemeinen gibt man in der init-Methode alles an, was zur Vorbereitung des
Applet und zum Aufbau der graphischen Benutzungsoberache (GUI) dient. In
der start-Methode werden dann eventuelle Aktionen wie z.B. selbstandig laufende
Threads gestartet. In der stop-Methode mussen diese Aktionen (Threads und dergleichen)
gestoppt werden.
Da das Laden und Starten des Applet ohnehin immer eine langere Wartezeit mit sich
bringt, wird empfohlen, alle wahrend der Interaktion mit dem Benutzer benotigten
weiteren Klassen sowie Bilder, Tone, Datenles etc. so weit wie moglich und sinnvoll
schon bei der Initialisierung des Applet uber das Internet zu laden (also in der init-
Methode), damit die interaktive Arbeit mit dem Benutzer dann zugig ablaufen kann
und nicht durch neuerliche Wartezeiten fur das nachtragliche Laden solcher Files
verzogert bzw. unterbrochen wird.
Die Groe des Applet wird nicht innerhalb des Applet mit setSize, getPreferred-
Size oder dergleichen angegeben, sondern mit den Parametern width und height im
Applet-Tag im HTML-File.
In den width- und height-Parametern von konnen nicht nur Pixel-Angaben
sondern auch Prozent-Angaben stehen, dann kann der Benutzer die Groe des Applet
verandern.
Innerhalb des Java-Programms kann man die aktuelle Groe des Applet mit der
Methode getSize() abfragen.
Java-Einfuhrung von H. Partl { Kursunterlage 93

7.7 Beenden des Applet
Bei Applikationen mit graphischen User-Interfaces ist meist ein Close- oder Exit-
Button notwendig, um die Applikation zu beenden.
Bei Applets ist ein Close- oder Exit-Button im allgemeinen nicht sinnvoll. Das Applet
wird vom Benutzer einfach dadurch beendet, da er die Web-Page verlat oder
den Web-Browser (mit Close oder Exit in seinem File-Menu) beendet.
In Applets soll daher auch kein System.exit ausgefuhrt werden, d.h. das Applet
darf den Web-Browser nicht "abschieen".
7.8 Beispiel: typischer Aufbau eines Applet mit Button-Aktionen
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class ButtonTest extends Applet
implements ActionListener {
}
private Button b1, b2;
private Label mess;
public void init() {
setLayout (new FlowLayout() );
b1 = new Button("B1");
b1.addActionListener (this);
add(b1);
b2 = new Button("B2");
b2.addActionListener (this);
add(b2);
mess = new Label("Nothing was pressed.");
add(mess);
setVisible(true);
}
public void actionPerformed (ActionEvent e) {
String s = e.getActionCommand();
if (s.equals("B1")) {
mess.setText("The first button was pressed.");
}
else
if (s.equals("B2")) {
mess.setText("The second button was pressed.");
}
this.validate();
}
Java-Einfuhrung von H. Partl { Kursunterlage 94

Hier das zugehorige minimale HTML-File, mit der Angabe der Groe des Applet:
Wenn Sie wissen wollen, was dieses Applet tut, probieren Sie es einfach aus (in Ihrem
Browser, wenn er das kann, oder Abschreibubung oder Download).
7.9 Beispiel: typischer Aufbau eines Applet mit Maus-Aktionen
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class MouseTest extends Applet
implements MouseListener, MouseMotionListener {
private int mouseX, mouseY;
private int radius, diameter = 20;
private Color circleColor = Color.red;
public void init() {
Dimension full = getSize();
mouseX = full.width/2;
mouseY = full.height/2;
radius=diameter/2;
addMouseListener(this);
addMouseMotionListener(this);
}
public void paint (Graphics g) {
g.setColor (circleColor);
g.fillOval ((mouseX-radius), (mouseY-radius),
diameter, diameter);
}
public void mousePressed (MouseEvent e) {
mouseX = e.getX();
mouseY = e.getY();
circleColor = Color.green;
repaint();
}
public void mouseReleased (MouseEvent e) {
mouseX = e.getX();
mouseY = e.getY();
circleColor = Color.red;
repaint();
}
Java-Einfuhrung von H. Partl { Kursunterlage 95

public void mouseClicked (MouseEvent e) { }
public void mouseEntered (MouseEvent e) { }
public void mouseExited (MouseEvent e) { }
public void mouseDragged (MouseEvent e) {
mouseX = e.getX();
mouseY = e.getY();
circleColor = Color.green;
repaint();
}
public void mouseMoved (MouseEvent e) { }
}
Wenn Sie wissen wollen, was dieses Applet tut, probieren Sie es einfach aus (in Ihrem
Browser, wenn er das kann, oder Abschreibubung oder Download).
7.10 Beispiel: typischer Aufbau eines Applet mit Text-Eingaben
import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class TextTest extends Applet
implements ActionListener {
private TextField field1, field2;
public void init() {
setLayout (new FlowLayout() );
field1 = new TextField("", 30);
field1.addActionListener(this);
add(field1);
field2 = new TextField("", 30);
field2.addActionListener(this);
add(field2);
Label helpText = new Label ("Enter text and hit return.");
add(helpText);
setVisible(true);
}
public void actionPerformed (ActionEvent e) {
String s = null;
Object which = e.getSource();
if (which==field1) {
s = field1.getText();
field2.setText(s);
field1.setText("");
}
Java-Einfuhrung von H. Partl { Kursunterlage 96

}
}
else
if (which==field2) {
s = field2.getText();
field1.setText(s);
field2.setText("");
}
Wenn Sie wissen wollen, was dieses Applet tut, probieren Sie es einfach aus (in Ihrem
Browser, wenn er das kann, oder Abschreibubung oder Download).
7.11 Ubung: einfaches Applet Thermostat
Schreiben Sie ein Applet, das folgende Daten und Steuerelemente darstellt und die
folgenden Aktionen ausfuhrt:
Im oberen Teil soll in der Mitte die Temperatur angezeigt werden.
Im unteren Teil sollen 2 Buttons nebeneinander zu sehen sein, die den Wert
der Temperatur um 1 verringern oder erhohen.
Als Erweiterung konnen Sie die Anzeige farbig gestalten, und zwar je nach dem
erreichten Temperaturbereich in verschiedenen Farben.
Wenn Sie sehen wollen, wie das aussehen konnte, probieren Sie es in Ihrem Browser
aus (falls er das kann).
Fur das Grundgerust dieses Applet konnen Sie Teile der Ubung aus dem Kapitel
uber Graphical User-Interfaces verwenden.
Fuhren Sie dieses Applet mit einem minimalen HTML-File im Appletviewer aus
und testen Sie auch, was passiert, wenn Sie das Fenster vergroern oder verkleinern.
Falls Ihnen dieses Beispiel zu einfach ist und Sie mehr Zeit investieren wollen, konnen
Sie auch eines oder mehrere der folgenden, aufwendigeren Beispiele ausprobieren.
Java-Einfuhrung von H. Partl { Kursunterlage 97

7.12 Ubung: Applet einfache Verkehrsampel
Schreiben Sie ein Applet, das folgende Elemente darstellt und folgende Aktionen
ausfuhrt:
Am oberen Rand soll in der Mitte der Text "Trac Light Exercise" stehen.
Im mittleren Bereich soll ein einfaches rechteckiges Bild einer Verkehrsampel
zu sehen sein, ein schwarzes Rechteck mit bunten Kreisen, reihum in jeweils
einem der folgenden 4 Zustande:
1. rot
2. rot + gelb
3. grun
4. gelb
(Auf grunes oder gelbes Blinklicht verzichten wir in dieser Ubung, siehe die
Ubung im Kapitel uber Threads)
Am unteren Rand sollen 2 Buttons zu sehen sein:
{ ein Next-Button, der ein Weiterspringen der Verkehrsampel auf den jeweils
nachsten Zustand bewirkt, und
{ ein Stop-Button, der die Ampel auf rot stellt.
Wenn Sie sehen wollen, wie das aussehen konnte, probieren Sie es in Ihrem Browser
aus (falls er das kann).
Fuhren Sie dieses Applet mit einem minimalen HTML-File im Appletviewer aus
und testen Sie auch, was passiert, wenn Sie das Fenster vergroern oder verkleinern.
Java-Einfuhrung von H. Partl { Kursunterlage 98

7.13 Ubung: komplexes Applet Sparbuch
Erweitern Sie das einfache Rechenbeispiel Sparbuch aus dem Kapitel Syntax und
Statements bzw. dessen Erweiterung aus dem Kapitel Exceptions zu einem Applet
mit graphischem User-Interface.
Uberlegen Sie zunachst die zu Grunde liegenden Daten (Model): Geldbetrag, Zinssatz,
und der Wert in jedem Jahr.
Uberlegen Sie dann die graphische Darstellung (View):
Oben sollen Eingabefelder fur Geldbetrag und Zinssatz sowie Textbereiche fur
Erklarungen und Fehlermeldungen vorhanden sein.
Unten soll eine Ubersicht uber die Wertentwicklung in den 10 Jahren sowohl
in Form einer Tabelle (Zahlenangaben) als auch in Form eines Diagramms
(graphisch) erscheinen.
Uberlegen Sie schlielich die Steuerung (Controller): Wenn der Benutzer einen
neuen Geldbetrag oder Zinssatz eingibt, sollen sofort die entsprechenden Werte sichtbar
werden (oder eine Fehlermeldung, wenn die Eingabe ungultig war).
Wenn Sie sehen wollen, wie das aussehen konnte, probieren Sie es in Ihrem Browser
aus (falls er das kann).
Fuhren Sie dieses Applet mit einem minimalen HTML-File im Appletviewer aus
und testen Sie auch, was passiert, wenn Sie das Fenster vergroern oder verkleinern.
7.14 Ubung: komplexes Applet: Baume im Garten
Uberlegen, entwerfen und schreiben Sie ein Applet, das folgende Elemente darstellt
und folgende Aktionen ausfuhrt:
Am oberen Rand soll in der Mitte eine Uberschrift stehen.
Im linken Hauptbereich soll der Grundri eines Gartens zu sehen sein, zunachst
ohne Baume, dann mit Kreisen fur die gepanzten Baume. Mit Mausklicks
oder Mausdrags kann der Benutzer hier Stellen fur das geplante Panzen eines
Baumes auswahlen.
Im rechten Hauptbereich soll ein einfaches buntes Bild des Gartens im Aufri
zu sehen sein, mit allen gepanzten Baumen.
Der untere Bereich soll aus einem Textbereich und einem Buttonbereich bestehen.
Der Textbereich soll kurze Texte (Anleitungen, Hinweise und Fehlermeldungen)
fur die Benutzerfuhrung enthalten, je nach den Aktionen des Benutzers.
Darunter sollen 3 Buttons zu sehen sein:
{ ein Okay-Button, der den Baum an der vom Benutzer ausgewahlten Stelle
panzt, wenn es eine erlaubte Stelle war.
{ ein Undo-Button, mit dem der gerade geplante bzw. der zuletzt gepanzte
Baum entfernt wird (bei mehrmaliger Verwendung bis zum Anfangszustand
zuruck).
Java-Einfuhrung von H. Partl { Kursunterlage 99

{ ein Empty-Button, der den Anfangszustand (Garten ohne Baume) wieder
herstellt.
Fuhren Sie dieses Applet mit einem minimalen HTML-File im Appletviewer aus
und testen Sie alle vorgesehenen Aktionen.
Wenn Sie sehen wollen, wie das aussehen konnte, probieren Sie es in Ihrem Browser
aus (falls er das kann).
7.15 Vermeidung von Flimmern oder Flackern (buered image)
Wenn die paint-Methode eine langere Rechnerzeit benotigt, kann beim Aufruf der
repaint-Methode ein storendes Flimmern oder Flackern entstehen. Dies hat folgende
Grunde:
Die repaint-Methode ruft intern die update-Methode auf. Diese loscht zunachst den
bisherigen Inhalt der Komponente (clear screen), indem sie die Flache mit der Hintergrundfarbe
fullt, und ruft dann die paint-Methode auf, die die Graphik-Ausgabe
bewirkt. Wenn der ganze Vorgang langer als etwa 1/20 Sekunde betragt, wird er als
Flimmern oder Flackern wahrgenommen.
Dieses storende Flimmern oder Flackern kann auf die folgende Weise vermieden
werden:
1. Man macht die zeitaufwendige Berechnung des neuen Bildes nicht in der paint-
Methode sondern in einer eigenen Methode in einem eigenen Image-Objekt
(Puerbild, buered image), und deniert die paint-Methode so, da sie nur
das fertig aufbereitete Bild ausgibt.
2. Man deniert die update-Methode so, da sie nur die paint-Methode aufruft,
ohne vorheriges Clear-Screen, das in diesem Fall auch nicht notig ware, weil
von der paint-Methode ohnehin die gesamte Flache neu gezeichnet wird.
Dies erfolgt nach dem folgenden Schema:
In der Klasse (die im allgemeinen eine Subklasse von Canvas oder Applet ist) werden
globale Datenfelder fur das Puerbild und die darin enthaltene Graphik angelegt:
private Image img;
private Graphics g;
In der init-Methode werden die Bild- und Graphik-Objekte mit der richtigen Groe
angelegt:
Dimension d = getSize();
img = createImage (d.width, d.height);
g = img.getGraphics();
Das globale Graphik-Objekt kann nun in beliebigen Methoden der Klasse bearbeitet
werden, und mit repaint kann dann die Ausgabe bewirkt werden:
g.setColor (...);
g.draw... (...);
g.fill... (...);
repaint();
Java-Einfuhrung von H. Partl { Kursunterlage 100

Die paint-Methode wird so deniert, da sie nur das globale Puerbild in ihren
Graphik-Parameter ausgibt, und zwar in diesem Fall ohne Image-Observer (null als
4. Parameter):
public void paint (Graphics g) {
if (img != null)
g.drawImage (img, 0, 0, null);
}
Die update-Methode wird so deniert, da sie nur die paint-Methode aufruft:
public void update (Graphics g) {
paint(g); // no clear
}
7.16 Uniform Resource Locators (URL)
Die Klasse URL im Paket java.net beschreibt Netz-Adressen (Uniform Resource
Locator). Applets konnen im allgemeinen nur Files und Directories auf dem Server
ansprechen, vom dem sie geladen wurden. Zu diesem Zweck konnen die folgenden
Methoden verwendet werden:
URL getCodeBase()
fur die Adresse bzw. das Directory, aus dem das Applet (Class-File) geladen
wurde. Dies ist das Package, aus dem eventuell andere Klassen geladen werden,
und dies gibt den Server an, den das Applet uber das Internet ansprechen darf.
URL getDocumentBase()
fur die Adresse bzw. das Directory, aus dem die Web-Page (das HTML-File),
die das Applet enthalt, geladen wurde. Dies kann ein anderes Directory oder
ein anderer Server als bei getCodeBase sein.
Wie man ein Daten- oder Text-File vom Web-Server lesen kann, wird im Kapitel
uber Ein-Ausgabe beschrieben. Hier folgen Hinweise zum Laden von Bildern und
Tonen und dergleichen vom Web-Server.
Java-Einfuhrung von H. Partl { Kursunterlage 101

7.17 Bilder (Image, MediaTracker)
Bilder konnen mit getImage vom Web-Server geladen und dann mit drawImage im
Applet oder in einem Canvas innerhalb des Applet dargestellt werden. Die allgemeinen
unterstutzten Bildformate sind GIF und JPEG.
Methode im Applet-Objekt:
Image getImage (URL directory, URL filename)
Methoden im Image-Objekt:
int getWidth(this)
int getHeight(this)
Methode im Graphics-Objekt:
drawImage (Image, int x1, int y1, this)
Beispielskizze:
Image logo;
public void init() {
logo = getImage( getDocumentBase(), "logo.gif");
}
public void paint (Graphics g) {
if (logo != null)
g.drawImage (logo, 25, 25, null);
}
Die Methode getImage startet nur das Laden des Bildes. Der Ladevorgang uber
das Internet kann langere Zeit dauern. Wenn man abwarten will, bis der Ladevorgang
erfolgreich abgeschlossen ist, mu man ein Objekt der Klasse MediaTracker
verwenden.
Dies ist zum Beispiel dann notwendig, wenn man mit getWidth und getHeight die
Groe des Bildes abfragen will, denn diese Werte sind erst dann verfugbar, wenn
das Bild fertig geladen wurde.
Beispiel:
Image img;
int imgWidth, imgHeight;
public void init() {
MediaTracker mt = new MediaTracker(this);
img = getImage( getDocumentBase(), "img.jpg");
mt.addImage (img, 0);
try {
mt.waitForID(0);
imgWidth = img.getWidth(this);
imgHeight = img.getHeight(this);
...
} catch (InterruptedException e) {
Java-Einfuhrung von H. Partl { Kursunterlage 102

}
System.out.println("Image not loaded.");
}
In Applikationen kann man Bilder analog mit
x.getToolkit().getImage(...)
(wobei x irgendeine AWT-Komponenente ist) oder mit
Toolkit.getDefaultToolkit().getImage(...)
laden.
7.18 Tone (sound, AudioClip)
Tone (Audio-Clips) konnen mit getAudioClip vom Web-Server geladen und mit
den Methoden play, loop und stop abgespielt werden. Bis JDK 1.1 wird nur das
Audio-Clip-Format (File-Extension .au) unterstutzt, ab JDK 1.2 auch andere Audio-
Formate wie MIDI und WAV und auch Video-Clips (Java Media Framewortk JMF).
Methode im Applet-Objekt:
AudioClip getAudioClip (URL directory, URL filename)
Methoden im AudioClip-Objekt:
play()
loop()
stop()
Beispielskizze fur ein einmaliges Abspielen beim Starten des Applet:
AudioClip sayHello;
public void init() {
sayHello = getAudioClip( getDocumentBase(), "hello.au");
sayHello.play();
}
Beispielskizze fur eine standige Wiederholung bis zum Verlassen des Applet:
AudioClip music;
public void init() {
music = getAudioClip( getDocumentBase(), "music.au");
}
public void start() {
music.loop();
}
public void stop() {
music.stop();
}
Fur das Abspielen von AudioClips "im Hintergrund" zugleich mit anderen Aktionen
verwendet man eigene Threads.
Java-Einfuhrung von H. Partl { Kursunterlage 103

7.19 Parameter
Ahnlich wie die Laufzeit-Parameter beim Starten einer Applikation mit java, konnen
mit dem -Tag in der Web-Page Parameter an das Applet ubergeben werden.
Jeder Parameter hat einen Namen und einen Wert:
Innerhalb des Applet konnen die Parameter mit der Methode getParameter abgefragt
werden. Die in HTML-Tags angegebenen Werte sind immer Strings. Die Umwandlung
von Ziernfolgen in Zahlen etc. mu innerhalb des Java-Applet erfolgen.
Bei Namen in HTML-Tags wird meist nicht zwischen Gro- und Kleinbuchstaben
unterschieden, es wird daher empfohlen, die Namen nur mit Kleinbuchstaben zu
vereinbaren.
Beispiel:
import java.applet.*;
public class ParamTest extends Applet {
String firstname = null;
int age = 0;
public void init() {
try {
firstname = getParameter ("firstname");
String ageString = getParameter ("age");
age = Integer.parseInt(ageString);
} catch (Exception e) {
}
if (age < 18) {
System.out.println(name + ", you are too young!");
}
... // do something
}
}
Java-Einfuhrung von H. Partl { Kursunterlage 104

7.20 Web-Browser
AppletContext
Web-Pages, Mail, News
Der Web-Browser, der das Applet geladen hat und darstellt, kann mit der Methode
getAppletContext verfugbar gemacht werden. Dann kann man mit getApplets und
getApplet auf die anderen, in derselben Web-Page enthaltenen Applets zugreifen,
oder den Web-Browser mit der Methode showDocument bitten, eine andere Web-
Page zu laden und darzustellen.
Methode im Applet-Objekt:
AppletContext getAppletContext()
Methoden im AppletContext-Objekt:
Enumeration getApplets()
Applet getApplet (String appletName)
showDocument (URL)
showDocument (URL, String target)
Wenn showDocument mit nur einem Parameter aufgerufen wird, wird die aktuelle
Web-Page (die das Applet enthalt) durch eine neue Web-Page ersetzt.
Wenn showDocument mit zwei Parametern aufgerufen wird, wird die neue Web-
Page in dem angegebenen Target-Frame dargestellt. Dies eignet sich z.B. fur die
Darstellung von Hilfe-Texten zum Applet in einem eigenen Frame (oder Browser-
Fenster) mit dem Targetnamen "help".
Wenn der URL nicht mit http: oder ftp: sondern mit mailto: oder news: beginnt,
wird das Mail- bzw. News-Fenster des Web-Browsers mit der angegebenen Mail-
Adresse bzw. Newsgruppe geonet, und der Benutzer kann eine E-Mail absenden
bzw. eine Newsgruppe lesen.
Im allen Fallen hangt es vom Web-Browser ab, ob und wie er das alles unterstutzt.
Beispielskizze:
URL newPage = null;
AppletContext browser = getAppletContext();
try {
newPage = new URL (getDocumentBase(), "xxx.html");
browser.showDocument (newPage);
} catch (Exception e {
}
Zugri auf andere Applets
Wenn die Web-Page mehrere Applets enthalt, etwa in der Form
Java-Einfuhrung von H. Partl { Kursunterlage 105

Zugri auf JavaScript
...
dann kann man innerhalb des Applet a1 nach folgendem Schema auf Felder xxxx
und Methoden yyyy das Applet a2 zugreifen:
AppletContext browser = getAppletContext();
Applet2 otherApplet = (Applet2) browser.getApplet("a2");
x = otherApplet.xxxx;
otherApplet.yyyy();
otherApplet.xxxx.yyyy();
In dieser Skizze fehlt noch die Fehlerbehandlung, z.B. ob das andere Applet in der
Web-Page gefunden wurde.
Wenn ein Web-Browser sowohl Java als auch JavaScript unterstutzt, dann kann
man auch zwischen Java-Applets und JavaScript-Scripts Daten und Informationen
austauschen:
Innerhalb von JavaScript kann man public Methoden und Felder von Java-Applets
in der Form
document.appletname.feldname
bzw.
document.appletname.methodenaufruf
ansprechen.
Innerhalb von Java-Applets kann man JavaScript-Funktionen aufrufen, wenn man
die Klasse JSObject aus dem Package netscape.javascript (von Netscape) verwendet
und im -Tag den Parameter mayscript angibt. Beispielskizze:
import netscape.javascript.*;
...
String[] somehtml = {
"Hello!",
"Some Java-generated hypertext ..."
};
JSObject w = JSObject.getWindow(this);
w.eval("w1 = window.open ('','windowname','')");
w.call("w1.document.write", somehtml);
w.eval("w1.document.close()");
Achtung! JavaScript wird nicht von allen Web-Browsern unterstutzt, und viele Benutzer
haben JavaScript wegen des damit verbundenen Sicherheitsrisikos in ihren
Browser-Optionen ausgeschaltet. JavaScript eignet sich daher nicht fur allgemein
verwendbare Applets uber das Internet sondern nur fur Spezialfalle innerhalb eines
Intranet.
Java-Einfuhrung von H. Partl { Kursunterlage 106

7.21 Ubung: Zwei Applets
Schreiben Sie eine Web-Page mit zwei Applets:
ein Resultat-Applet, das einen Text anzeigt, und
ein Steuerungs-Applet, in dem der Benutzer einen Text eingibt, der dann im
anderen Applet angezeigt wird.
7.22 Applet-Dokumentation
Um den Benutzern die richtige Verwendung eines Applet zu erleichtern, sollten die
folgenden Hilfsmittel verwendet werden:
spezielle Kommentare, aus denen mit Javadoc die Dokumentation des Java-
Programms erstellt wird, und
die Methoden getAppletInfo() und getParameterInfo() im Applet, deren Ergebnisse
von manchen Web-Browsern (z.B. dem Appletviewer) beim Anklicken
von "Eigenschaften" oder "Info" angezeigt werden.
Beispiel:
import java.awt.*;
import java.applet.*;
/**
* an example for an Applet with javadoc documentation,
* Applet info, und parameter info.
* @since JDK 1.0
*/
public class AppletDoc extends Applet {
String text;
int fontSize;
Font f;
public void init () {
text = getParameter("text");
if (text == null)
text = "Hello World!";
try {
fontSize = Integer.parseInt (
getParameter("fontsize").trim() );
} catch (Exception e) {
fontSize = 12;
}
f = new Font ("Helvetica", Font.BOLD, fontSize);
}
public void paint (Graphics g) {
g.setFont (f);
Java-Einfuhrung von H. Partl { Kursunterlage 107

}
g.drawString (text, 25, 50);
}
public String getAppletInfo() {
String s =
"AppletDoc = Hello World Applet with parameters";
return s;
}
public String[][] getParameterInfo() {
String[][] s = {
{ "text", "String", "Text to be displayed" },
{ "fontsize", "Integer", "Font size in points" }
};
return s;
}
7.23 Doppelnutzung als Applet und Applikation
Man kann ein Java-Programm auch so schreiben, da es sowohl als Applet innerhalb
einer Web-Page als auch als lokale Applikation ausgefuhrt werden kann. Zu diesem
Zweck mu das Programm
eine Subklasse von Applet sein und
eine main-Methode enthalten.
Die main-Methode wird nur bei Aufruf als Applikation ausgefuhrt und im Applet
ignoriert. Sie mu ein Frame (als Ersatz fur das Fenster des Web-Browsers) erzeugen
und in diesem ein Objekt des Applet einfugen und dann die init- und start-Methoden
des Applet aufrufen, die den Inhalt des Applet darstellen.
Auerdem sollte ein WindowListener implementiert werden, der beim Schlieen des
Frame die Applikation beendet (analog zum Schlieen des Web-Browsers).
Falls das Applet eine stop-Methode enthalt, mu diese von der Applikation vor deren
Beendigung aufgerufen werden.
Beispiel:
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
public class AppApp extends Applet
implements WindowListener {
public void init() {
setLayout( new FlowLayout() );
Label hello = new Label("Hello World!");
add(hello);
Java-Einfuhrung von H. Partl { Kursunterlage 108

}
}
// add more content ...
setVisible(true);
public static void main (String[] args) {
AppApp a = new AppApp();
Frame f = new Frame("AppApp");
}
f.setLayout( new BorderLayout() );
a.init();
f.add (a, "Center");
f.setSize(300,200);
f.addWindowListener( a );
f.setVisible(true);
a.start();
public void windowClosing (WindowEvent e) {
this.stop();
System.exit(0);
}
public void windowClosed (WindowEvent e) { }
public void windowOpened (WindowEvent e) { }
public void windowIconified (WindowEvent e) { }
public void windowDeiconified (WindowEvent e) { }
public void windowActivated (WindowEvent e) { }
public void windowDeactivated (WindowEvent e) { }
Java-Einfuhrung von H. Partl { Kursunterlage 109

8. Threads
Programmfaden
mehrere Aktionen parallel
8.1 Multithreading, Thread, Runnable
Threads ("Faden") sind Programmteile, die parallel, also unabhangig voneinander,
mehr oder weniger gleichzeitig ablaufen.
Es gibt Threads, die von der Java Virtual Machine automatisch erzeugt werden, z.B.
fur das Event-Handling und den Garbage-Collector. Fur die Aufspaltung eigener
Programme in mehrere Threads dienen die folgenden beiden Objekte:
die Klasse Thread fur die Steuerung von Threads (starten und beenden),
das Interface Runnable, mit dem das innerhalb des Thread laufende Programm
implementiert wird.
Das Programm, das innerhalb des Thread lauft, mu das Interface Runnable implementieren
und eine Methode mit der Signature
public void run()
enthalten, die dann innerhalb des Thread ausgefuhrt wird.
Beispiel:
public class MyProgram implements Runnable {
public void run() {
System.out.println("Hello World!");
}
}
Java-Einfuhrung von H. Partl { Kursunterlage 110

8.2 Starten eines Thread (start)
Konstruktor:
new Thread (Runnable)
Der Parameter gibt an, welches Programm innerhalb des Thread laufen soll (siehe
oben).
Das Starten des Thread erfolgt mit der Methode
start()
Damit wird die run-Methode des Runnable-Objekts gestartet.
Beispielskizze:
Thread t;
Runnable theProgram = new MyProgram();
t = new Thread (theProgram);
t.start();
Der Zusammenhang zwischen Runnable-Objekt und Thread-Objekt ist ahnlich
wie zwischen einem Auto und seinem Lenker:
Das Runnable-Objekt entspricht dem Auto.
das Thread-Objekt entspricht dem Lenker, der das Auto steuert.
Jedes Auto mu von einer Person gelenkt werden, und jede Person kann nur
ein Auto lenken.
Der Konstruktor des Thread-Objekts entspricht der Ubergabe des Autoschlussels
an den Lenker: Damit wird festgelegt, welches Auto er lenken
soll.
Die start-Methode entspricht dem Starten mit dem Startschlussel, die run-
Methode entspricht dem Laufen des Motors: Der Lenker dreht den Startschlussel,
und das bewirkt, da der Motor zu laufen beginnt.
Java-Einfuhrung von H. Partl { Kursunterlage 111

8.3 Beenden oder Abbrechen eines Thread
Der Thread lauft selbstandig (also unabhangig von dem Thread, der ihn gestartet
hat, siehe auch unten) und endet automatisch, wenn das Ende der run-Methode
erreicht wird.
Falls die Aktionen des Thread eine langere Ausfuhrungszeit benotigen oder in einer
Schleife wiederholt werden, mu man eine Moglichkeit vorsehen, den Thread "von
auen" zu beenden oder abzubrechen.
Dazu verwendet man am besten ein boolean Datenfeld, das von auen gesetzt werden
kann und innerhalb des Runnable-Objekts abgefragt wird.
Beispielskizze:
Thread t;
MyProgram myProg = new MyProgram();
t = new Thread (myProg);
t.start();
...
myProg.setRunFlag(false);
public class MyProgram implements Runnable {
private boolean runFlag;
public void setRunFlag (boolean runFlag) {
this.runFlag = runFlag;
}
public boolean getRunFlag() {
return this.runFlag;
}
public void run() {
runFlag=true;
while (runFlag) {
// do something
}
}
}
Es gibt auch Methoden stop(), interrupt(), suspend() und resume() fur das Beenden,
Abbrechen oder Unterbrechen eines Thread. Die Verwendung dieser Methoden
wird jedoch nicht empfohlen ("deprecated" ab JDK 1.2), weil es dabei entweder zu
Deadlock-Situationen oder zu unvollstandig ausgefuhrten Aktionen und damit zu
ungultigen Objekt- oder Datenzustanden kommen kann.
Beispiel: Wenn ein Thread, der mehrere zusammengehorige Daten in eine oder mehrere
Files oder Datenbanken schreiben will, mit einer dieser Methoden abgebrochen
wird, so kann es passieren, da nur ein Teil der neuen Daten abgespeichert wird und
damit ein ungultiger, inkonsistenter Datenzustand entsteht.
Java-Einfuhrung von H. Partl { Kursunterlage 112

8.4 Unterbrechungen (sleep)
Man kann nicht davon ausgehen, da die Rechenzeit "gerecht" auf alle parallel
laufenden Threads aufgeteilt wird. Es kann durchaus passieren, da ein Thread alle
Betriebsmittel fur sich verbraucht und alle anderen Threads dadurch aufgehalten
werden und untatig warten mussen. Dies kann auch durch das Setzen von Prioriaten
mit setPriority() oder yieald() nicht vollig ausgeschlossen werden.
Deshalb mu man bei parallel laufenden Threads immer dafur sorgen, da jeder
von ihnen Pausen einlegt, in denen die anderen Threads eine Chance bekommen,
ihrerseits zu laufen. Dies gilt auch fur das Programm, das den Thread mit start()
gestartet hat und nun will, da dieser auch tatsachlich lauft.
Die wichtigste Warte-Methode ist die statische Methode
Thread.sleep (long)
fur eine Pause mit einer bestimmten Zeitdauer (in Millisekunden)
Beim Aufruf von sleep mu die Fehlersituation InterruptedException abgefangen
werden, fur den Fall, da der Thread wahrend der Wartezeit gestoppt oder abgebrochen
wird.
Besonders wichtig ist die sleep-Methode, wenn die run-Methode eine Schleife oder
Endlos-Schleife ist, die bestimmte Aktionen immer wieder wiederholt (so lange, bis
der Thread beendet wird). Beispiel:
public class MyProgram implements Runnable {
private boolean runFlag;
public void setRunFlag (boolean runFlag) {
this.runFlag = runFlag;
}
public boolean getRunFlag() {
return this.runFlag;
}
public void run() {
runFlag=true;
while (runFlag) {
// do something
try {
Thread.sleep(1000);
} catch (InterruptedException e) { }
}
}
}
Java-Einfuhrung von H. Partl { Kursunterlage 113

8.5 Synchronisierung (join, wait, notify, synchronized)
Wenn ein Thread die Ergebnisse, die ein anderer Thread produziert, verwenden will,
mu der eine Thread auf den anderen warten und der andere dem einen mitteilen,
wann er mit seiner Aufgabe fertig ist. Dazu dienen die folgenden Methoden:
Methode im Thread-Objekt:
join()
fur das Abwarten, bis der gestartete Thread fertig gelaufen ist (d.h. sein Ende
erreicht hat)
Methoden in jedem Objekt (jeder Subklasse von Object):
wait()
fur das Abwarten, bis der gestartete Thread ein notify() fur dieses Objekt
sendet
wait(long timeout)
ebenso, aber mit einem Timeout (maximale Wartezeit im Millisekunden)
notify()
fur das Beenden eines wait()-Zustandes fur dieses Objekt, wenn ein oder mehrere
Threads mit wait() darauf warten; sonst ohne Bedeutung
notifyAll()
fur das Beenden von allen eventuell fur dieses Objekt wartenden wait()-
Zustanden
Dabei mu darauf geachtet, da keine Deadlock-Situation auftritt (Proze A wartet,
das Proze B ein notify() sendet, und Proze B wartet, da Proze A ein notify()
sendet).
Wenn zwei oder mehrere parallel laufende Threads dasselbe Objekt ansprechen, kann
es zu Problemen kommen, wenn beide gleichzeitig das Objekt verandern wollen
und dabei auf vom anderen Thread halb ausgefuhrte Zwischenzustande zugreifen
(concurrent update problem). In diesem Fall mu man alle "gefahrlichen" Aktionen
jeweils in einen synchronized-Block der folgenden Form einfugen:
synchronized (Object) {
Statements;
}
wobei fur Object meistens this anzugeben ist, oder die jeweilige Methode insgesamt
als synchronized deklarieren:
public synchronized typ name (parameter) {
Statements;
}
Dies bewirkt da der mit synchronized markierte Statement-Block (bzw. die mit
synchronized markierte Methode) nur dann ausgefuhrt wird, wenn kein anderer,
ebenfalls mit synchronized markierter Statement-Block fur dieses Objekt lauft; andernfalls
wartet der neue Statement-Block, bis der alte Statement-Block fertig ist
und sich das Objekt daher wieder in einem gultigen Zustand bendet, und fuhrt
dann seine Aktionen ebenfalls komplett und ungestort aus.
Java-Einfuhrung von H. Partl { Kursunterlage 114

Die Methoden wait() und notify() sind nur innerhalb von synchronized Blocks oder
Methoden erlaubt.
Ab JDK 1.3 kann man auch sogenannte "Piped Streams" zur Kommunikation von
Daten und von Wartezustanden zwischen zwei Threads verwenden (Klassen Piped-
Writer und PipedReader im Pakte java.io): Jedes Lesen aus dem PipedReader in
dem einen Thread wartet, bis vom anderen Thread entsprechende Daten in den
zugehorigen PipedWriter geschrieben werden.
8.6 Beispiel: eine einfache Animation
import java.awt.* ;
import java.applet.* ;
public class Anima extends Applet
implements Runnable {
private boolean runFlag;
private int x, y, height, width;
private Image img;
private Graphics g;
private Thread t = null;
private Color nightColor = new Color (0, 0, 102);
private Color moonColor = new Color (204, 204, 255);
public void init() {
Dimension d = getSize();
width = d.width;
height = d.height;
img = createImage (width, height);
g=img.getGraphics();
x = width/2;
y = height/2;
}
public void start() {
if (t == null)
{
t = new Thread (this);
t.start();
}
}
public void stop() {
if (t != null)
{
runFlag=false; // or: t.stop();
t=null;
}
}
Java-Einfuhrung von H. Partl { Kursunterlage 115

public void run () {
runFlag=true;
while (runFlag) {
g.setColor (nightColor);
g.fillRect(0,0,width,height);
g.setColor (moonColor);
g.fillArc(x, y-25, 50, 50, 270, 180);
repaint();
x = x + 2;
if (x > width+50 ) {
x = -50;
}
try { Thread.sleep(100); }
catch (InterruptedException e) {}
}
}
public void update (Graphics g) {
paint(g);
}
public void paint (Graphics g) {
if (img != null) {
g.drawImage(img,0,0,null);
}
}
}
Wenn Sie wissen wollen, was dieses Applet tut, probieren Sie es einfach aus (in Ihrem
Browser, wenn er das kann, oder Abschreibubung oder Download).
8.7 Ubung: einfaches Applet Blinklicht
Schreiben Sie ein einfaches Applet, das eine gelb blinkende Verkehrsampel zeigt
(schwarzes Rechteck mit oder ohne gelbem Kreis).
Wenn Sie sehen wollen, wie das aussehen konnte, probieren Sie es in Ihrem Browser
aus (falls er das kann).
Java-Einfuhrung von H. Partl { Kursunterlage 116

8.8 Ubung: erweitertes Applet Verkehrsampel mit Blinklicht
Erweitern Sie das Applet Verkehrsampel (siehe die Ubung im Kapitel Applets) in
folgender Weise:
Fugen Sie einen weiteren Button "Blink" hinzu.
Wenn dieser Blink-Button angeklickt wird, dann soll die Verkehrsampel gelb
blinken (wie in der vorhergehenden einfachen Ubung).
Das Blinken soll enden und die Verkehrsampel wieder die normalen Farben
zeigen, wenn der Blink-Button nochmals angeklickt wird, oder wenn der Nextoder
Stop-Button angeklickt wird, oder wenn die Web-Page verlassen oder das
Applet oder der Web-Browser beendet wird.
Wenn Sie sehen wollen, wie das aussehen konnte, probieren Sie es in Ihrem Browser
aus (falls er das kann).
Java-Einfuhrung von H. Partl { Kursunterlage 117

System-Interfaces
Ein-Ausgabe (IO)
Networking (Web-Server, Sockets)
System-Funktionen und Utilities
Datenbanken
Java-Einfuhrung von H. Partl { Kursunterlage 118

9. Ein-Ausgabe (IO)
Das Lesen und Schreiben von lokalen Dateien (Files) ist im allgemeinen nur fur
Applikationen, aber nicht fur Applets erlaubt. Applets konnen im allgemeinen nur
Files auf dem Server ansprechen, von dem sie geladen wurden (siehe die Kapitel
uber das Lesen von einem Web-Server und uber Networking).
Fur die Verwendung der Ein-Ausgabe-Klassen mu das Package java.io importiert
werden.
Alle Ein-Ausgabe-Operationen konnen bestimmte Fehlersituationen auslosen (IO-
Exception, SecurityException, FileNotFoundException u.a.), die mit try und catch
abgefangen werden sollen (siehe das Kapitel uber Exceptions).
9.1 Dateien (Files) und Directories
Deklaration eines Files:
Die folgenden Datenstrome ("Systemdateien") stehen innerhalb der System-Klasse
statisch zur Verfugung und mussen nicht explizit deklariert werden:
PrintStream System.out
PrintStream System.err
InputStream System.in
fur die Standard-Ausgabe
fur die Fehlerausgabe
fur die Standard-Eingabe
Andere Files kann man im einfachsten Fall ansprechen, indem man den Filenamen
im Konstruktor eines Datenstromes angibt (siehe unten).
Fur kompliziertere Aktionen mit Dateien und Directories konnen File-Objekte mit
den folgenden Konstruktoren angelegt und mit den folgenden Methoden verwendet
werden:
File f = new File (filename);
File f = new File (directory, filename);
Der Filename ist als String anzugeben. Er kann auch den kompletten Pfad enthalten,
also mit Schragstrichen oder Backslashes oder Doppelpunkten, je nach Betriebssystem,
die Applikation ist dann aber nicht plattformunabhangig. Statt diesen File-
Separator explizit im String anzugeben, sollte man deshalb immer den am jeweiligen
System gultigen Separator mit dem statischen Datenfeld
File.separator
ansprechen und mit + in den String einbauen.
Die Version des Konstruktors mit zwei Parametern ist dann sinnvoll, wenn man
mehrere Files in einem Directory ansprechen will, oder wenn das Directory innerhalb
Java-Einfuhrung von H. Partl { Kursunterlage 119

des Programms bestimmt oder vom Benutzer ausgewahlt wird. Fur den Directory-
Namen kann entweder ein String (wie oben) oder ein File-Objekt, das ein Directory
beschreibt, angegeben werden.
Das Onen oder Anlegen des Files erfolgt erst dann, wenn das File-Objekt im Konstruktor
eines Datenstromes (InputStream, OutputStream, Reader, Writer, siehe
unten) verwendet wird.
Deklaration eines Directory:
Methoden
Directories werden wie Files deklariert und "geonet":
File dir = new File (dirname);
File dir = new File (parentdir, dirname);
Mit den Methoden isFile() und isDirectory() kann abgefragt werden, ob es sich um
ein File oder um ein Directory handelt. Das Anlegen eines Directory erfolgt mit der
Methode mkdir().
Die wichtigsten Methoden fur File-Objekte (Dateien und Directories) sind:
String getName()
fur den File- bzw. Directory-Namen ohne Pfad
String getPath() und getAbsolutePath()
fur den File- bzw. Directory-Namen mit Pfad
String getParent()
fur das Parent-Directory
boolean exists(), boolean canWrite(), boolean canRead()
fur die Existenz und die Permissions
boolean isFile(), boolean isDirectory()
fur die Art (File oder Directory)
long length()
fur die Lange in Bytes
long lastModified()
ist eine system-interne Zahl, die das Alter des File-Inhalts angibt (nur fur
relative Vergleiche brauchbar, nicht fur Datums-Angaben)
boolean mkdir()
fur das Anlegen des Directory (liefert true, wenn erfolgreich durchgefuhrt,
sonst false)
String[] list()
fur eine Liste von allen in einem Directory enthaltenen File- und Directory-
Namen. Wenn man diese Files oder Subdirectories ansprechen will, mu man
mit Konstruktoren wie new File(name[i]) File-Objekte dafur erzeugen.
Java-Einfuhrung von H. Partl { Kursunterlage 120

static File[] listRoots()
fur eine Liste von allen Filesystem-Anfangen ("Laufwerken" unter MS-
Windows).
boolean renameTo (new File(filename))
fur die Anderung des File- oder Directory-Namens (liefert true, wenn erfolgreich
durchgefuhrt, sonst false)
boolean delete()
fur das Loschen des Files oder Directory (liefert true, wenn erfolgreich durchgefuhrt,
sonst false)
9.2 Datenstrome (stream)
Im Sinne der Grundsatze der objekt-orientierten Programmierung gibt es in Java
verschiedene Klassen und Objekte fur Datenstrome, die je nach der Anwendung
entsprechend kombiniert werden mussen. Dabei sind die Spezialfalle jeweils Unterklassen
der einfachen Falle (Vererbung), alle Ein-Ausgabe-Operationen konnen also
direkt am Objekt der Unterklasse durchgefuhrt werden.
Einfache, grundlegende Stream-Klassen denieren auf einer niedrigen Ebene
die Ein- und Ausgabe in Dateien (Files) oder auch in anderen Datenstromen
wie z.B. Pipes, Byte-Arrays oder Netzverbindungen (Sockets, URLs).
Spezielle, darauf aufbauende Stream-Klassen denieren zusatzliche Eigenschaften
wie z.B. Puerung, zeilenorientierte Text-Ausgabe, automatische Zeilennumerierung
und dergleichen.
Es gibt in Java zwei verschiedene Gruppen von Datenstromen:
InputStream, OutputStream und RandomAccessFile fur byte-orientierte Datenles,
Reader und Writer fur zeichen- und zeilen-orientierte Textles.
Java-Einfuhrung von H. Partl { Kursunterlage 121

9.3 InputStream (Eingabe)
Byte-weises Lesen
InputStream ist die Oberklasse fur das Lesen, also die Eingabe von Datenstromen
(siehe auch die Alternative Reader).
FileInputStream ist die grundlegende Klasse fur das Lesen von Dateien (siehe auch
die Alternative FileReader).
Das Onen des Lese-Stroms bzw. des Files erfolgt mit einem Konstruktor der Form
FileInputStream infile = new FileInputStream (filename);
Der Filename kann entweder als String oder als File-Objekt angegeben werden (siehe
oben).
Die wichtigsten Methoden fur InputStreams sind:
int read()
liefert ein Byte, oder den Wert -1, wenn das Ende des Datenstroms (End-of-
File) erreicht wurde. Beispiel:
int b = infile.read();
int read (byte[])
int read (byte[], offset, length)
liest so viele Zeichen wie moglich in das Byte-Array bzw. in den angegebenen
Teilbereich des Byte-Array und liefert die Anzahl der gelesenen Zeichen
(eventuell 0), oder den Wert -1, wenn das Ende des Datenstroms (End-of-File)
erreicht wurde. Beispiel:
byte[] b = new byte[1024];
int n = infile.read (b[]);
skip(long)
uberspringt die angegebene Anzahl von Bytes im Eingabestrom.
close()
schliet den Eingabestrom bzw. das File.
Ein typisches Beispiel fur das Byte-weise Lesen eines Daten-Files hat folgenden
Aufbau:
int b;
try {
BufferedInputStream in = new BufferedInputStream (
new FileInputStream ("filename.dat") );
while( (b = in.read()) != -1 ) {
// do something ...
}
in.close();
} catch (Exception e) {
System.out.println("error " + e);
}
Java-Einfuhrung von H. Partl { Kursunterlage 122

9.4 Spezielle Input-Streams
BueredInputStream
DataInputStream
Spezielle InputStreams bauen auf grundlegenden InputStreams auf. Der Konstruktor
hat als Parameter ein Objekt des darunterliegenden InputStream.
Die wichtigsten Input-Streams und ihre Methoden sind:
Um die Eingabe ezienter und schneller zu machen, soll nicht jedes Byte einzeln
von der Hardware gelesen werden, sondern aus einem Puerbereich. Daher sollte fast
immer ein BueredInputStream uber den einfachen FileInputStream gelegt werden.
Konstruktoren:
new BufferedInputStream (InputStream)
fur einen Puer mit Standardgroe
new BufferedInputStream (InputStream, int)
fur einen Puer mit der angegebenen Groe
Beispiel:
BufferedInputStream in = new BufferedInputStream
( new FileInputStream (filename) );
Der DataInputStream erlaubt es, bestimmte primitive Datentypen direkt einzulesen,
d.h. die Daten mussen in der plattformunabhangigen Java-internen Darstellung
im Input-Stream stehen ("binares Datenle", z.B. mit DataOutputStream geschrieben).
Konstruktor:
new DataInputStream (InputStream)
Beispiel:
DataInputStream in = new DataInputStream
( new BufferedInputStream
( new FileInputStream (filename) ) );
Methoden:
boolean readBoolean()
byte readByte()
int readInt()
long readLong()
float readFloat()
double readDouble()
und so weiter
Es gibt hier auch eine String-Methode readLine(), es wird aber empfohlen, fur die
Verarbeitung von Textzeilen lieber die Klasse BueredReader zu verwenden (siehe
unten).
Java-Einfuhrung von H. Partl { Kursunterlage 123

ObjectInputStream
Ahnlich wie der DataInputStream, erlaubt es aber auch, beliebige Objekt-Typen zu
lesen, die im Input-Stream in der Java-internen Darstellung stehen ("Serialization",
z.B. mit ObjectOutputStream geschrieben, Filenamen der Form xxxx.ser).
Konstruktor:
new ObjectInputStream (InputStream)
Methoden:
wie beim DataInputStream, und zusatzlich
Object readObject()
fur beliebige Objekte
Anmerkung: Object ist die Superklasse fur alle Klassen. Das Ergebnis von read-
Object() mu mit "Casting" auf den Typ des tatsachlich gelesenen Objekts umgewandelt
werden. Beispiel:
Date d;
...
d = (Date) in.readObject();
9.5 Lesen einer Datei von einem Web-Server (URL)
Mit den Klassen URL (uniform resource locator) und URLConnection im Paket
java.net kann eine beliebige Datei von einem Web-Server oder FTP-Server gelesen
werden (bei Applikationen von einem beliebigen Server, bei einem Applet im allgemeinen
nur von dem Web-Server, von dem es geladen wurde). Mit der Methode
openStream() erhalt man einen InputStream, der dann wie ein FileInputStream
verwendet werden kann.
Beispiel:
import java.io.*;
import java.net.*;
...
BufferedInputStream in;
URL url;
try {
url = new URL( "http://www.xxx.com/yyy.html" );
in = new BufferedInputStream ( url.openStream() );
...
// Lesen mit in.read()
...
} catch (Exception e) {
System.out.println("error "+e);
}
Dies eignet sich bis JDK 1.1 primar fur das Lesen von Textles (siehe InputStream-
Reader) und Datenles (siehe DataInputStream). Ab JDK 1.2 gibt es auch eigene
Java-Einfuhrung von H. Partl { Kursunterlage 124

Klassen fur die Interpretation von HTML-Files (JEditorPane, HTMLDocument,
HTMLReader).
Komplexere Moglichkeiten fur Ein-Ausgabe-Operationen uber das Internet sind im
Kapitel uber Networking und Sockets beschrieben.
9.6 OutputStream (Ausgabe)
Byte-weises Schreiben
OutputStream ist die Oberklasse fur das Schreiben, also die Ausgabe von Datenstromen
(siehe auch die Alternative Writer).
FileOutputStream ist die grundlegende Klasse fur das Schreiben von Dateien (siehe
auch die Alternative FileWriter).
Das Onen des Ausgabe-Stroms bzw. des Files erfolgt mit Konstruktoren der Form
new FileOutputStream (filename);
new FileOutputStream (filename, false);
new FileOutputStream (filename, true);
Der Filename kann entweder als String oder als File-Objekt angegeben werden
(siehe oben). In den ersten beiden Fallen wird die Datei neu geschrieben oder
uberschrieben, im dritten Fall (Appendmode true) werden die Informationen an
das Ende einer bereits existierenden Datei hinzugefugt.
In JDK 1.0 ist die Angabe des Appendmode nicht moglich, dort mu fur das Hinzufugen
an eine bereits bestehende Datei stattdessen die Klasse RandomAccessFile
verwendet werden (siehe unten).
Die wichtigsten Methoden fur OutputStreams sind:
write(int)
schreibt ein Byte mit den angegeben Wert
write (byte[])
write (byte[], offset, length)
schreibt alle im Byte-Array bzw. im angegebenen Teilbereich des Byte-Array
enthaltenen Bytes
flush()
sorgt dafur, da alle eventuell noch im Puer wartenden Bytes tatsachlich
in die Datei geschrieben werden (sollte immer vor dem Close bzw. vor der
Beendigung oder einem Abbruch des Programms aufgerufen werden)
close()
schliet den Ausgabestrom bzw. das File.
Ein typisches Beispiel fur das Byte-weise Schreiben eines Daten-Files hat folgenden
Aufbau:
Java-Einfuhrung von H. Partl { Kursunterlage 125

try {
BufferedOutputStream out = new BufferedOutputStream (
new FileOutputStream ("filename.dat") );
...
out.write(...);
...
out.flush();
out.close();
} catch (Exception e) {
System.out.println("error " + e);
}
9.7 Spezielle Output-Streams
BueredOutputStream
DataOutputStream
Spezielle OutputStreams bauen auf grundlegenden OutputStreams auf. Der Konstruktor
hat als Parameter ein Objekt des darunterliegenden OutputStream.
Die wichtigsten Output-Streams und ihre Methoden sind:
Um die Ausgabe ezienter und schneller zu machen, soll nicht jedes Byte einzeln
auf die Hardware geschrieben werden, sondern aus einem Puerbereich. Daher sollte
fast immer ein BueredOutputStream uber den einfachen FileOutputStream gelegt
werden.
Konstruktoren:
new BufferedOutputStream (OutputStream)
fur einen Puer mit Standardgroe
new BufferedOutputStream (OutputStream, int)
fur einen Puer mit der angegebenen Groe
Beispiel:
BufferedOutputStream out = new BufferedOutputStream
( new FileOutputStream (filename) );
Der DataOutputStream erlaubt es, bestimmte primitive Datentypen direkt in ihrer
(plattformunabhangigen) Java-internen Darstellung zu schreiben ("binares Daten-
le", kann dann mit DataInputStream gelesen werden).
Konstruktor:
new DataOutputStream (OutputStream)
Beispiel:
DataOutputStream out = new DataOutputStream
( new BufferedOutputStream
( new FileOutputStream (filename) ) );
Java-Einfuhrung von H. Partl { Kursunterlage 126

Methoden:
ObjectOutputStream
PrintStream
writeBoolean(boolan)
writeByte(int)
writeBytes(String)
writeInt(int)
writeLong(long)
writeFloat(float(
writeDouble(double)
und so weiter
Ahnlich wie der DataOutputStream, erlaubt es aber auch, Objekt-Typen in der
Java-internen Darstellung zu schreiben (kann dann mit ObjectInputStream gelesen
werden). Dazu mu das Objekt nur das Interface Serializable implementieren (was
im allgemeinen kein Problem ist).
Konstruktor:
new ObjectOutputStream (OutputStream)
Methoden:
wie beim DataOutputStream, und zusatzlich
writeObject(Object)
Anmerkung: Object ist die Superklasse fur alle Klassen, der Parameter von write-
Object kann also ein Objekt einer beliebigen Klasse sein. Beispiel:
Date d;
...
out.writeObject (d);
Es wird empfohlen, fur das Schreiben von zeilenorientierten Datenstromen lieber die
Klasse PrintWriter zu verwenden (siehe unten)
Java-Einfuhrung von H. Partl { Kursunterlage 127

9.8 RandomAccessFile (Ein- und Ausgabe)
Random-Access-Files erlauben es, Daten nicht nur in einem Datenstrom vom Anfang
bis zum Ende zu lesen oder zu schreiben, sondern an bestimmte Stellen eines Files zu
"springen" und dort direkt zu lesen und zu schreiben. Dabei ist auch ein Abwechseln
zwischen Lese- und Schreiboperationen moglich.
Konstruktor:
new RandomAccessFile (filename, mode)
Der Filename kann als String oder als File-Objekt angegeben werden.
Der Mode ist ein String, der entweder nur "r" oder "rw" enthalt. Im ersten Fall
kann der File-Inhalt nur gelesen werden, im zweiten Fall (auch) geschrieben bzw.
verandert werden.
Methoden:
Es stehen alle fur InputStreams und fur OutputStreams denierten Methoden zur
Verfugung, also insbesondere read, write, close, ush, und auerdem die folgenden
Methoden:
long getFilePointer()
liefert die aktuelle Position innerhalb des Files
long length()
liefert die Lange des Files
seek (long)
setzt den FilePointer auf eine bestimmte Stelle fur das nachste read oder write
Wenn man Daten an das Ende einer bereits existierenden Datei hinzufugen will,
kann man diese Datei als RandomAccessFile mit mode "rw" onen und mit
file.seek( file.length() );
an das File-Ende positionieren, bevor man den ersten write-Befehl ausfuhrt. Ab JDK
1.1 kann man dies aber einfacher mit dem Appendmode-Parameter im Konstruktor
des FileOutputStream bzw. FileWriter erreichen.
Java-Einfuhrung von H. Partl { Kursunterlage 128

9.9 Reader und Writer (Text-Files)
FileReader
FileWriter
Java als plattformunabhangige Sprache verwendet den Zeichencode "Unicode" (16
bit pro Zeichen) fur die Verarbeitung von allen weltweit verwendeten Schriftzeichen.
Die Reader- und Writer-Klassen unterstutzen die Umwandlung zwischen diesem 16
bit Unicode und dem auf dem jeweiligen Rechnersystem verwendeten (meist 8 bit)
Zeichencode fur Textles. Dies kann der in englisch-sprachigen und westeuropaischen
Landern verwendete Zeichencode Iso-Latin-1 (ISO-8859-1) oder ein anderer Zeichencode
sein, z.B. fur osteuropaische lateinische Schriften (Iso-Latin-2) oder fur
kyrillische, griechische, arabische, hebraische oder ostasiatische Schriften, oder die
Unicode-Kodierung mit UTF-8, oder auch ein Computer-spezischer Code wie z.B.
fur MS-DOS, MS-Windows oder Apple Macintosh.
Fur die Verarbeitung von Textles sollten daher ab JDK 1.1 Reader und Writer
statt Input-Streams und Output-Streams verwendet werden. Diese Klassen enthalten
nicht nur Methoden fur das Lesen und Schreiben von einzelnen Bytes (read,
write) sondern auch zusatzliche Methoden fur das Lesen und Schreiben von ganzen
Zeilen (readLine, newLine) sowie fur die Darstellung von Zahlen und anderen Datentypen
als menschenlesbare Texte (print, println).
Die wichtigsten Klassen sind:
FileReader, FileWriter und PrintWriter
BueredReader und BueredWriter
InputStreamReader und OutputStreamWriter
StringReader und StringWriter
Der FileReader ist die grundlegende Klasse zum text- und zeilen-orientierten Lesen
von Dateien (Files). Aus Ezienzgrunden sollte er innerhalb eines BueredReader
verwendet werden (siehe unten).
Konstruktor:
new FileReader (filename)
Der Filename ist als String oder als File-Objekt anzugeben.
Das Encoding kann hier nicht angegeben werden, es wird immer das lokale Encoding
des Systems angenommen. Falls Sie das Encoding (z.B. "8859 1") explizit angeben
wollen, mussen Sie statt dem FileReader eine Kombination von InputStreamReader
und FileInputStream verwenden (siehe unten).
Der FileWriter ist die grundlegende Klasse zum text- und zeilen-orientierten Schreiben
von Dateien (Files). Aus Ezienzgrunden sollte er innerhalb eines BueredWriter
verwendet werden (siehe unten).
Konstruktoren:
Java-Einfuhrung von H. Partl { Kursunterlage 129

new FileWriter (filename)
new FileWriter (filename, false)
new FileWriter (filename, true)
Der Filename ist als String oder als File-Objekt anzugeben. In den ersten beiden
Fallen wird die Datei neu geschrieben oder uberschrieben, im dritten Fall (Appendmode
true) werden die Informationen an das Ende einer bereits existierenden Datei
hinzugefugt.
Das Encoding kann hier nicht angegeben werden, es wird immer das lokale Encoding
des Systems angenommen. Falls Sie das Encoding (z.B. "8859 1") explizit angeben
wollen, mussen Sie statt dem FileWriter eine Kombination von OutputStreamWriter
und FileOutputStream verwenden (siehe unten).
PrintWriter
Der PrintWriter ist eine spezielle Klasse zum text- und zeilen-orientierten Schreiben
von Datenstromen oder Files. Sie enthalt zusatzliche Methoden fur die Umwandlung
von Zahlen und anderen Objekten in menschenlesbare Texte (print, println, siehe
unten).
Konstruktoren:
new PrintWriter (Writer)
new PrintWriter (OutputStream)
Das Encoding kann hier nicht angegeben werden, es wird immer das lokale Encoding
des Systems angenommen.
BueredReader und BueredWriter
Um die Ausgabe ezienter und schneller zu machen, soll nicht jedes Byte einzeln von
der Hardware gelesen bzw. auf die Hardware geschrieben werden, sondern aus einem
Puerbereich. Daher sollte fast immer ein BueredReader bzw. BueredWriter uber
den einfachen FileReader, InputStreamReader, FileWriter oder OutputStreamWriter
gelegt werden.
Konstruktoren:
new BufferedReader (Reader)
fur einen Puer mit Standardgroe
new BufferedReader (Reader, int)
fur einen Puer mit der angegebenen Groe
new BufferedWriter (Writer)
fur einen Puer mit Standardgroe
new BufferedWriter (Writer, int)
fur einen Puer mit der angegebenen Groe
Beispiele:
Java-Einfuhrung von H. Partl { Kursunterlage 130

BufferedReader infile = new BufferedReader
(new FileReader (infileName) );
BufferedWriter outfile = new BufferedWriter
(new FileWriter (outfileName) );
InputStreamReader und OutputStreamWriter
Die Klasse InputStreamReader dient dazu, einen byte-orientierten InputStream zum
Lesen von Texten und Textzeilen zu verwenden. Dies ist fur Spezialfalle notwendig,
die nicht mit dem FileReader abgedeckt werden konnen. Aus Ezienzgrunden sollte
sie innerhalb eines BueredReader verwendet werden.
Konstruktor:
new InputStreamReader (InputStream)
new InputStreamReader (InputStream, String)
Der String im zweiten Fall gibt den Zeichencode an, z.B. "8859 1". Im ersten Fall
wird der am jeweiligen Rechnersystem "ubliche" Zeichencode verwendet. Beim Lesen
von Dateien uber das Internet soll immer der Code der Datei explizit angegeben
werden, damit man keine bosen Uberraschungen auf Grund von lokalen Spezialfallen
am Client erlebt.
Beispiele:
BufferedReader stdin = new BufferedReader
(new InputStreamReader (System.in) );
BufferedReader infile = new BufferedReader
(new InputStreamReader
(new FileInputStream("message.txt"), "8859_1" ) )
String fileUrl = "ftp://servername/dirname/filename";
BufferedReader infile = new BufferedReader
(new InputStreamReader
( ( new URL(fileUrl) ).openStream(), "8859_1" ) )
Die Klasse OutputStreamReader funktioniert analog zum InputStreamReader und
dient zum Schreiben von Texten und Textzeilen auf einen byte-orientierten OutputStream
in Spezialfallen, die nicht mit dem FileWriter abgedeckt werden konnen.
Beispiele:
BufferedWriter stdout = new BufferedWriter
(new OutputStreamWriter (System.out) );
BufferedWriter outfile = new BufferedWriter
(new OutputStreamWriter
(new FileOutputStream("message.txt"),
"8859_1" ) )
Java-Einfuhrung von H. Partl { Kursunterlage 131

StringReader und StringWriter
Die Klassen StringReader und StringWriter dienen dazu, aus einem langen String-
Objekt (statt einem File oder InputStream) zu lesen bzw. in ein String-Objekt zu
schreiben.
Konstruktoren:
new StringReader (String)
new StringWriter()
Den Inhalt des StringWriter-Objekts kann man mit der folgenden zusatzlichen Methode
erhalten:
String toString()
9.10 Reader
Reader - Methoden
zeichenweises Lesen
Die wichtigsten Methoden bei den Reader-Klassen sind:
int read()
liefert ein Zeichen, oder den Wert -1, wenn das Ende des Datenstroms (Endof-File)
erreicht wurde.
int read (char[])
int read (char[], offset, length)
liest so viele Zeichen wie moglich in das Zeichen-Array bzw. in den angegebenen
Teilbereich des Zeichen-Array und liefert die Anzahl der gelesenen Zeichen
(eventuell 0), oder den Wert -1, wenn das Ende des Datenstroms (End-of-File)
erreicht wurde.
String readLine()
liefert eine Zeile, oder den Wert null, wenn das Ende des Datenstroms (Endof-File)
erreicht wurde.
skip(long)
uberspringt die angegebene Anzahl von Zeichen im Eingabestrom.
close()
schliet den Eingabestrom bzw. das File.
Ein typisches Beispiel fur das zeichenweise Lesen eines Text-Files hat folgenden
Aufbau:
int ch;
try {
BufferedReader in = new BufferedReader (
new FileReader ("filename.txt") );
while( (ch = in.read()) != -1 ) {
// do something ...
Java-Einfuhrung von H. Partl { Kursunterlage 132

zeilenweises Lesen
9.11 Writer
Writer - Methoden
}
in.close();
} catch (Exception e) {
System.out.println("error " + e);
}
Ein typisches Beispiel fur das zeilenweise Lesen eines Text-Files hat folgenden Aufbau:
String thisLine;
try {
BufferedReader in = new BufferedReader (
new FileReader ("filename.txt") );
while( (thisLine = in.readLine()) != null ) {
// do something ...
}
in.close();
} catch (Exception e) {
System.out.println("error " + e);
}
Die wichtigsten Methoden bei den Writer-Klassen sind:
write(int)
schreibt ein Zeichen mit den angegeben Wert
write (char[])
write (char[], offset, length)
schreibt alle im Zeichen-Array bzw. im angegebenen Teilbereich des Zeichen-
Array enthaltenen Zeichen
write(String)
schreibt die im angebenen String enthaltene Zeichenkette
newLine()
schreibt ein Zeilenende-Zeichen
flush()
sorgt dafur, da alle eventuell noch im Puer wartenden Zeichen tatsachlich
in die Datei geschrieben werden (sollte immer vor dem Close bzw. vor der
Beendigung oder einem Abbruch des Programms aufgerufen werden)
close()
schliet den Ausgabestrom bzw. das File.
Anmerkung: Um plattformunabhangige Dateien zu erzeugen, sollten Zeilenenden
stets mit der Methode newLine() geschrieben werden und nicht mit "nn" oder "nrnn"
innerhalb von Strings.
Java-Einfuhrung von H. Partl { Kursunterlage 133

PrintWriter - Methoden
Der PrintWriter hat zusatzlich die folgenden Methoden:
print(String)
fur die Ausgabe eines Textstrings
print(boolean)
print(char)
print(int)
print(long)
print(float)
print(double)
und so weiter fur eine menschenlesbare Darstellung des jeweiligen Wertes in
Zeichen
print(Object)
fur eine menschenlesbare Darstellung des Objekts unter Verwendung der Methode
toString()
println()
fur die Ausgabe eines Zeilenende-Zeichens
println(String)
println(Object)
println(boolean)
und so weiter
fur die Ausgabe des Strings bzw. Wertes bzw. Objekts und anschlieend eines
Zeilenende-Zeichens ("print line")
Wenn Sie angeben wollen, mit wie vielen Nachkommstellen Float- und Double-
Zahlen ausgegeben werden sollen, konnen Sie die Klassen DecimalFormat oder NumberFormat
aus dem Package java.text verwenden. Beispiel:
double x = ...;
DecimalFormat dec = new DecimalFormat ("#,###,##0.00");
System.out.println("x = " + dec.format(x));
zeichen- und zeilenweises Schreiben
Ein typisches Beispiel fur das Schreiben eines Text-Files hat folgenden Aufbau:
try {
BufferedWriter out = new BufferedWriter (
new FileWriter ("filename.txt") );
...
out.write(...);
out.newLine();
...
out.flush();
out.close();
} catch (Exception e) {
System.out.println("error " + e);
}
Java-Einfuhrung von H. Partl { Kursunterlage 134

oder mit Verwendung von PrintWriter (mit auto-ush):
try {
PrintWriter out = new PrintWriter (
new BufferedWriter (
new FileWriter ("filename.txt") ) );
...
out.print(...);
out.println(...);
...
// out.flush(); not needed with autoflush PrintWriter
out.close();
} catch (Exception e) {
System.out.println("error " + e);
}
9.12 Ubung: zeilenweises Ausdrucken eines Files
Schreiben Sie eine einfache Applikation, die ein Text-File (ihr eigenes Java-Source-
File) Zeile fur Zeile liest und auf die Standard-Ausgabe ausgibt.
Dieses Programm kann dann als Muster fur kompliziertere Programme verwendet
werden.
9.13 Ubung: zeichenweises Kopieren eines Files
Schreiben Sie eine einfache Applikation, die ein Text-File (ihr eigenes Java-Source-
File) Byte fur Byte oder Zeichen fur Zeichen auf ein neues File ("test.out") kopiert.
Diese beiden Programmvarianten konnen dann als Muster fur kompliziertere Programme
verwendet werden.
9.14 Ubung: Lesen eines Files uber das Internet
Schreiben Sie eine einfache Applikation, die ein kurzes Text-File von einem Web-
Server oder FTP-Server liest und Zeile fur Zeile auf die Standard-Ausgabe ausgibt.
Java-Einfuhrung von H. Partl { Kursunterlage 135

10. Networking
Java unterstutzt standardmaig nicht nur das Lesen und Schreiben von lokalen
Dateien (siehe oben) sondern auch die Kommunikation uber Computer-Netze mit
der Technik des Internet-Protokolls TCP/IP.
Die wichtigsten Moglichkeiten, Pakete und Klassen sind:
Zugri auf Web-Server (URL):
Paket java.net
Klassen URL, HttpURLConnection, ...
Java im Web-Server (Servlet):
Pakete javax.servlet, javax.servlet.http
Klassen GenericServlet, HttpServlet, ...
Client-Server-Systeme (Socket):
Paket java.net
Klassen ServerSocket, Socket
Fur die Details wird auf die Online-Dokumentation verwiesen. Beispiele fur die
Verwendung der Klasse URL nden Sie oben. Weitere Hinweise zu einigen dieser
Klassen nden Sie nachfolgend.
10.1 Java im Web-Server (CGI, Servlets)
Web-Server konnen nicht nur fertige Files liefern sondern auch Programme
ausfuhren. Dazu dient die Schnittstelle Common Gateway Interface (CGI). Die
CGI-Programme konnen, eventuell in Abhangigkeit von Benutzer-Eingaben, irgendwelche
Aktionen ausfuhren und die Ergebnisse uber das Hypertext Transfer
Protocol HTTP an den Web-Browser senden.
CGI-Programme konnen im HTML-File oder Applet entweder uber ein Hypertext-
Link aufgerufen werden (nur Ausgabe an den Client) oder uber ein Formular oder
GUI (Eingabe vom Client an das CGI-Programm, Ausgabe an den Client).
CGI-Programme konnen in jeder beliebigen Programmier- oder Script-Sprache geschrieben
werden, auch in Java. In diesem Fall besteht das CGI-Programm aus einem
Shell-Script, in dem die Java Virtual Machine aufgerufen wird, die den Bytecode der
Java-Applikation interpretiert, etwa in einer der folgenden Formen:
java Classname
java Classname Parameter
java -Dvariable=wert Classname
Dies bedeutet, da bei jedem Aufruf des CGI-Programms die Java Virtual Machine
neu gestartet werden mu, was eventuell zu langeren Wartezeiten fuhren kann.
Java-Einfuhrung von H. Partl { Kursunterlage 136

Diesen Nachteil kann man vermeiden, wenn man einen Web-Server verwendet, der
die Java Virtual Machine integriert enthalt und Java-Programme sofort direkt aufrufen
kann (z.B. die neueren Versionen von Apache, Netscape Enterprise Server und
vielen anderen).
Diese Java-Programme werden als Servlets bezeichnet. Der Name "Servlet" ist
analog zu "Applet" gebildet: So wie Applets von einer Java Virtual Machine innerhalb
des Web-Browsers ausgefuhrt werden, so werden Servlets von einer Java
Virtual Machine innerhalb des Web-Servers ausgefuhrt.
Dafur gibt es die Packages javax.servlet und javax.servlet.http sowie ein Java Servlet
Development Kit JSDK mit einem ServletRunner zum Testen von Servlets, bevor
sie im echten Web-Server eingebaut werden.
Die wichtigsten Methoden von Servlets sind:
Wenn der Web-Server startet und die Servlets initialisiert, wird die init-
Methode ausgefuhrt.
Bei jedem Client-Request ("User-Click") wird die service-Methode oder die
von dort je nach der Request-Methode aufgerufene Methode doGet, doPost
etc. ausgefuhrt. Diese Methoden haben 2 Parameter:
{ Mit dem Parameter ServletRequest konnen die vom Client mitgesendeten
Informationen abgefragt werden.
{ Mit dem Parameter ServletResponse mu die Antwort an den Client
gesendet werden.
Mit der Methode getServletInfo kann man das Servlet dokumentieren.
Servlets konnen wie Java-Applikationen auch auf lokale Files, Programme und Systemfunktionen
am Web-Server zugreifen.
Fur ausfuhrlichere Informationen wird auf die Referenzen und die Literatur verwiesen.
Hier nur eine kurze Skizze fur den typischen Aufbau eines Servlet:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class ... extends HttpServlet {
public void init (ServletConfig config)
throws ServletException {
super.init( config );
...
}
public void service
(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
String xxx = req.getParameter("xxx");
Java-Einfuhrung von H. Partl { Kursunterlage 137

}
}
...
resp.setContentType("text/html");
PrintWriter out =
new PrintWriter( resp.getOutputStream() );
out.println (" ... ");
...
out.println (" ... ");
out.flush();
out.close();
public String getServletInfo() {
return "...";
}
10.2 Internet-Protokoll, Server und Clients
Grundbegrie
Vorgangsweise
Java unterstutzt die Kommunikation uber das weltweite Internet und uber interne
Intranets und Extranets mit den Internet-Protokollen TCP und UDP. Dazu mu
das Package java.net importiert werden.
Die programmtechnischen Mechanismen fur Netzverbindungen werden Sockets
(vom englischen Wort fur Steckdose) genannt.
Fur die Adressierung werden Hostname und Portnummer verwendet.
Der Hostname ist eine weltweit bzw. netzweit eindeutige Bezeichnung des Rechners
(Name oder Nummer).
Die Portnummer gibt an, welches Programm auf diesem Rechner die uber das
Netz ubertragenen Informationen verarbeiten soll. Portnummern unter 1024 haben
eine vordenierte Bedeutung und konnen nur mit Supervisor-Privilegien (root
unter Unix) verwendet werden. Portnummern uber 1024 sind "frei". Fur Java-
Anwendungen, die von gewohnlichen Benutzern geschrieben werden, kommen also
meist nur Portnummern uber 1024 in Frage, und man mu sicherstellen, da nicht jemand
anderer auf demselben Rechner dieselbe Portnummer schon fur andere Zwecke
verwendet.
Server sind die Rechner, die ein bestimmtes Service bieten und damit die Kunden
(Clients) "bedienen".
Clients ("Kunden") sind die Benutzer, die das Service des Servers in Anspruch
nehmen wollen, bzw. die von ihnen dafur benutzten Rechner.
Der Server "horcht" (listen) mit Hilfe einer ServerSocket auf eine Portnummer,
d.h. er wartet darauf, da ein Client etwas von ihm will ("einen Request sendet"). In
Java-Einfuhrung von H. Partl { Kursunterlage 138

10.3 Sockets
diesem Fall baut er, meist in einem eigenen Thread, eine Verbindung (connection)
mit dem Client uber eine Socket auf, liest eventuell vom Client kommende Befehle
und Dateneingaben und sendet jedenfalls Meldungen und Ergebnisse an den Client.
Clients bauen uber eine Socket eine Verbindung (connection) zum Server auf,
senden eventuell Befehle oder Daten an den Server und lesen jedenfalls alle vom
Server kommenden Informationen.
ServerSocket (listen, accept)
Die Klasse ServerSocket dient dazu, auf Client-Requests zu warten (listen) und bei
Bedarf eine Verbindung (connection, Socket) zum Client aufzubauen.
Konstruktor:
new ServerSocket (int portnumber)
new ServerSocket (int portnumber, int max)
Mit portnumber gibt man an, auf welche Portnummer die ServerSocket "horcht".
Mit max kann man angeben, wieviele Verbindungen maximal gleichzeitig aktiv sein
durfen (default 50).
Methoden:
Socket accept()
wartet auf eine Verbindungsaufnahme (request) von einem Client und baut
dann eine Verbindung (connection, Socket) zum Client mit der entsprechenden
Portnummer auf.
close()
beendet die ServerSocket.
InetAddress getInetAddress()
liefert den Hostnamen des Servers
int getLocalPort()
liefert die Portnummer
synchronized setSoTimeout(int)
setzt eine Beschrankung fur die maximale Wartezeit des accept(), in Millisekunden,
oder 0 fur unbeschrankt.
synchronized int getSoTimeout()
liefert den Timeout-Wert.
Die Konstruktoren und Methoden konnen die Fehlersituation IOException werfen,
z.B. wenn bereits ein anderes Programm diese Portnummer verwendet.
Java-Einfuhrung von H. Partl { Kursunterlage 139

Socket (connection)
Die Klasse Socket dient fur die Verbindung (connection) zwischen Client und Server.
Konstruktor:
new Socket (String hostname, int portnumber)
baut eine Verbindung zum angegebenen Rechner (z.B. Server) unter der angegebenen
Portnummer auf.
Methoden:
InputStream getInputStream()
onet einen Datenstrom zum Empfangen (Lesen) von Informationen uber die
Verbindung
OutputStream getOutputStream()
onet einen Datenstrom zum Senden (Schreiben) von Informationen uber die
Verbindung
synchronized close()
beendet die Verbindung (connection).
InetAddress getLocalAddress()
liefert den eigenen Hostnamen (z.B. des Client)
InetAddress getInetAddress()
liefert den Hostnamen des anderen Rechners (z.B. des Servers)
int getLocalPort()
liefert die Portnummer
synchronized setSoTimeout(int)
setzt eine Beschrankung fur die maximale Wartezeit beim Lesen im Input-
Stream, in Millisekunden, oder 0 fur unbeschrankt.
synchronized int getSoTimeout()
liefert den Timeout-Wert.
Die Konstruktoren und Methoden konnen die Fehlersituation IOException oder InterruptedException
werfen, z.B. wenn der Rechnername ungultig ist oder der Server
keine Verbindung unter dieser Portnummer akzeptiert oder wenn beim Lesen ein
Timeout passiert.
Die Datenstrome konnen genauso wie "normale" Datenstrome (siehe oben) zum
Lesen bzw. Schreiben verwendet werden und zu diesem Zweck mit weiteren Datenstromen
wie BueredInputStream, BueredOutputStream, DataInputStream,
InputStreamReader, OutputStreamWriter, BueredReader, BueredWriter, Print-
Writer kombiniert werden.
Lese-Befehle (read, readLine) warten dann jeweils, bis entsprechende Daten von der
Gegenstelle gesendet werden und uber die Verbindung ankommen.
Um eine eziente Ubertragung uber das Netz zu erreichen, wird die Verwendung
von Puerung empfohlen, dann darf aber beim Schreiben die Methode ush() nicht
vergessen werden.
Java-Einfuhrung von H. Partl { Kursunterlage 140

Fur die Verarbeitung von "Befehlen", die aus mehreren Wortern oder Feldern bestehen,
kann die Klasse StringTokenizer oder StreamTokenizer verwendet werden
(siehe die Online-Dokumentation).
10.4 Beispiel: typischer Aufbau eines Servers
ServerSocket
Das Hauptprogramm des Servers, das auf die Portnummer "horcht" hat folgenden
Aufbau:
import java.net.* ;
public class ServerMain {
public static void main (String[] args) {
ServerSocket server = null;
Socket s = null;
ServerCon doIt;
Thread t;
int port = ...;
}
}
try {
server = new ServerSocket (port);
while(true) {
s = server.accept();
doIt = new ServerCon (s);
t = new Thread (doIt);
t.start();
}
} catch (Exception e) {
try { server.close(); } catch (Exception e2) {}
System.out.println("ServerMain " +e);
System.exit(1);
}
Socket
Das fur jede Verbindung aufgerufene Server-Programm ist ein Thread mit folgendem
Aufbau:
import java.net.* ;
import java.io.* ;
public class ServerCon implements Runnable {
private Socket socket;
private BufferedReader in;
private PrintWriter out;
Java-Einfuhrung von H. Partl { Kursunterlage 141

public ServerCon (Socket s) {
socket = s;
}
}
public void run() {
try {
out = new PrintWriter
(new BufferedWriter
(new OutputStreamWriter
(socket.getOutputStream() ) ) );
in = new BufferedReader
(new InputStreamReader
(socket.getInputStream() ) );
...
... in.readLine() ...
...
out.println(...);
out.flush();
...
in.close();
out.close();
socket.close();
} catch (Exception e) {
System.out.println("ServerCon " + e);
}
}
10.5 Beispiel: typischer Aufbau eines Client
import java.net.* ;
import java.io.* ;
public class ClientCon {
public static void main (String[] args) {
int port = ...;
String host = "...";
Socket socket;
BufferedReader in;
PrintWriter out;
try {
socket = new Socket (host, port);
out = new PrintWriter
(new BufferedWriter
(new OutputStreamWriter
(socket.getOutputStream() ) ) );
in = new BufferedReader
(new InputStreamReader
(socket.getInputStream() ) );
Java-Einfuhrung von H. Partl { Kursunterlage 142

}
}
...
out.println(...);
out.flush();
...
... in.readLine() ...
...
out.close();
in.close();
socket.close();
} catch (Exception e) {
System.out.println ("ClientCon " + e);
}
10.6 Ubung: einfache Client-Server-Applikation
Schreiben Sie einen Server (als Applikation), der auf Verbindungsaufnahmen wartet
und an jeden Client zunachst einen Willkommensgru und dann - 6 mal (also ca.
1 Minute lang) in Abstanden von ungefahr 10 Sekunden - jeweils zwei Textzeilen
liefert, die einen kurzen Text und Datum und Uhrzeit enthalten, und schlielich die
Verbindung zum Client schliet.
Fur die Datums- und Zeitangabe verwenden Sie das Standard-Format der aktuellen
Uhrzeit, das Sie mit
( new Date() ).toString()
erhalten, auch wenn dabei nicht die richtige Zeitzone verwendet wird. (Mehr uber
die Problematik von Datums- und Zeitangaben nden Sie im Kapitel uber Datum
und Uhrzeit).
Schreiben Sie einen Client (als Applikation), der mit diesem Server Verbindung
aufnimmt und alle Informationen, die vom Server gesendet werden, Zeile fur Zeile
auf die Standard-Ausgabe ausgibt.
Testen Sie dieses System. Die Beendigung des Servers (und auch des Clients, falls
er Probleme macht) erfolgt durch Abbruch des Programmes mittels Ctrl-C.
Fur diese Ubung mussen Sie die Hostnamen der verwendeten Rechner (innerhalb
des lokalen Netzes) kennen und sich auf eine Portnummer einigen.
Java-Einfuhrung von H. Partl { Kursunterlage 143

11. System-Funktionen und Utilities
Einer der groen Vorteile von Java ist die umfangreiche Klassenbibliothek, die fur
eine Unmenge von Anwendungsbereichen bereits fertige Programme und Klassen
enthalt, die einfach und bequem verwendet werden konnen.
Ein paar typische Beispiele fur besonders interessante Klassen sind:
Paket java.lang
Klassen Object, Class, System, Runtime, Process,
String, StringBuer, Math, Integer, Double ...
Paket java.util
Date, GregorianCalendar ...
StringTokenizer,
Vector, Hashtable, LinkedList ...
Paket java.text
SimpeDateFormat, DecimalFormat, ...
Paket java.awt
Toolkit, PrintJob ...
Pakete javax.swing, javax.swing.xxxx
ListModel, TableModel, TreeModel ...
Fur die Details wird auf die Online-Dokumentation verwiesen. Zu einigen dieser
Klassen nden Sie nachfolgend ein paar Hinweise.
11.1 Datum und Uhrzeit (Date)
Fur die Verarbeitung von Datums- und Zeitangaben mu das Package java.util importiert
werden, fur die DateFormat-Klassen zusatzlich das Package java.text.
Im JDK ab Version 1.1 mu fur die "richtige", fur alle Lander der Welt brauchbare
Verarbeitung von Datums- und Zeitangaben eine Kombination von mehreren Klassen
fur Datum und Uhrzeit, Datums-Berechnungen (Kalender), Zeitzonen, Sprachen
und Ausgabeformate verwendet werden. Ein kurzes Beispiel folgt unten.
Die Verwendung ist dementsprechend kompliziert, auerdem enthalten die meisten
Implementierungen auch verschiedene Fehler (Bugs).
Fur einfache Anwendungen konnen die alten Funktionen der Date-Klasse Version
1.0 verwendet werden (siehe anschlieend).
Java-Einfuhrung von H. Partl { Kursunterlage 144

11.2 Date Version 1.0
Konstruktoren
Die hier beschriebenen Funktionen der Klasse Date werden vom Compiler mit der
Warnung "deprecated" versehen, sind aber fur einfache Anwendungen ausreichend
und wesentlich einfacher zu programmieren als die neuen Funktionen von Version
1.1 (siehe unten).
new Date()
setzt Datum und Uhrzeit auf heute und die aktuelle Zeit.
new Date (year, month, day)
setzt das Datum auf den angegebenen Tag (siehe unten) und die Uhrzeit auf
0 Uhr.
new Date(year, month, day, hour, minutes)
setzt Datum und Uhrzeit auf die angegebene Zeit (siehe unten).
new Date(year, month, day, hour, minutes, seconds)
setzt Datum und Uhrzeit auf die angegebene Zeit (siehe unten).
new Date(long)
setzt Datum und Uhrzeit auf die angegebene Zeit im Millisekunden (siehe
unten).
Jahre mussen relativ zum Jahr 1900 angegeben werden, also
-8 bedeutet das Jahr 1892,
98 bedeutet das Jahr 1998,
101 bedeutet das Jahr 2001,
1990 bedeutet das Jahr 3890.
Monate mussen im Bereich 0 bis 11 angegeben werden, also
0fur Janner,
1fur Februar, usw. bis
11 fur Dezember.
Dies ist fur die Verwendung als Array-Index gunstig, fuhrt aber sonst leicht zu
Irrtumern. Es wird daher empfohlen, statt der Zahlenangaben lieber die in der Klasse
Calendar (Version 1.1) denierten symbolischen Namen zu verwenden:
Calendar.JANUARY fur Janner,
Calendar.FEBRUARY fur Februar,
Calendar.MARCH fur Marz, usw. bis
Calendar.DECEMBER fur Dezember.
Tage innerhalb der Monate werden wie gewohnt im Bereich 1 bis 31 angegeben.
Wochentage werden im Bereich 0 bis 6 angegeben, dafur sollten aber lieber die
symbolischen Namen
Calendar.SUNDAY fur Sonntag,
Calendar.MONDAY fur Montag, usw. bis
Calendar.SATURDAY fur Samstag
verwendet werden.
Java-Einfuhrung von H. Partl { Kursunterlage 145

Stunden werden im Bereich 0 bis 23 angegeben, Minuten und Sekunden im
Bereich 0 bis 59.
Fur alle bisher genannten Zahlen wird der Typ int verwendet.
Fur die Berechnung von Zeitdierenzen wird eine Groe in Millisekunden verwendet,
deren Nullpunkt am 1. Janner 1970 um 0 Uhr liegt. Dafur wird der Typ long
verwendet.
Methoden
int getTime()
liefert den Zeitpunkt in Millisekunden (siehe oben).
int getYear()
liefert das Jahr (relativ zu 1900, siehe oben).
int getMonth()
liefert den Monat (0-11, siehe oben).
int getDate()
liefert den Tag innerhalb des Monats (1-31).
int getDay()
liefert den Wochentag (0-6, siehe oben).
int getHours()
liefert die Stunde (0-23).
int getMinutes()
liefert die Minuten (0-59).
int getSeconds()
liefert die Sekunden (0-59, bei Schaltsekunden auch 60).
setTime(long)
setzt Datum und Uhrzeit auf den angegebenen Zeitpunkt in Millisekunden
(siehe oben).
setYear(int)
setMonth(int)
setDate(int)
setHours(int)
setMinutes(int)
setSeconds(int)
andert jeweils nur das angegebene Feld (siehe oben).
boolean after(Date)
liefert true, wenn der Zeitpunkt spater als der angegebene liegt.
boolean before(Date)
liefert true, wenn der Zeitpunkt fruher als der angegebene liegt.
boolean equals(Date)
liefert true, wenn die beiden Zeiten gleich sind.
Java-Einfuhrung von H. Partl { Kursunterlage 146

String toString(Date)
liefert einen TextString, der Datum, Uhrzeit und Zeitzone in dem auf Unix-
Rechnern ublichen Format angibt.
String toGMTString(Date)
liefert einen TextString, der Datum und Uhrzeit in dem am Internet (z.B. im
Date-Header von Electronic Mail) ublichen Format angibt.
String toLocaleString(Date)
liefert einen TextString, der Datum, Uhrzeit und Zeitzone in einer auf dem
lokalen System (in der lokalen Sprache und Zeitzone) ublichen Format angibt.
Auerdem gibt es eine statische Methode
long Date.parse (String)
mit der ein Datums-String in einem genormten Format (z.B. Unix- oder Internet-
Format, siehe oben) in den entsprechenden Zeitpunkt in Millisekunden umgewandelt
wird.
Wenn man mit den vorgefertigten Ausgabeformaten nicht zufrieden ist, kann man
eine eigene Version einer DateFormat-Klasse schreiben, die die gewunschte Datums-
Darstellung liefert. Damit die Verwendung zur Klasse DateFormat von Version 1.1
kompatibel ist, sollte diese Methode die folgende Signature haben:
public String format (Date d)
Beispiel fur ein einfaches, selbst geschriebenes DateFormat:
import java.util.*;
public class MyDateFormat { // Date Version 1.0
public String format (Date d) {
String s;
// like SimpleDateFormat("d. M. yyyy")
s = d.getDate() + ". " +
(d.getMonth()+1) + ". " +
(d.getYear()+1900);
return s;
}
}
Beispiel fur die einfache Verarbeitung von Datums-Angaben in Version 1.0:
import java.util.*;
public class Date10 { // Date Version 1.0
public static void main (String[] args) {
MyDateFormat df = new MyDateFormat();
Date today = new Date();
long todayInt = today.getTime();
int currentYear = today.getYear() + 1900;
System.out.println ("Today is " +
Java-Einfuhrung von H. Partl { Kursunterlage 147

df.format(today) );
System.out.println ("The current year is " +
currentYear );
long yesterdayInt = todayInt - 24*60*60*1000L;
Date yesterday = new Date (yesterdayInt);
System.out.println ("Yesterday was " +
df.format(yesterday) );
long next30Int = todayInt + 30*24*60*60*1000L;
Date next30 = new Date (next30Int);
System.out.println ("30 days from today is " +
df.format(next30) );
Date marriage = new Date (90, Calendar.FEBRUARY, 7);
long marriageInt = marriage.getTime();
int marriageYear = marriage.getYear() + 1900;
System.out.println ("Married on " +
df.format(marriage) );
System.out.println ("Married for " +
(currentYear-marriageYear) + " years." );
System.out.println ("Married for " +
(todayInt-marriageInt)/(24*60*60*1000L) +
" days." );
Date silver= new Date (marriageInt);
silver.setYear( marriage.getYear()+25 );
// works for all dates except Feb 29th
System.out.println ("Silver marriage on " +
df.format(silver) );
if ( silver.getYear() == today.getYear() &&
silver.getMonth() == today.getMonth() &&
silver.getDate() == today.getDate() )
System.out.println ("Congratulations!");
}
}
Java-Einfuhrung von H. Partl { Kursunterlage 148

11.3 Date und Calendar Version 1.1
Klassen
Im JDK 1.1 soll fur die "richtige",fur alle Lander der Welt brauchbare Verarbeitung
von Datums- und Zeitangaben eine Kombination der folgenden Klassen verwendet
werden:
Calendar bzw. GregorianCalendar fur Datums- und Zeit-Berechnungen
(mit Fehlerkontrollen)
DateFormat bzw. SimpleDateFormat fur die Darstellung von Datum und
Uhrzeit als Textstring
TimeZone bzw. SimpleTimeZone fur die Zeitzone
Locale fur das Land oder die Sprache
Date fur Zeitpunkte
Die Klasse Date soll in diesem Fall nur fur die Speicherung eines Zeitpunkts verwendet
werden. Von den oben fur Version 1.0 angefuhrten get- und set-Methoden sollen
nur diejenigen verwendet werden, die den Zeitpunkt in Millisekunden angeben. Fur
die Angabe von Jahr, Monat, Tag und Uhrzeit sollen stattdessen die "besseren"
Methoden des Kalenders verwendet werden.
Die richtige Kombination und Verwendung dieser Klassen ist einigermaen kompliziert.
Auerdem enthalten manche Implementierungen ein paar Fehler (Bugs) oder
unterstutzen nicht alle Lander und Sprachen. Deshalb greifen viele Java-Benutzer
auf die alte Version 1.0 oder auf selbst geschriebene Klassen wie z.B. BigDate zuruck.
Hier wird nur ein kurzes Beispiel fur typische Anwendungen gegeben. Fur die Details
wird auf die Online-Dokumentation und auf die Fragen und Antworten in den
einschlagigen Usenet-Newsgruppen verwiesen (siehe Referenzen).
Beispiel fur Datums- und Zeit-Angaben und -Berechungen in Version 1.1:
import java.util.*;
import java.text.*;
public class Date11 { // Date Version 1.1
public static void main (String[] args) {
DateFormat df = new SimpleDateFormat ("d. MMMM yyyy",
Locale.GERMANY);
DateFormat tf = new SimpleDateFormat ("HH.mm",
Locale.GERMANY);
SimpleTimeZone mez = new SimpleTimeZone( +1*60*60*1000,
"CET");
mez.setStartRule (Calendar.MARCH, -1, Calendar.SUNDAY,
2*60*60*1000);
mez.setEndRule (Calendar.OCTOBER, -1, Calendar.SUNDAY,
2*60*60*1000);
Java-Einfuhrung von H. Partl { Kursunterlage 149

Calendar cal = GregorianCalendar.getInstance (mez);
cal.setLenient(false); // do not allow bad values
Date today = new Date();
System.out.println ("Heute ist der " +
df.format(today) );
System.out.println ("Es ist " +
tf.format(today) + " Uhr");
cal.setTime(today);
int currentYear = cal.get(Calendar.YEAR);
System.out.println ("Wir haben das Jahr " +
currentYear );
cal.add (Calendar.DATE, -1);
Date yesterday = cal.getTime();
System.out.println ("Gestern war der " +
df.format(yesterday) );
try {
cal.set (1997, Calendar.MAY, 35);
cal.setTime(cal.getTime()); // to avoid a bug
Date bad = cal.getTime();
System.out.println ("Bad date was set to " +
df.format(bad) );
} catch (Exception e) {
System.out.println ("Invalid date was detected "
+ e);
}
cal.set (1996, Calendar.FEBRUARY, 29);
cal.setTime(cal.getTime()); // to avoid a bug
Date marriage = cal.getTime();
System.out.println ("geheiratet am " +
df.format(marriage) );
long todayInt = today.getTime();
long marriageInt = marriage.getTime();
long diff = todayInt - marriageInt;
System.out.println ("seit " +
diff/(24*60*60*1000L) +
" Tagen verheiratet" );
int marriageYear = cal.get(Calendar.YEAR);
System.out.println ("seit " +
(currentYear-marriageYear) +
" Jahren verheiratet" );
cal.setTime(marriage);
Java-Einfuhrung von H. Partl { Kursunterlage 150

* bypass leap year error in add YEAR method: */
if ( (cal.get(Calendar.MONTH) == Calendar.FEBRUARY) &&
(cal.get(Calendar.DATE) == 29) ) {
cal.add (Calendar.DATE, 1);
}
/* end of leap year error bypass */
cal.add (Calendar.YEAR, 25);
Date silverMarriage = cal.getTime();
System.out.println ("Silberne Hochzeit am " +
df.format(silverMarriage) );
}
}
String todayDay = df.format(today);
String silverDay = df.format(silverMarriage);
// compare only day, not time:
if ( silverDay.equals(todayDay) )
System.out.println ("Herzlichen Glueckwunsch!");
11.4 Zeitmessung
Fur die Berechnung von Laufzeiten kann man entweder Date-Objekte (siehe oben)
oder die folgende statische Methode verwenden:
static long System.currentTimeMillis()
liefert den aktuellen Zeitpunkt in Millisekunden.
Beispiel:
public static void main (String[] args) {
long startTime = System.currentTimeMillis();
... // do something
long endTime = System.currentTimeMillis();
long runTime = endTime - startTime;
float runSeconds = ( (float)runTime ) / 1000.F;
System.out.println ("Run time was " + runSeconds + " seconds." );
}
Java-Einfuhrung von H. Partl { Kursunterlage 151

11.5 Ausdrucken (PrintJob, PrinterJob)
PrintJob
Das AWT Version 1.1 enthalt auch eine Klasse PrintJob, mit der ein Printout erzeugt
und mit Hilfe des systemspezischen Printer-Selection-Dialog auf einem Drucker
ausgedruckt werden kann.
Dazu dienen die folgenden Methoden in den verschiedenen Klassen:
Toolkit getToolkit()
liefert bei einem Frame das Toolkit, das fur die Darstellung des Frame und
der in ihm enthaltenen Komponenten auf dem System zustandig ist.
PrintJob getPrintjob(Frame, String, Properties)
erzeugt bei einem Toolkit einen Printjob fur das Frame, mit dem angegebenen
Title-String und eventuellen Druckereigenschaften (oder null).
Graphics getGraphics()
liefert bei einem Printjob das Graphics-Objekt, das einen Printout enthalten
kann. Fur jede neue Seite soll ein neues Graphics-Element angelegt werden.
Dieses Graphics-Element kann mit beliebigen Graphik-Operationen gefullt
werden. Meistens verwendet man aber nur die folgenden beiden Methoden:
print (Graphics g)
bei einer AWT-Komponente stellt einen Printout nur dieser Komponente in
das Graphics-Objekt.
printAll (Graphics g)
bei einem AWT-Container wie z.B. Frame oder Applet stellt einen Printout
dieses Containers mit seinem gesamten Inhalt in das Graphics-Objekt.
dispose()
fur das Graphics-Objekt setzt das fertig erstellte Graphics-Objekt (eine Seite
des Printout) in den Printout.
end()
fur den PrintJob beendet den Printout. Nun wird er vom Print-Spooling des
Systems an den Drucker gesendet, und danach kann der Drucker wieder fur
andere Jobs verwendet werden.
Beispielskizze:
Frame f = new Frame ("Test");
f.setLayout(...);
f.add(...);
...
Toolkit t = f.getToolkit();
PrintJob pJob = t.getPrintjob (f, "Test", null);
Graphics g = pJob.getGraphics();
f.printAll(g); // or g.drawxxx ...
g.dispose();
pJob.end();
Java-Einfuhrung von H. Partl { Kursunterlage 152

Wenn man ein Applet ausdrucken will, mu man mit getParent() das zugehorige
Frame bestimmen und dann dieses in getPrintJob angeben. Auerdem mu der
Benutzer dem Applet mit dem SecurityManager die Erlaubnis zum Drucken am
Client-Rechner geben.
PrinterJob
Ab JDK 1.2 gibt es eine neue Klasse PrinterJob mit den Interfaces Printable und
Pageable im Package java.awt.print.
Dazu dienen unter anderem die folgenden Klassen und Methoden:
PrinterJob.getPrinterJob()
liefert ein PrinterJopb-Objekt.
setPrintable (Printable)
gibt an, welches Objekt gedruckt werden soll. Dieses Objekt mu das Interface
Printable implementieren, also eine print-Methode enthalten.
Die print-Methode im PrinterJob bewirkt, da die print-Methode des
Printable-Objekts aufgerufen und das Ergebnis an den Drucker gesendet wird
(oder die PrintException geworfen wird).
Die print-Methode des Printable-Objekts hat die folgenden Parameter:
{ das Graphics-Objekt, das wie in der paint-Methode (oder durch Aufruf
der paint-Methode oder der printAll-Methode) mit der graphischen Information
gefullt werden mu, eventuell mit Verschiebung des Eckpunktes
mittels translate,
{ ein PageFormat-Objekt, und
{ die Seitennummer (pageIndex).
und mu einen der folgenden beiden Werte zuruckgeben:
{ PrinterJob.PAGE EXISTS
wenn eine Seite erzeugt wurde,
{ PrinterJob.NO SUCH PAGE
wenn keine Seite erzeugt wurde.
Beispielskizze:
public class Xxxx extends Frame
implements ActionListener, Printable {
...
public void actionPerformed(ActionEvent e) {
if (e.getSource() == printButton) {
PrinterJob printJob = PrinterJob.getPrinterJob();
printJob.setPrintable(this);
try {
printJob.print();
} catch (PrintException ex) {
}
Java-Einfuhrung von H. Partl { Kursunterlage 153

Sonstige Moglichkeiten
}
}
public int print(Graphics g, PageFormat pageFormat, int pageIndex) {
if (pageIndex == 0) {
g.translate(100, 100);
paint(g); // or: this.printAll(g); or: g.drawxxx ...
return Printable.PAGE_EXISTS;
}
return Printable.NO_SUCH_PAGE;
}
}
Auerdem konnen mit PrinterJob auch Objekte, die das Interface Pageable implementieren,
ausgedruckt werden, das sind Dokumente, die aus mehreren Seiten
(Page) bestehen, mit Seiteninhalt, Kopf- und Fuzeilen und Seitennummern. Die
Klasse Book ist eine Klasse, die dieses Interface implementiert.
Weitere Alternativen zur Verwendung von PrintJob sind die Ausgabe auf das
Pseudo-File mit den Filenamen "lpt1" oder die Verwendung der Print-Screen-
Funktion durch den Benutzer, um den aktuellen Fensterinhalt (z.B. eine Web-Page
mit einem Applet mit Benutzer-Eingaben) auszudrucken. In manchen Fallen kann
es auch gunstig sein, die Information, die ausgedruckt werden soll, als HTML-File
zu erzeugen, das dann vom Benutzer in seinem Web-Browser angezeigt und ausgedruckt
werden kann.
11.6 Ausfuhrung von Programmen (Runtime, exec)
Mit der Klasse Runtime und deren Methode exec kann man innerhalb von Applikationen
andere Programme (Hauptprogramme, Prozesse) starten. Dies hat den Vorteil,
da man alle Funktionen des Betriebssystems ausnutzen kann, und den Nachteil,
da die Java-Applikation dadurch nicht mehr Plattform- oder Rechner-unabhangig
ist
Applets konnen im allgemeinen keine anderen Programme starten.
Fur die Verwendung von Runtime und Process mu das Package java.util importiert
werden, im Fall von Ein-Ausgabe-Operationen auch java.io.
Die fur diesen Zweck wichtigsten Methoden der Klasse Runtime sind:
static Runtime Runtime.getRuntime()
liefert das Runtime-Objekt der Java Virtual Machine
Process exec(String)
erzeugt einen Proze, der den im String enthaltenen Befehl (Befehlswort und
eventuell Parameter) ausfuhrt.
Process exec(String[])
erzeugt einen Proze, der den im String-Array enthaltenen Befehl (Befehlswort
und Parameter) ausfuhrt.
Java-Einfuhrung von H. Partl { Kursunterlage 154

Die exec-Methode kann die Fehlersituation IOException werfen, wenn es den Befehl
(das Programm) nicht gibt.
Die wichtigsten Methoden der Klasse Process sind:
waitFor()
wartet, bis der Proze fertig gelaufen ist.
destroy()
bricht den Proze ab.
int exitValue()
liefert den Return-Code (Exit-Status) des Prozesses (meist 0 fur okay, ungleich
0fur Fehler)
InputStream getInputStream()
liefert einen InputStream zum Lesen der vom Proze geschriebenen Standard-
Ausgabe.
InputStream getErrorStream()
liefert einen InputStream zum Lesen der vom Proze geschriebenen Fehler-
Ausgabe.
OutputStream getOutputStream()
liefert einen OutputStream zum Schreiben der vom Proze gelesenen Standard-
Eingabe.
Die waitFor-Methode kann die Fehlersituation InterruptedException werfen, wenn
das Programm wahrend des Wartens abgebrochen wird.
Beispiel (Unix):
try {
Process p = Runtime.getRuntime().exec
("/usr/local/bin/elm");
p.waitFor();
} catch (Exception e) {
System.err.println("elm error " +e);
}
Das analoge Beispiel fur einen PC enthalt
Process p = Runtime.getRuntime().exec
("c:\\public\\pegasus\\pmail.exe");
Befehlsnamen mussen im allgemeinen mit dem Pfad angegeben werden.
Auf PCs mu man beachten, da man als Befehlsname nur "echte" exe- oder com-
Programme angeben kann. Die meisten DOS-Befehle wie DIR oder COPY sind aber
nicht eigene Programm-Files sondern werden von der "Shell" COMMAND.COM
(unter DOS, Windows 3 und Windows 95) bzw. CMD.EXE (unter Windows NT)
ausgefuhrt. Beispiel:
Process p = Runtime.getRuntime().exec
("command.com /c dir");
Java-Einfuhrung von H. Partl { Kursunterlage 155

Wenn man unter Unix eine Eingabe- oder Ausgabe-Umleitung oder Pipe fur den
Befehl angeben will, mu man analog zuerst eine Unix-Shell aufrufen und dieser
Shell dann den kompletten Befehl (einschlielich der Umleitung) als einen einzigen
String-Parameter angeben. Beispiel:
Process p = Runtime.getRuntime().exec (new String[] {
"/usr/bin/sh", "-c", "/usr/bin/ls > ls.out" } );
Mit Hilfe der Methode getOutputStream kann man Eingaben vom Java-Programm
an den Proze senden. Mit Hilfe der Methoden getInputStream und getErrorStream
kann man die vom Proze erzeugte Ausgabe im Java-Programm verarbeiten. Beispiel:
try {
String cmd = "/usr/bin/ls -l /opt/java/bin";
String line = null;
Process p = Runtime.getRuntime().exec(cmd);
BufferedReader lsOut = new BufferedReader
(new InputStreamReader
(p.getInputStream() ) );
while( ( line=lsOut.readLine() ) != null) {
System.out.println(line);
}
} catch (Exception e) {
System.err.println("ls error " +e);
}
Wenn man allerdings zwei oder alle drei dieser Eingabe- und Ausgabe-Strome lesen
bzw. schreiben will, mu man das in getrennten Threads tun, weil sonst ein auf
Eingabe wartendes Read die anderen blockiert.
11.7 Verwendung von Unterprogrammen (native methods, JNI)
Man kann innerhalb von Java-Applikationen auch Unterprogramme aufrufen, die
in einer anderen Programmiersprache geschrieben sind, insbesondere in den Programmiersprachen
C und C++. Solche Unterprogramme werden als "eingeborene"
(native) Methoden bezeichnet, das entsprechende Interface als Java Native Interface
(JNI). Der Vorteil liegt darin, da man samtliche von dieser Programmiersprache
unterstutzten Funktionen und Unterprogramm-Bibliotheken verwenden kann.
Der Nachteil liegt darin, da die Java-Applikation dann im allgemeinen nicht mehr
Plattform- oder auch nur Rechner-unabhangig ist.
Der Vorgang lauft in folgenden Schritten ab:
Zunachst wird eine Java-Klasse geschrieben, die folgende Elemente enthalt:
die Deklaration der native Methode. Diese Deklaration enthalt nur die Signature,
mit der zusatzlichen Angabe "native", und dann nur einen Strichpunkt,
keinen Statement-Block. Dieser wird spater in der Programmiersprache C oder
C++ geschrieben.
einen statischen Block (static), der die zugehorige Laufzeit-Bibliothek ladt.
Beispiel:
Java-Einfuhrung von H. Partl { Kursunterlage 156

public class ClassName {
public native void name() ;
static {
System.loadLibrary ("libname");
}
}
Diese Klasse kann wie jede normale Klasse verwendet werden, d.h. man kann Objekte
dieser Klasse mit new anlegen und ihre Methoden fur dieses Objekt aufrufen.
Als nachstes werden mit dem Hilfsprogramm javah Header-Files und ein sogenanntes
Stub-File erstellt. Diese Files enthalten die entsprechenden Deklarationen in C-
Syntax, die dann vom C-Programm verwendet werden. Es gibt auch Umwandlungs-
Programme fur die Umwandlung von Java-Strings in C-Strings und umgekehrt.
Unter Verwendung dieser Hilfsmittel wird nun das C-Programm geschrieben und
ubersetzt und in einer Library (Bibliotheks-File) fur dynamisches Laden zur Laufzeit
gespeichert. Diese Library mu in die Environment-Variable LD LIBRARY PATH
hinzugefugt werden.
Schlielich werden die Java-Klassen mit dem Java-Compiler javac ubersetzt und
mit dem Befehl java ausgefuhrt. Dabei wird das C-Programm automatisch aus der
vorher erstellten Library dazugeladen.
Fur die Details wird auf die Online-Dokumentation und auf die einschlagige Literatur
verwiesen.
Java-Einfuhrung von H. Partl { Kursunterlage 157

12. Datenbanken
Zu den wichtigsten Anwendungsgebieten von Java zahlen User-Interfaces zu Datenbanksystemen.
Das Java-Programm kann dabei ein Applet, eine Applikation oder ein Servlet sein
und kann am selben Rechner wie die Datenbank laufen oder auch auf einem anderen
Rechner und von dort uber das Internet oder ein Intranet auf die Datenbank
zugreifen (siehe Datenbank-Anwendungen uber das Internet).
Die "Java Database Connectivity" (JDBC) ist im Sinne der Plattformunabhangigkeit
von Java so aufgebaut, da das Java-Programm von der Hard- und
Software des Datenbanksystems unabhangig ist und somit fur alle Datenbanksysteme
(MS-Access, Oracle etc.) funktioniert.
Mit den im JDBC enthaltenen Java-Klassen (Package java.sql) kann man Daten in
der Datenbank so bequem speichern und abfragen wie beim Lesen und Schreiben
von Dateien oder Sockets. Auf diese Weise kann man die Vorteile von Java, die
vor allem bei der Gestaltung von (graphischen und plattformunabhangigen) User-
Interfaces liegen, mit der Machtigkeit von Datenbanksystemen verbinden.
12.1 Relationale Datenbanken
Relationale Datenbanken bestehen aus Tabellen (Relationen). Die Tabellen entsprechen
in etwa den Klassen in der Objektorientierten Programmierung. Beispiele:
Eine Personaldatenbank enthalt Tabellen fur Mitarbeiter, Abteilungen, Projekte.
Eine Literaturdatenbank entalt Tabellen fur Bucher, Zeitschriften, Autoren, Verlage.
Diese Tabellen konnen in Beziehungen zueinander stehen (daher der Name "Relation").
Beispiele: Ein Mitarbeiter gehort zu einer Abteilung und eventuell zu einem
oder mehreren Projekten. Jede Abteilung und jedes Projekt wird von einem Mitarbeiter
geleitet. Ein Buch ist in einem Verlag erschienen und hat einen oder mehrere
Autoren.
Beispielskizze fur eine Tabelle "Mitarbeiter":
Abteilung Vorname Zuname Geburtsjahr Gehalt
EDV-Zentrum Hans Fleiig 1972 24000.00
EDV-Zentrum Grete Tuchtig 1949 32000.00
Personalstelle Peter Gscheitl 1968 16000.00
Jede Zeile der Tabelle (row, Tupel, Record) enthalt die Eigenschaften eines Elementes
dieser Menge, entspricht also einem Objekt. In den obigen Beispielen also
jeweils ein bestimmter Mitarbeiter, eine Abteilung, ein Projekt, ein Buch, ein Autor,
ein Verlag. Jede Zeile mu eindeutig sein, d.h. verschiedene Mitarbeiter mussen sich
durch mindestens ein Datenfeld (eine Eigenschaft) unterscheiden.
Java-Einfuhrung von H. Partl { Kursunterlage 158

Jede Spalte der Tabelle (column, eld, entity) enthalt die gleichen Eigenschaften
der verschiedenen Objekte, entspricht also einem Datenfeld. Beispiele: Vorname,
Zuname, Geburtsjahr und Abteilung eines Mitarbeiters, oder Titel, Umfang, Verlag
und Erscheinungsjahr eines Buches.
Ein Datenfeld (z.B. die Sozialversicherungsnummer eines Mitarbeiters oder die ISBN
eines Buches) oder eine Gruppe von Datenfeldern (z.B. Vorname, Zuname und
Geburtsdatum einer Person) mu eindeutig sein, sie ist dann der Schlussel (key)
zum Zugri auf die Zeilen (Records) in dieser Tabelle. Eventuell mu man dafur eigene
Schlusselfelder einrichten, z.B. eine eindeutige Projektnummer, falls es mehrere
Projekte mit dem gleichen Namen gibt.
Die Beziehungen zwischen den Tabellen konnen auch durch weitere Tabellen (Relationen)
dargestellt werden, z.B. eine Buch-Autor-Relation, wobei sowohl ein bestimmtes
Buch als auch ein bestimmter Autor eventuell in mehreren Zeilen dieser
Tabelle vorkommen kann, denn ein Buch kann mehrere Autoren haben und ein
Autor kann mehrere Bucher geschrieben haben. Das gleiche gilt fur die Relation
Mitarbeiter-Projekt.
Das Konzept (Design) einer Datenbank ist eine komplexe Aufgabe, es geht dabei
darum, alle relevanten Daten (Elemente, Entities) und alle Beziehungen zwischen
ihnen festzustellen und dann die logische Struktur der Datenbank entsprechend festzulegen.
Die logisch richtige Aufteilung der Daten in die einzelnen Tabellen (Relationen)
wird als Normalisierung der Datenbank bezeichnet, es gibt dafur verschiedene
Regeln und Grundsatze, ein Beispiel ist die sogenannte dritte Normalform.
Fast alle Datenbanksysteme seit Ende der 70er- oder Beginn der 80er-Jahre sind
relationale Datenbanksysteme und haben damit die in den 60er- und 70er-Jahren
verwendeten, blo hierarchischen Datenbanksysteme abgelost.
Eine zukunftweisende Weiterentwicklung der Relationalen Datenbanken sind die
"Objektrelationalen Datenbanken", bei denen - vereinfacht gesprochen - nicht nur
primitive Datentypen sondern auch komplexe Objekte als Datenfelder moglich sind,
ahnlich wie in der objektorientierten Programmierung.
Datenschutz und Datensicherheit
Datenbanken enthalten meist umfangreiche und wichtige, wertvolle Informationen.
Daher mu bei Datenbanksystemen besonderer Wert auf den Datenschutz und die
Datensicherheit gelegt werden.
Die Datenbank-Benutzer werden in 2 Gruppen aufgeteilt: den Datenbankadministrator
und die Datenbankanwender.
Der Datenbankadministrator legt mit der Data Denition Language (DDL) die
logischen Struktur der Datenbank fest und ist fur den Datenschutz, die Vergabe der
Berechtigungen an die Datenbankanwender und fur die Datensicherung verantwortlich.
Die Datenbankanwender konnen mit einer Data Manipulation Language (DML)
oder Query Language die Daten in der Datenbank speichern, abfragen oder
verandern.
Java-Einfuhrung von H. Partl { Kursunterlage 159

Datenkonsistenz
Mit der Hilfe von Usernames und Pawortern werden die einzelnen Benutzer identiziert,
und der Datenbankadministrator kann und mu sehr detailliert festlegen,
welcher Benutzer welche Aktionen (lesen, hinzufugen, loschen, verandern) mit welchen
Teilen der Datenbank (Tabellen, Spalten, Zeilen) ausfuhren darf.
Die in einer Datenbank gespeicherten Informationen stehen meistens in Beziehungen
zueinander, bestimmte Informationen hangen in eventuell recht komplexer Weise
von anderen, ebenfalls in der Datenbank gespeicherten Informationen ab. Es mu
sichergestellt werden, da die gesamte Datenbank immer in einem gultigen Zustand
ist, da also niemals ungultige oder einander widersprechende Informationen darin
gespeichert werden.
Dies wird mittels Transaktionen erreicht: Unter einer Transaktion versteht man
eine Folge von logisch zusammengehorenden Aktionen, die nur entweder alle
vollstandig oder uberhaupt nicht ausgefuhrt werden durfen.
Beispiel: Wenn zwei Mitarbeiter den Arbeitsplatz tauschen, mu sowohl beim Mitarbeiter
1 der Arbeitsplatz von A auf B als auch beim Mitarbeiter 2 der Arbeitsplatz
von B auf A geandert werden. Wurde bei einer dieser beiden Aktionen ein Fehler
auftreten, die andere aber trotzdem ausgefuhrt werden, dann hatten wir plotzlich 2
Mitarbeiter auf dem einen Arbeitsplatz und gar keinen auf dem anderen.
Ein anderes Beispiel: Wenn in der Datenbank nicht nur die Gehalter der einzelnen
Mitarbeiter sondern auch die Summe aller Personalkosten (innerhalb des Budgets)
gespeichert ist, dann mussen bei jeder Gehaltserhohung beide Felder um den gleichen
Betrag erhoht werden, sonst stimmen Budgetplanung und Gehaltsauszahlung nicht
uberein.
Um solche Inkonsistenzen zu vermeiden, mussen zusammengehorende Aktionen jeweils
in eine Transaktion zusammengefat werden:
Wenn alle Aktionen erfolgreich abgelaufen sind, wird die Transaktion beendet
(commit) und die Datenbank ist in einem neuen gultigen Zustand.
Falls wahrend der Transaktion irgendein Fehler auftritt, werden alle seit Beginn
der Transaktion ausgefuhrten unvollstandigen Anderungen ruckgangig
gemacht (rollback), und die Datenbank ist wieder in demselben alten, aber
gultigen Zustand wie vor Beginn der versuchten Transaktion.
Java-Einfuhrung von H. Partl { Kursunterlage 160

12.2 Structured Query Language (SQL)
Datentypen
SQL hat sich seit den 80er-Jahren als die von allen Datenbanksystemen (wenn auch
eventuell mit kleinen Unterschieden) unterstutzte Abfragesprache durchgesetzt, und
die Version SQL2 ist seit 1992 auch oziell genormt.
SQL umfat alle 3 Bereiche der Datenbankbenutzung:
die Denition der Datenbankstruktur,
die Speicherung, Loschung und Veranderung von Daten und
die Abfrage von Daten.
Fur eine komplette Beschreibung von SQL wird auf die Fachliteratur verwiesen, hier
sollen nur ein paar typische Beispiele gezeigt werden.
SQL kennt unter anderem die folgenden Datentypen:
CHAR (n) = ein Textstring mit einer Lange von genau n Zeichen (ahnlich wie
String, wird mit Leerstellen aufgefullt)
VARCHAR (n) = ein Textstring mit einer variablen Lange von maximal n Zeichen
(n < 255)
LONGVARCHAR (n) = ein Textstring mit einer variablen Lange von maximal n
Zeichen (n > 254)
DECIMAL oder NUMERIC = eine als String von Ziern gespeicherte Zahl (ahnlich
wie BigInteger)
INTEGER = eine ganze Zahl (4 Bytes, wie int)
SMALLINT = eine ganze Zahl (2 Bytes, wie short)
BIT = wahr oder falsch (wie boolean)
REAL oder FLOAT = eine Fliekommazahl (wie oat)
DOUBLE = eine doppelt genaue Fliekommazahl (wie double)
DATE = ein Datum (Tag)
TIME = eine Uhrzeit
TIMESTAMP = ein Zeitpunkt (Datum und Uhrzeit, ahnlich wie Java-Date)
Denition der Datenbankstruktur (DDL)
CREATE = Einrichten einer neuen Tabelle.
Beispiel:
CREATE TABLE Employees (
INT EmployeeNumber ,
CHAR(30) FirstName ,
CHAR(30) LastName ,
INT BirthYear ,
FLOAT Salary
)
Java-Einfuhrung von H. Partl { Kursunterlage 161

deniert eine Tabelle "Employees" (Mitarbeiter) mit den angegebenen Datenfeldern.
Die Erlaubnis dazu hat meistens nur der Datenbankadministrator.
ALTER = Andern einer Tabellendenition.
DROP = Loschen einer Tabellendenition.
Anderungen an den Daten (Updates)
Abfrage von Daten
INSERT = Speichern eines Records in einer Tabelle.
Beispiel:
INSERT INTO Employees
(EmployeeNumber, FirstName, LastName, BirthYear, Salary)
VALUES ( 4710, 'Hans', 'Fleissig', 1972, 24000.0 )
INSERT INTO Employees
(EmployeeNumber, FirstName, LastName, BirthYear, Salary)
VALUES ( 4711, 'Grete', 'Tuechtig', 1949, 32000.0 )
speichert zwei Mitarbeiter-Records mit den angegebenen Daten.
UPDATE = Verandern von Datenfeldern in einem oder mehreren Records.
Beispiel:
UPDATE Employees
SET Salary = 36000.0 WHERE LastName = 'Tuechtig'
setzt das Gehalt bei allen Mitarbeitern, die Tuechtig heien, auf 36000.
DELETE = Loschen eines oder mehrerer Records
Beispiel:
DELETE Employees WHERE EmployeeNumber = 4710
loscht den Mitarbeiter mit der Nummer 4710 aus der Datenbank.
SELECT = Abfragen von gespeicherten Daten.
Beispiele:
SELECT * FROM Employees
liefert alle Datenfelder von allen Records der Tabelle Employees.
SELECT LastName, FirstName, Salary FROM Employees
liefert die angegebenen Datenfelder von allen Records der Tabelle Employees.
SELECT LastName, Salary
FROM Employees WHERE BirthYear

SELECT * FROM Employees
WHERE LastName = 'Fleissig' AND FirstName LIKE 'H%'
liefert alle Daten derjenigen Mitarbeiter, deren Zuname Fleissig ist und deren Vorname
mit H beginnt.
12.3 Datenbank-Zugrie in Java (JDBC)
Mit Hilfe der "Java Database Connectivity" (JDBC) kann man innerhalb von
Java-Programmen auf Datenbanken zugreifen und Daten abfragen, speichern oder
verandern, wenn das Datenbanksystem die "Standard Query Language" SQL verwendet,
was bei allen wesentlichen Datenbanksystemen seit den 80er-Jahren der Fall
ist.
Im Java-Programm werden nur die logischen Eigenschaften der Datenbank und der
Daten angesprochen (also nur die Namen und Typen der Relationen und Datenfelder),
und die Datenbank-Operationen werden in der genormten Abfragesprache
SQL formuliert (Version SQL 2 Entry Level).
Das Java-Programm ist somit von der Hard- und Software des Datenbanksystems
unabhangig. Erreicht wird dies durch einen sogenannten "Treiber" (Driver), der zur
Laufzeit die Verbindung zwischen dem Java-Programm und dem Datenbanksystem
herstellt - ahnlich wie ein Drucker-Treiber die Verbindung zwischen einem Textverarbeitungsprogramm
und dem Drucker oder zwischen einem Graphikprogramm
und dem Plotter herstellt. Falls die Datenbank auf ein anderes System umgestellt
ist, braucht nur der Driver ausgewechselt werden, und die Java-Programme konnen
ansonsten unverandert weiter verwendet werden.
Der JDBC-Driver kann auch uber das Internet bzw. Intranet vom Java-Client direkt
auf den Datenbank-Server zugreifen, ohne da man eine eigene Server-Applikation
(CGI oder Servlet) schreiben mu.
Das JDBC ist bereits im Java Development Kit JDK enthalten (ab 1.1), und zwar
im Package java.sql. Mit JDK 1.2 kam eine neue Version JDBC 2.0 heraus, die
eine Reihe von zusatzlichen Features enthalt. Im folgenden werden aber nur die
(wichtigen) Features beschrieben, die sowohl in JDBC 1.x als auch in JDBX 2.0
enthalten sind.
Die Software fur die Server-Seite und die JDBC-Driver auf der Client-Seite mussen
vom jeweiligen Software-Hersteller des Datenbanksystems erworben werden (also
z.B. von der Firma Oracle). Dafur gibt es dann eigene Packages wie z.B. sun.jdbc
oder com.rma.produkt. Das JDBC enthalt auch eine sogenannte JDBC-ODBC-
Brucke fur den Zugri auf ODBC-Datenbanken (Open Database Connectivity, z.B.
MS-Access).
Beispielskizze fur eine Datenbank-Abfrage (select)
Hier eine Skizze fur den Aufbau einer typischen Datenbank-Anwendung mit einer
Abfrage von Daten. Mehr Informationen uber die darin vorkommenden Klassen
und Methoden nden Sie in den nachfolgenden Abschnitten und in der Online-
Dokumentation.
Java-Einfuhrung von H. Partl { Kursunterlage 163

import java.sql.*;
...
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
String username="admin";
String password="";
Connection con = DriverManager.getConnection
("jdbc:odbc://hostname/databasename", username, password);
con.setReadOnly(true);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery
("SELECT LastName, Salary, Age, Sex FROM Employees");
System.out.println("List of all employees:");
while (rs.next()) {
System.out.print(" name=" + rs.getString(1) );
System.out.print(" salary=" + rs.getDouble(2) );
System.out.print(" age=" + rs.getInt(3) );
if ( rs.getBoolean(4) ) System.out.print(" sex=M");
else
System.out.print(" sex=F");
System.out.println();
}
stmt.close();
con.close();
} catch ...
Beispielskizze fur einzelne Updates der Datenbank (insert, update, delete)
import java.sql.*;
...
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
String username="admin";
String password="";
Connection con = DriverManager.getConnection
("jdbc:odbc://hostname/databasename", username, password);
Statement stmt = con.createStatement();
int rowCount = stmt.executeUpdate
("UPDATE Employees " +
"SET Salary = 50000.0 WHERE LastName = 'Partl' ");
System.out.println(
rowCount + "Gehaltserhoehungen durchgefuehrt.");
stmt.close();
con.close();
} catch ...
oder bei mehreren Anderungen analog mit:
int rowCount = 0;
for (int i=0; i

owCount = rowCount + stmt.executeUpdate
("UPDATE Employees SET Salary = " + newSalary[i] +
" WHERE LastName = '" + goodPerson[i] + "' ");
}
System.out.println(
rowCount + "Gehaltserhoehungen durchgefuehrt.");
Beispielskizze fur umfangreiche Updates der Datenbank (PreparedStatement)
import java.sql.*;
...
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
String username="admin";
String password="";
Connection con = DriverManager.getConnection
("jdbc:odbc://hostname/databasename", username, password);
con.setAutoCommit(false);
PreparedStatement ps = con.prepareStatement
("UPDATE Employees SET Salary = ? WHERE LastName = ? ");
for (int i=0; i

12.5 Connection
Die Klasse Connection dient zur Verbindung mit einer Datenbank. Erzeugt wird
diese Verbindung vom JDBC DriverManager in der Form
Connection con =
DriverManager.getConnection (URL, username, password);
Der URL hat eine der folgenden Formen:
jdbc:protocol:databasename
fur eine lokale Datenbank mit JDBC-Driver
jdbc:protocol://hostname:port/databasename
fur eine Datenbank auf einem anderen Rechner, mit JDBC-Driver
jdbc:odbc:datasourcename
fur eine lokale ODBC-Datenbank, mit JDBC-ODBC-Driver
jdbc:odbc://hostname/datasourcename
fur eine ODBC-Datenbank auf einem anderen Rechner, mit JDBC-ODBC-
Driver
Der Username und das Pawort sind als String-Parameter anzugeben. Aus Sicherheitsgrunden
empehlt es sich, das Pawort nicht x im Programm anzugeben sondern
vom Benutzer zur Laufzeit eingeben zu lassen, am besten in einem TextField
mit setEchoCharacter('*') oder in Swing mit einem JPasswordField.
Die wichtigsten Methoden der Klasse Connection sind:
createStatement();
erzeugt ein Statement fur die Ausfuhrung von SQL-Befehlen.
prepareStatement (String sql);
erzeugt ein Prepared Statement fur die optimierte Ausfuhrung von SQL-
Befehlen.
getMetaData();
liefert die DatabaseMetaData (DDL-Informationen) der Datenbank.
setReadOnly(true);
es werden nur Datenbank-Abfragen durchgefuhrt, der Datenbank-Inhalt wird
nicht verandert, es sind daher keine Transaktionen notwendig und der Zugri
kann optimiert werden.
setReadOnly(false);
alle SQL-Statements sind moglich, also sowohl Abfragen als auch Updates
(Default).
setAutoCommit(true);
jedes SQL-Statement wird als eine eigene Transaktion ausgefuhrt, commit()
und rollback() sind nicht notwendig (Default).
setAutoCommit(false);
mehrere SQL-Statements mussen mit commit() und rollback() zu Transaktionen
zusammengefat werden.
Java-Einfuhrung von H. Partl { Kursunterlage 166

12.6 Statement
commit();
beendet eine Transaktion erfolgreich (alle Statements wurden ausgefuhrt).
rollback();
beendet eine Transaktion im Fehlerfall (alle Anderungen seit Beginn der Transaktion
werden ruckgangig gemacht).
close();
beendet die Verbindung mit der Datenbank.
Beispielskizze:
String username="admin";
String password="";
Connection con = DriverManager.getConnection
("jdbc:odbc://hostname/databasename", username, password);
Statement stmt = con.createStatement();
con.setReadOnly(true);
...
stmt.close();
con.close();
Innerhalb einer Connection konnen mehrere Statements geonet werden, eventuell
auch mehrere gleichzeitig.
Die Klasse Statement dient zur Ausfuhrung eines SQL-Statements oder von mehreren
SQL-Statements nacheinander. Erzeugt wird dieses Statement von der Connection
in der Form
Statement stmt = con.createStatement();
Die wichtigsten Methoden der Klasse Statement sind:
ResultSet res = executeQuery( String sql )
fuhrt ein SQL-Statement aus, das ein ResultSet als Ergebnis liefert, also z.B.
ein SELECT-Statement.
int rowCount = executeUpdate( String sql )
fuhrt ein SQL-Statement aus, das kein ResultSet liefert, also z.B. ein INS-
ERT, UPDATE oder DELETE-Statement. Der Ruckgabewert ist die Anahl
der Records, fur die der Befehl durchgefuhrt wurde, oder 0.
boolean anyResults = execute( String sql )
fuhrt ein SQL-Statement aus, das mehrere Ergebnisse (ResultSets oder UpdateCounts)
liefern kann, die man dann mit den Methoden getResultSet, get-
UpdateCount und getMoreResults abarbeiten mu. Dies trit nur in seltenen
Spezialfallen zu.
setQueryTimeout ( int seconds )
setzt ein Zeitlimit fur die Durchfuhrung von Datenbankabfragen (in Sekunden).
Java-Einfuhrung von H. Partl { Kursunterlage 167

12.7 ResultSet
close()
beendet das Statement.
Beispielskizze fur eine Abfrage:
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery
("SELECT LastName, Salary, Age, Sex FROM Employees");
...
stmt.close();
Beispielskizze fur ein Update:
Statement stmt = con.createStatement();
int rowCount = stmt.executeUpdate
("UPDATE Employees" +
"SET Salary = 50000.0 WHERE LastName = 'Partl' ");
...
stmt.close();
Innerhalb eines Statements darf zu jedem Zeitpunkt immer nur hochstens 1 Result-
Set oen sein.
Ein ResultSet ist das Ergebnis einer SQL-Abfrage, im allgemeinen das Ergebnis eines
SELECT-Statements. Es enthalt einen oder mehrere Records von Datenfeldern und
bietet Methoden, um diese Datenfelder ins Java-Programm hereinzuholen.
Die wichtigsten Methoden der Klasse ResultSet sind:
boolean next()
setzt den "Cursor" auf den ersten bzw. nachsten Record innerhalb des Result-
Set. Dessen Datenfelder konnen dann mit den getXXX-Methoden angesprochen
werden.
boolean getBoolean( String name )
int getInt ( String name )
float getFloat ( String name )
double getDouble ( String name )
String getString ( String name )
usw. liefert den Wert des Datenfeldes mit dem angegebenen Namen (caseinsensitive),
wenn der Name in der Datenbank eindeutig ist.
boolean getBoolean( int n )
int getInt ( int n )
float getFloat ( int n )
double getDouble ( int n )
String getString ( int n )
usw. liefert den Wert des n-ten Datenfeldes im Ergebnis (von 1, nicht von 0
an gezahlt); wenn man im SELECT-Befehl Feldnamen angegeben hat, dann
in der angegebenen Reihenfolge; wenn man im SELECT-Befehl * angegeben
hat, dann in der in der Datenbank denierten Reihenfolge.
Java-Einfuhrung von H. Partl { Kursunterlage 168

java.sql.Date getDate ( String name )
Time getTime ( String name )
Timestamp getTimestamp ( String name )
java.sql.Date getDate ( int n )
usw. liefert analog ein Datums- bzw. Zeit-Objekt. Dabei ist zu beachten, da
die Klasse java.sql.Date verschieden von java.util.Date ist, es gibt in diesen
Klassen aber Methoden, um das eine Datum in das andere umzuwandeln (am
einfachsten mit getDate und setDate).
boolean wasNull()
gibt an, ob das zuletzt gelesene Datenfeld leer war (d.h. den SQL-Nullwert
enthielt).
close()
beendet die Abfrage vorzeitig.
getMetaData();
liefert die ResultSetMetaData (DDL-Informationen) zu diesem ResultSet.
Beispielskizze:
ResultSet rs = stmt.executeQuery
("SELECT LastName, Salary, Age, Sex FROM Employees");
System.out.println("List of all employees:");
while (rs.next()) {
System.out.print(" name=" + rs.getString(1) );
System.out.print(" salary=" + rs.getDouble(2) );
System.out.print(" age=" + rs.getInt(3) );
if ( rs.getBoolean(4) ) System.out.print(" sex=M");
else
System.out.print(" sex=F");
System.out.println();
}
Anmerkungen:
Innerhalb eines Statements darf zu jedem Zeitpunkt immer nur hochstens 1 Result-
Set oen sein. Wenn man mehrere ResultSets gleichzeitig braucht, mu man dafur
mehrere Statements innerhalb der Connection onen (soferne das Datenbanksystem
das erlaubt).
Die Zugrie auf die Felder sollen in der Reihenfolge erfolgen, wie sie von der Datenbank
geliefert werden, also in der Reihenfolge, in der sie im SELECT-Befehl bzw. bei
* im Record stehen. Bei JDBC 1.x konnen die Records auch nur in der Reihenfolge,
in der sie von der Datenbank geliefert werden, verarbeitet werden (mit next).
Ab JDBC 2.0 enthalt die Klasse ResultSet zahlreiche weitere Methoden, die auch
ein mehrmaliges Lesen der Records (z.B. mit previous) und auch Datenanderungen
in einzelnen Records (z.B. mit updateString, updateInt) erlauben.
Ansonsten kann man ein mehrmaliges Abarbeiten der Resultate erreichen, indem
man sie in einem Vector zwischenspeichert. Beispielskizze:
ResultSet rs = stmt.getResultSet();
ResultSetMetaData md = rs.getMetaData();
int numberOfColumns = md.getColumnCount();
Java-Einfuhrung von H. Partl { Kursunterlage 169

int numberOfRows = 0;
Vector rows = new Vector();
while (rs.next()) {
numberOfRows++;
Vector newRow = new Vector();
for (int i=1; i

12.9 DatabaseMetaData und ResultSetMetaData
Mit den Klassen DatabaseMetaData und ResultSetMetaData kann man Informationen
uber die Datenbank bzw. das ResultSet erhalten, also z.B. welche Tabellen
(Relationen) deniert sind, wie die Datenfelder heien und welchen Typ sie haben,
und dergleichen.
Den Zugri auf die DatabaseMetaData erhalt man mit der Methode getMetaData
in der Connection. Damit kann man dann alle moglichen Eigenschaften des Datenbanksystems,
des JDBC-Drivers, der Datenbank und der Connection abfragen (siehe
die Online-Dokumentation).
Den Zugri auf die ResultSetMetaData erhalt man mit der Methode getMetaData
im ResultSet. Ein paar typische Methoden der Klasse ResultSetMetaData sind:
int getColumnCount()
Anzahl der Datenfelder
String getColumnName ( int n )
welchen Namen das n-te Datenfeld hat
int getColumnType ( int n )
welchen der SQL-Datentypen das n-te Datenfeld hat (siehe die statischen Konstanten
in der Klasse Types)
boolean isSearchable ( int n )
ob das n-te Datenfeld ein Suchfeld ist, das in der WHERE-Klausel angegeben
werden darf
int getColumnDisplaySize ( int n )
wieviele Zeichen man maximal fur die Anzeige des n-ten Datenfeldes braucht
String getColumnLabel ( int n )
welche Bezeichnung man fur das n-te Datenfeld angeben soll (eventuell
verstandlicher als der Datenfeldname)
String getSchemaName ( int n )
in welchem Datebank-Schema (DDL) das n-te Datenfeld deniert ist
String getTableName ( int n )
zu welcher Tabelle (Relation) das n-te Datenfeld gehort
Java-Einfuhrung von H. Partl { Kursunterlage 171

12.10 Datenbank-Anwendungen uber das Internet
Wie kann das Konzept bzw. die "Architektur" einer Java-Datenbank-Anwendung
aussehen, wenn die Benutzer uber das Internet oder ein Intranet von ihren Client-
Rechnern aus auf die Datenbank zugreifen sollen?
Ein solches Client-Server-System kann z.B. aus folgenden Komponenten zusammengesetzt
werden:
einer Java-Applikation (oder Servlet) auf dem Server, die auf die Datenbank
zugreift, und
einem HTML-Formular oder einem Java-Applet, das innerhalb einer Web-Page
auf den Clients lauft und das User-Interface realisiert.
Die Applikation auf dem Server (bzw. das Servlet) greift auf das Datenbanksystem
und damit auf die Daten zu. Es erhalt vom Client Abfragen oder Daten, fuhrt
die entsprechenden Datenbank-Abfragen oder Daten-Eingaben durch und liefert die
Ergebnisse an den Client.
Das Applet stellt das User-Interface dar. Es sendet die Abfragen oder Dateneingaben
des Benutzers an den Server und gibt die von dort erhaltenen Daten oder Meldungen
an den Benutzer aus.
Das Applet kann von den Benutzern als Teil einer Web-Page mit dem Web-Browser
uber das Internet geladen werden. Der Benutzer braucht fur den Datenbankzugri
also keine andere Software als nur seinen Java-fahigen Web-Browser.
Die Kommunikation zwischen Applet und Server kann je nach der verfugbaren Software
auf verschiedene Arten erfolgen:
Am Server arbeitet ein Servlet innerhalb des Web-Servers, die Kommunikation
mit dem Applet erfolgt uber HTTP.
Am Server arbeitet eine Java-Applikation als CGI-Programm innerhalb des
Web-Servers, die Kommunikation mit dem Applet erfolgt uber HTTP.
Am Server arbeitet eine selbstandige Java-Applikation, die Kommunikation
mit dem Applet erfolgt uber Sockets.
Die Kommunikation zwischen Server-Applikation (bzw. Servlet) und Datenbank
kann
uber JDBC
oder uber das JNI (native Interface) mit Hilfe von Unterprogrammen in C
oder einer anderen Programmiersprache
erfolgen. Dabei konnen das Server-Programm und das Datenbanksystem
am selben Rechner laufen (Datenbank-Server mit Web-Interface)
oder auf zwei verschiedenen Rechnern laufen, die uber das Internet oder Intranet
verbunden sind (Applikations-Server und Datenbank-Server).
Java-Einfuhrung von H. Partl { Kursunterlage 172

Eine weitere Moglichkeit ware es, da das Applet selbst mit JDBC uber das Internet
direkt auf die Datenbank zugreift, mit einem geeigneten JDBC-Driver, der in diesem
Fall allerdings auf jedem Client installiert sein oder mit dem Applet mitgeladen
werden mu.
Auerdem ware es auch moglich, statt eines Applet eine Java-Applikation am Client
zu installieren, die dann wiederum entweder mit Umweg uber ein Server-Programm
oder direkt mit einem JDBC-Driver auf die Datenbank zugreift.
Fortgeschrittene Java-Programmierer konnen auch RMI (Remote Method Invocation)
oder EJB (Enterprise Java Beans) oder CORBA (Common Object Request
Broker Architecture) verwenden.
Bei wichtigen oder sensiblen Daten mu jeweils auf die Datensicherheit und auf den
Datenschutz geachtet werden (Pawort-Schutz, Verschlusselung der Daten bei der
Ubertragung).
12.11 Ubung: eine kleine Datenbank
Vorbereitung
Diese Ubung besteht aus mehreren Schritten und kann nur dann ausgefuhrt werden,
wenn Sie ein Datenbanksystem und den zugehorigen JDBC-Driver auf Ihrem
Rechner installiert haben und wenn Sie wissen, wie man mit diesem Datenbanksystem
Datenbanken deniert und verwendet. Wenn dies nicht der Fall ist, konnen
Sie "nur" das Konzept dieser Ubungsbeispiele uberlegen und die Java-Programme
nur schreiben und compilieren, aber nicht ausfuhren.
Fur diese Ubung werden die Datenbank und die Java-Applikationen am selben Rechner
angelegt und ausgefuhrt, also ohne Internet-Verbindung.
Legen Sie - zum Beispiel mit MS-Access - eine Datenbank an, die eine Tabelle
"Mitarbeiter" mit den folgenden Datenfeldern enthalt: Abteilung (Text, String),
Vorname (Text, String), Zuname (Text, String), Geburtsjahr (Zahl, int), Gehalt
(Zahl, double).
Fullen Sie diese Tabelle mit ein paar Datenrecords, etwa wie im Beispiel im Kapitel
uber relationale Datenbanksysteme.
Registrieren Sie diese Datenbank auf Ihrem Rechner, zum Beispiel mit dem ODBC-
Manager der MS-Windows Systemsteuerung als DSN (Datenquellenname). Dann
konnen Sie den einfachen JDBC-ODBC-Driver verwenden, der im JDK enthalten
ist (aber manchmal unerklarliche Fehler liefert).
Bei der Verwendung von anderen Datenbanksystemen mussen Sie sicherstellen, da
ein entsprechender JDBC-Driver verfugbar ist, und die Datenbank dementsprechend
anlegen und registieren.
Einfache Ubrungsbeispiele
1. Liste der Geburtsjahre
Schreiben Sie eine einfache Java-Applikation, die eine Liste aller Mitarbeiter mit
Vorname und Geburtsjahr auf den Bildschirm ausgibt.
Java-Einfuhrung von H. Partl { Kursunterlage 173

2. Berechnung des Durchschnittsgehalts
Schreiben Sie eine einfache Java-Applikation, die das Durchschnittsgehalt der Mitarbeiter
berechnet und auf den Bildschirm ausgibt. Zu diesem Zweck fragen Sie
das Gehalt von allen Mitarbeitern ab, bilden die Summe, zahlen die Anzahl und
dividieren schlieich die Summe durch die Anzahl.
Komplizierte Ubrungsbeispiele
3. Speichern
4. Liste (Abfrage)
Wenn Sie wollen, konnen Sie das einfache Beispiel auch durch die folgenderen, etwas
aufwendigeren Aufgaben erganzen.
Schreiben Sie eine einfache Java-Applikation, die ein paar (mindestens 3, hochstens
10) Mitarbeiter-Records in dieser Datenbank speichert.
Schreiben Sie eine einfache Java-Applikation, die eine Liste aller Mitarbeiter mit
Vorname, Zuname und Alter (in Jahren) ausgibt.
5. Berechnungen (Abfrage)
Schreiben Sie eine einfache Java-Applikation, die die Anzahl der Mitarbeiter, das
Durchschnittsalter und die Gehaltssumme (Summe der Monatsgehalter) ausgibt.
6. Einfache GUI-Applikation (Abfrage)
Schreiben Sie eine Java-GUI-Applikation, bei der der Benutzer in einem TextField
einen Zunamen eingeben kann und dann entweder alle Daten uber diesen Mitarbeiter
am Bildschirm aufgelistet erhalt oder eine Fehlermeldung, da es keinen Mitarbeiter
mit diesem Namen gibt. Das GUI soll auch einen Exit-Button haben, mit dem man
die Applikation beenden kann.
Username und Pawort geben Sie der Einfachheit halber direkt im Programm an,
auch wenn man das bei echten Datenbanken aus Sicherheitsgrunden nicht tun sollte.
7. Aufwendigere GUI-Applikation (Updates)
Schreiben Sie eine Java-GUI-Applikation, bei der der Benutzer zunachst mit 2 Textfeldern
seinen Username und sein Pawort eingibt, um mit der Datenbank verbunden
zu werden, und dann in einem neuen Fenster mit 4 Textfeldern alle Daten fur einen
zusatzlichen Mitarbeiter eingeben und mit einem Store-Button in der Datenbank
speichern kann. Jedes dieser Fenster soll auch einen Exit-Button haben, mit dem
man die Applikation beenden kann.
Fugen Sie mit dieser Applikation ein paar (mindestens 2, hochstens 5) weitere Mitarbeiter
in die Datenbank ein und fuhren Sie dann die Ubungsprogramme 4, 5 und
6 neuerlich aus, um zu testen, ob alle Mitarbeiter richtig gespeichert wurden.
Java-Einfuhrung von H. Partl { Kursunterlage 174

Wenn Sie sehr viel mehr Zeit investieren wollen, konnen Sie auch uberlegen, wie
ein graphisches User-Interface aufgebaut sein mute, um damit nicht nur die Speicherung
von neuen Records sondern auch Abfragen von gespeicherten Records,
Datenanderungen an einzelnen Records und Loschungen von einzelnen Records
durchfuhren zu konnen.
8. Loschen
Schreiben Sie eine einfache Java-Applikation, die alle Mitarbeiter-Records aus der
Datenbank loscht.
Fuhren Sie dieses Programm aus und testen Sie dann mit Programm 1 oder 4, ob
tatsachlich keine Mitarbeiter mehr gespeichert sind.
Java-Einfuhrung von H. Partl { Kursunterlage 175

13. Referenzen
Online-Informationen uber Java:
{ Online-Dokumentation (API) des JDK - auch on-line auf
http://java.sun.com/docs/
{ http://java.sun.com/ - auch unter http://www.javasoft.com/
{ http://www.gamelan.com/
{ http://www.sourceforge.net/
{ http://codeguru.developer.com/java/
{ Java Tutorial auf http://java.sun.com/docs/books/tutorial/index.html
{ Java FAQ auf http://sunsite.unc.edu/javafaq/javafaq.html
{ Java Programmers FAQ auf http://www.afu.com/javafaq.html
{ Java Glossary in http://mindprod.com/gloss.html
{ deutsche Java-FAQ auf http://www.os-visions.de/texte/java/faq/
{ Bucher:
3 Java-Einfuhrung von Hubert Partl auf
http://www.boku.ac.at/javaeinf/
3 Go to Java 2 von Guido Kruger auf http://www.gkrueger.com/
3 Java ist auch eine Insel von Christian Ullenboom auf
http://java-tutor.com/
3 Java Dokumentation von Brit Schroter und Johann Plank auf
http://www.selfjava.de/
3 Thinking in Java von Bruce Eckel auf
http://www.BruceEckel.com/javabook.html
{ siehe auch http://www.yahoo.com/ (Suche)
Online-Informationen uber Internet, WWW und HTML:
{ Internet-Handbuch von H.Partl - auch online auf
http://www.boku.ac.at/zid/hand/#internet
{ HTML-Einfuhrung von H.Partl - auch online auf
http://www.boku.ac.at/htmleinf/
{ W3-Consortium - auf http://www.w3.org/
{ siehe auch http://www.yahoo.com/ (Suche)
Java-Einfuhrung von H. Partl { Kursunterlage 176

Newsgruppen uber Java und Web-Pages:
{ comp.lang.java.help
{ comp.lang.java.programmer
{ comp.lang.java.gui
{ und andere Spezialgruppen in der Hierarchie comp.lang.java.*
{ comp.infosystems.www.authoring.html
{ comp.infosystems.www.authoring.site-design
{ und andere Gruppen in der Hierarchie comp.infosystems.*
{ de.comp.lang.java
{ de.comm.infosystems.www.authoring
{ und andere Gruppen in den Hierarchien de.comm.* und de.comp.*
{ siehe auch http://www.deja.com/ (Suche)
Beilage:
Musterlosungen der Ubungsaufgaben
Java-Einfuhrung von H. Partl { Kursunterlage 177