Java 2 Kompendium
Ralph Steyer
Java 2
Professionelle Programmierung mit J2SE Version 1.3
Markt+Tec Technik Verlag
Die Deutsche Bibliothek – CIP-Einheitsaufnahme Ein Titeldatensatz für diese Publikation ist bei Der Deutschen Bibliothek erhältlich. Die Informationen in diesem Buch werden ohne Rücksicht auf einen eventuellen Patentschutz veröffentlicht. Warennamen werden ohne Gewährleistung der freien Verwendbarkeit benutzt. Bei der Zusammenstellung von Texten und Abbildungen wurde mit größter Sorgfalt vorgegangen. Trotzdem können Fehler nicht vollständig ausgeschlossen werden. Verlag, Herausgeber und Autoren können für fehlerhafte Angaben und deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Für Verbesserungsvorschläge und Hinweise auf Fehler sind Verlag und Herausgeber dankbar. Alle Rechte vorbehalten, auch die der fotomechanischen Wiedergabe und der Speicherung in elektronischen Medien. Die gewerbliche Nutzung der in diesem Produkt gezeigten Modelle und Arbeiten ist nicht zulässig. Fast alle Hardware- und Softwarebezeichnungen, die in diesem Buch erwähnt werden, sind gleichzeitig auch eingetragene Warenzeichen oder sollten als solche betrachtet werden. Umwelthinweis: Dieses Buch wurde auf chlorfrei gebleichtem Papier gedruckt. Die Einschrumpffolie – zum Schutz vor Verschmutzung – ist aus umweltverträglichem und recyclingfähigem PE-Material.
10 9 8 7 6 5 4 3 2 1 05 04 03 02 01
ISBN 3-8272-6039-6 © 2001 by Markt+Technik Verlag, ein Imprint der Pearson Education Deutschland GmbH, Martin-Kollar-Straße 10–12, D-81829 München/Germany Alle Rechte vorbehalten Einbandgestaltung: Grafikdesign Heinz H. Rauner, Gmund Lektorat: Jürgen Bergmoser,
[email protected] Herstellung: Elisabeth Egger,
[email protected] Satz: reemers publishing services gmbh, Krefeld (www.reemers.de) Druck und Verarbeitung: Bercker, Kevelaer Printed in Germany
Java 2 Kompendium 5 Inhaltsübersicht Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 Hinweise zum Buch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 Kapitel 1 What's new? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 Kapitel 2 Schnuppertour Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 Kapitel 3 Das JDK. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 Kapitel 4 Unterschiede zwischen Java-Applikakkationen und -Applets . . . . . . . . . . 137 Kapitel 5 Java-Hintergründe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 Kapitel 6 Java – die Hauptbestandteile der Sprache. . . . . . . . . . . . . . . . . . . . . . . . . 183 Kapitel 7 Grundlagen der Applet-Erstellllung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341 Kapitel 8 Multithreading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393 Kapitel 9 Grafik und Animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417 Kapitel 10 Das AWT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517 Kapitel 11 Swing & Co . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .623 Kapitel 12 Debugging und Ausnahmebehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . 667 Kapitel 13 Ein- und Ausgabe in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .697 Kapitel 14 Java-Sicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 755 Kapitel 15 Andere Sprachen in Verbindung mit Java. . . . . . . . . . . . . . . . . . . . . . . . . 777 Kapitel 16 Weiterführende Themen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 829 Anhang A. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 905 Anhang B. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955 Anhang C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1075 Anhang D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1101 Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1105 Java 2 Kompendium
5
Inhaltsverzeichnis
V o r w or t . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25
Hinweise zum Buch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
27
Kapitel 1
W h at ' s n ew ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
1.1
Java 1.2, Java 2.0, JDK 1.2 und JDK 1.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
1.2
JavaSoft und Sun . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
33
1.3
Die Java-Neuerungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Kompatibilität und das Java-Plug-In . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Interoperabilität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Anpassung einer Applikation an verschiedene Länderstandards . . . . . . . . . . . . . . . . . . . . Erweiterung der Sicherheitsschnittstelle von Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Verschlüsselung in Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Abstract Window Toolkit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Java-Archive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Datenbankunterstützung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Verteilte Programmierung und Object Serialization. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Java IDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . JavaBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Servlets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Inner Classes und Anonymous Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Native Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Reference Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Multimedia-Unterstützung in Java 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Java-2D-API-Referenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Swing JDK 1.2/1.3 und die Java Accessibility API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Drag&Drop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Java-Standardklassen und die Datei classes.zip . . . . . . . . . . . . . . . . . . . . . . . . . . . . Veränderungen bei den Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Neues Lizenzierungsmodell für Java 2.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
34 34 39 40 40 41 42 43 44 44 45 45 46 46 47 47 47 48 49 50 51 51 53
1.4
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
54
Java 2 Kompendium
7
Inhaltsverzeichnis Kapitel 2
Schnup nuppertour Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
55
2.1
Was ist Java? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Internet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ein kurzer Abriss der Internet-Geschichte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Organisation des Internets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Adressierung im Internet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die IP-Nummern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das DNS-Konzept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Uniform Resource Locator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
56 56 58 62 64 65 66 68 71
2.2
Die Geschichte von Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Erstes Java-Auftreten, HotJava und das JDK 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Was macht Java so einzigartig? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Herkunft von Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
73 75 77 79
2.3
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
86
Kapitel 3
D as J D K . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
87
3.1
Bezug des JDK. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
88
3.2
Installation des JDK. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . classes.zip, src.zip, src.jar, rt.jar & Co. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Verzeichnisstruktur innerhalb des JDK-Verzeichnisses . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Java-Laufzeitumgebung jre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Das Java-Plug-In . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
91 93 94 96 96
3.3
Die JDK-Dokumentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
3.4
Fehlervorbeugung und Fehlerbehebung beim JDK . . . . . . . . . . . . . . . . . . . . . . . . . . . Pfad-Angaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . CLASSPATH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Verwendung von mehreren JDK-Versionen unter Windows . . . . . . . . . . . . . . . . . . . . . . . . »Class not found« und andere Fehlermeldungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Die Java-Umgebungsvariablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Unbekannte Fehler. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
103 103 105 109 112 116 116
3.5
Die wichtigsten JDK-Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ein paar allgemeine Hinweise zu den JDK-Programmen . . . . . . . . . . . . . . . . . . . . . . . . . . Der Appletviewer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Java-Compiler Javac . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Der Java-Interpreter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
117 117 121 125 130
3.6
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
8
Java 2 Kompendium
Inhaltsverzeichnis Kapitel 4
Unterschiede zwischen Java-Applikat kationen un und -Applets . . . . . . . . . . . . . . . . . . . . . 137
4.1
Die technischen Unterschiede . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
4.2
Eine erste Beispielanwendung und ein erstes Applet. . . . . . . . . . . . . . . . . . . . . . . . . 141 Eine erste Applikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 Übergabe von Aufrufargumenten an ein Java-Programm . . . . . . . . . . . . . . . . . . . . . . . . . 144 Ein erstes Applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
4.3
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
Kapitel 5
Java-Hintergründe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
5.1
Was ist OOP?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
5.2
Die Definition von Objektorientierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 Objektmethoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 Who's calling?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
5.3
Klassen und Instanzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 Superklasse und Subklasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 Metaklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 Abstrakte Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
5.4
Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 Mehrfachvererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
5.5
Überschreiben. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
5.6
Polymorphismus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
5.7
Binden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 Frühes Binden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 Spätes Binden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
5.8
Die Grundprinzipien der objektorientierten Programmierung . . . . . . . . . . . . . . . . . . . 166
5.9
Objektorientierte Analyse und objektorientiertes Design . . . . . . . . . . . . . . . . . . . . . . 167 Die objektorientierte Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 Das objektorientierte Design. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
5.10
Die Objektorientierung von Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 Java-Klassen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 Polymorphismus und Binden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 Schnittstellen und Pakete statt Mehrfachvererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 Überladen, Überschreiben und Überschatten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170 Globale Vereinbarungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
Java 2 Kompendium
9
Inhaltsverzeichnis 5.11
Plattformunabhängigkeit von Java und die JVM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 Die binäre Plattformunabhängigkeit von Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 Die JVM-Architektur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 Die Datentypen der JVM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179 Die Java-Plattformunabhängigkeit auf Quellebene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
5.12
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
Kapitel 6
Java – die Haupt uptbestandt ndteile der Sprache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
6.1
Token. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183 Der Unicode-Zeichensatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 Die UTF-8-Codierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 Kleiner Vorgriff auf die Datentypen von Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 Die Java-Token-Details . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 Literale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 Operatoren-Priorität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221 Kommentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
6.2
Typen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 Operationen mit den Datentypen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
6.3
Datenfelder (Arrays) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235 Deklarieren von Datenfeldern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 Erstellen von Datenfeldobjekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 Dynamische Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238 Speichern und Zugreifen auf Datenfeldelemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
6.4
Ausdrücke, Operatoren und Casting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245 Ausdrücke. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245 Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248 Typkonvertierungen und der Casting-Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250 Der Instanceof-Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
6.5
Anweisungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258 Blöcke und Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260 Leere Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261 Bezeichnete Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261 Deklarationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262 Ausdrucksanweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
10
Java 2 Kompendium
Inhaltsverzeichnis Auswahlanweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 Iterationsanweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269 Java-Sprunganweisungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 Schutzanweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276 Unerreichbare Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 6.6
Klassen und Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 Allgemeines zu Klassen in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278 Allgemeine Klassendeklaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 Klassen-Modifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279 Der Klassenname . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285 Superklassen und das Schlüsselwort extends . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285 Designregeln für Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286 Innere und anonyme Klassen bzw. Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 Adapterklassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 Konstruktoren und der new-Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 Das Speichermanagement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 Das Schlüsselwort this. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
6.7
Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302 Deklaration einer Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 Die Zugriffsspezifizierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 Die Methodenmodifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305 Die Rückgabewerte von Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308 Der Methodenname. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309 Die Parameterliste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310 Der Methodenkörper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311 Methoden überladen und überschreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
6.8
Schnittstellen und das Schlüsselwort implements . . . . . . . . . . . . . . . . . . . . . . . . . . 317 Erstellung einer Schnittstelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 Namensregeln für Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 Die Erweiterung anderer Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319 Der Körper einer Schnittstelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319 Überschreiben und Verwenden von Schnittstellenmethoden . . . . . . . . . . . . . . . . . . . . . . . 322 Verwenden von Feldern einer Schnittstelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323 Beispiele mit Schnittstellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
Java 2 Kompendium
11
Inhaltsverzeichnis 6.9
Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325 Instanzvariablen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326 Klassenvariablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326 Klassenvariablen versus Instanzvariablen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327 Lokale Variablen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329 Die Java-Konstanten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
6.10
Der Zugriff auf Java-Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
6.11
Pakete und die import-Anweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331 Die Verwendung von Paketen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331 Erstellung eines Paketes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335 Das anonyme Default-Paket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336 Zugriffslevel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
6.12
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
Kapitel 7
Grundlagen de der Applet-Erstellun llung ung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
7.1
Die Vorbereitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
7.2
Grundlagen der Einbindung von Java-Applets in HTML-Seiten. . . . . . . . . . . . . . . . . . 343 HTML-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
7.3
Konkrete Referenzierung eines Java-Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 Die <APPLET>-Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 Die Parameter des <APPLET>-Tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355 Die <EMBED>-Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358 Die
-Syntax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360 Welches Tag ist sinnvoll? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362 Die ursprüngliche HotJava-Syntax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
7.4
Die interne Arbeitsweise eines Applets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363 Erstellung und Grundmethoden eines Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364 Ein Musterapplet als Schablone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
7.5
Die Applet-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367 Ausgabe in einem Applet mit der paint()-Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368 Übergabewerte für ein Applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368 Bilder importieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373 Importieren und Abspielen von Sound . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375 Die Interaktion des Applets mit der Umgebung und den Lebenszyklus eines Applets verwalten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375 Methoden zur Ereignisbehandlung in Applets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
12
Java 2 Kompendium
Inhaltsverzeichnis 7.6
Multithreading bei Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
7.7
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
Kapitel 8
Multithread eading. ng . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
8.1
Klassen Thread-fähig machen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394 Die Erweiterung der Klasse Thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394 Implementation von Runnable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
8.2
Thread-Gruppen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406 Eine Thread-Gruppe erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406 Hinzufügen eines Threads zu einer Thread-Gruppe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
8.3
Dämonen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
8.4
Schutzmaßnahmen bei Multithreading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412 Methoden synchronisieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413 Vorsicht, Deadlock! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413 Synchronisierte Blöcke. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414 Thread-sicherer Zugriff auf Datenstrukturen und Objekte . . . . . . . . . . . . . . . . . . . . . . . . . 415
8.5
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Kapitel 9
Grafik und und Animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
9.1
Zeichnen, Update und neu zeichnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
9.2
Punkte, Linien, Kreise und Bögen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420 Das Koordinatensystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420 Eine Linie zeichnen – die drawLine()-Methode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421 Ein Rechteck zeichnen – die drawRect()-Methode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422 Ein gefülltes Rechteck zeichnen – fillRect() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423 Löschen eines Bereichs – clearRect() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423 Kopieren eines Bereichs – copyArea(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424 Ein 3D-Rechteck zeichnen – die draw3dRect()-Methode . . . . . . . . . . . . . . . . . . . . . . . . . 425 Ein gefülltes 3D-Rechteck zeichnen – fill3dRect() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425 Abgerundete Rechtecke – drawRoundRect() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426 Abgerundete gefüllte Rechtecke – fillRoundRect() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426 Zeichnen von Polygonen – drawPolygon() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427 Zeichnen von gefüllten Polygonen – fillPolygon() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430 Zeichnen von Kreisen und Ellipsen – drawOval() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431 Zeichnen von gefüllten Kreisen und Ellipsen – fillOval() . . . . . . . . . . . . . . . . . . . . . . . . . . 432 Zeichnen von Bögen – drawArc() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433 Zeichnen von gefüllten Bögen – fillArc() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
Java 2 Kompendium
13
Inhaltsverzeichnis 9.3
Farbangaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434 Die Color-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435 Farben setzen – setColor() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436 Hintergrundfarben und Vordergrundfarben pauschal setzen – setBackground() und setForeground(). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438 Ein Apfelmännchen als Java-Applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439 Abrufen von Farbinformationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444 Textausgabe über den Zeichnen-Modus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445 Erstellen von Fontobjekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445 Abfragen der zur Verfügung stehenden Fonts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448 Informationen über einen speziellen Font abfragen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
9.4
Die Java-Zeichenmodi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450 Der Paint-Modus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450 Der XOR-Zeichenmodus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
9.5
Zeichnen von Bildern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451 Laden von Bildern – getImage() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451 Anzeigen von Bildern – drawImage() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452 Der Imageobserver und der MediaTacker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
9.6
Animationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457 Aufbau eines Animationsrahmens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458 Abspielen einer Animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458 Flimmereffekte in Animationen reduzieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468 Clipping. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474 Double-Buffering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476
9.7
Das 2D-API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478 Java-2D-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479 Zeichnen unter dem Java-2D-API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480 Komplexere Zeichnenoperationen im 2D-API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487 Text unter Java 2D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
9.8
Bilder unter Java 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493 Anzeige von Bildern unter Java 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493 Transparenz und Bilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493 Rendering als Bestandteil von Java 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499 Kontrolle der Ausgabequalität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500 Transformation von 2D-Objekten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501 Neue Formen kreieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502
14
Java 2 Kompendium
Inhaltsverzeichnis Stroking Paths. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502 Füllen von Formen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502 Komposition von Bildern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502 Transparenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503 Text und Fonts unter Java 2D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503 Farbmanagement unter Java 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506 2D-Bildbearbeitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506 Offscreen-Puffer unter Java 2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507 2D-Graphics Devices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507 9.9
Die Java-2D-API-Referenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508
9.10
Sound und Töne in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510 Das Abspielen und Stoppen eines Audio-Clips – play() . . . . . . . . . . . . . . . . . . . . . . . . . . . 511 Die Sound-Möglichkeiten der JDK-Demos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511 Das Java Media Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514
9.11
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
Kapitel 10
Das AWT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
10.1
Was ist das Abstract Window Toolkit? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
10.2
Woraus besteht das AWT? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521 Was sind AWT-Komponenten? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522 Was versteht man unter AWT-Container? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523 Container und Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523 Der Aufbau der AWT-Klassenhierarchie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523 Was ist ein AWT-Layoutmanager? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
10.3
Container. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525 Panels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526 Frames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527 Dialoge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533
10.4
Schaltflächen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538
10.5
Labels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
10.6
Kontrollkästchen und Optionsfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545 Kontrollkästchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546 Optionsfelder. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548 Reaktionen auf Kontrollfelder und Radiobuttons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550
Java 2 Kompendium
15
Inhaltsverzeichnis 10.7
Auswahlmenüs und Listenfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 554 Einzeilige Listenfelder. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555 Mehrzeilige Listenfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
10.8
Textbereiche und Textfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566 Textbereiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566 Textfelder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567 Gemeinsame Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569 Spezielle TextField-Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570 Spezielle TextArea-Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571
10.9
Schieber und Bildlaufleisten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572
10.10
Zeichenbereiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578
10.11
Menüs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580
10.12
Eine Schablone für alle Fälle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 589
10.13
Layoutmanager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590 Layout-Regeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592 Die Layoutmanager im Detail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
10.14
Die Eventmodelle 1.0 und 1.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605 Der AWT-Event-Handler 1.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606 Tastaturereignisse des AWT-Event-Handlers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607 Mausereignisse des AWT-Event-Handlers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608 Zentrale Aspekte des 1.0-Eventhandlings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 608 Das Eventhandling 1.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611 Der Umstieg vom 1.0-Eventmodell auf das 1.1-Modell. . . . . . . . . . . . . . . . . . . . . . . . . . . 618
10.15
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621
Kapitel 11
Swing & Co . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
11.1
Das Swing-API. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
11.2
Swing und AWT im Vergleich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624 Einige Swing-Probleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
11.3
Swing in der Praxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627 Umschalten von Look and Feel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627 Swing und Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
11.4
Eigenständige Applikationen und Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638 Eine Swing-Applikations-Schablone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639
16
Java 2 Kompendium
Inhaltsverzeichnis 11.5
Swing-Komponenten im Detail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643
11.6
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 666
Kapitel 12
Debug bugging und und Ausnahmebehandlung ung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667
12.1
Debugging. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668 Fehler im Vorfeld abfangen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668 Vernünftige Sicherungsmaßnahmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669 Fehler finden und beseitigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669 Fehlerlokalisierung ohne Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 670 Fehlerlokalisierung mit Debugger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 672
12.2
Ausnahmebehandlung und andere Fehlerbehandlungen . . . . . . . . . . . . . . . . . . . . . . 675 Die individuell programmierte Fehlerbehandlung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 676 Die Ausnahmebehandlung von Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677 Benutzerdefinierte Exceptions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687 Die RuntimeException . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693
12.3
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 694
Kapitel 13
Ein- und und Ausgabe in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 697
13.1
Allgemeines zur Ein- und Ausgabe unter Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 697
13.2
Die Klasse InputStream. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 701 Methoden zum Einlesen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 701 Blockaden vorher abfragen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702 Überspringen von Daten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703 Positionen beim Lesen markieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703 Ressourcen freigeben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704
13.3
Die Klasse OutputStream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704 Methoden zum Schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705 Den gepufferten Cache ausgeben. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 706 Ressourcen freigeben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 707
13.4
Byte-Datenfeldströme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 707
13.5
Der StringBufferInputStream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 708
13.6
Gefilterte Ströme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 708
13.7
Gepufferte Ströme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 709
13.8
Datenströme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 710 Die DataInput-Schnittstelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 710
Java 2 Kompendium
17
Inhaltsverzeichnis Die DataOutput-Schnittstelle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 712 Die DataInputStream- und DataOutputStream-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . 712 13.9
Die PrintStream-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 713
13.10
Pipe-Ströme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 714
13.11
Objektströme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 715
13.12
Einige spezielle Utility-Ströme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 716 Die LineNumberInputStream-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 716 Die SequenceInputStream-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 716 Die PushbackInputStream-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 717 Die StreamTokenizer-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 717
13.13
Die File-Klasse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 718 Überprüfung, ob Datei oder Verzeichnis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 718 Lese- und Schreiberlaubnis überprüfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719 Die letzte Änderung überprüfen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719 Die Existenz eines Objekts überprüfen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719 Pfadkontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 719 Namen und Pfad einer Datei oder eines Verzeichnisses ermitteln . . . . . . . . . . . . . . . . . . . 719 Eine Datei oder ein Verzeichnis umbenennen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 720 Dateien löschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 720 Verzeichnisse erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 720 Den Inhalt eines Verzeichnisses angeben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 720
13.14
Dateiströme – FileInputStream und FileOutputStream . . . . . . . . . . . . . . . . . . . . . . . . 721 Die RandomAccessFile-Klasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 722
13.15
Praktische Java-Beispiele mit Datenströmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723
13.16
Drucken unter Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744 Drucken unter dem JDK 1.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744 Drucken unter dem SDK 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 748
13.17
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751
Kapitel 14
Java-Sicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 755
14.1
Das Java-Sicherheitskonzept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 755 Die Missbrauchsfähigkeiten einer Sprache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 756 Viren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760 Unkontrollierte Systemzugriffe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760 Verifizierung des Bytecodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 761 Der Verifier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 761
18
Java 2 Kompendium
Inhaltsverzeichnis Der Classloader. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 762 Der Sicherheitsmanager. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 763 Digitale Unterschriften eines Applets und Verschlüsselung in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 765 Native Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 765 Weitere unerwünschte Aktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 766 14.2
ActiveX-Sicherheitskonzept im Vergleich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 766 Was sind ActiveX-Controls? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 766 Sicherheitskonzept von ActiveX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 769
14.3
Bekannte Sicherheitslücken der Java-Vergangenheit . . . . . . . . . . . . . . . . . . . . . . . . 771 Der Bytecode-Bug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 772 Schwarze Witwen und der DNS-Bug . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 773 Der CLASSPATH-Bug. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 773 Weitere Bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 774 Informationen zur Sicherheit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 775
14.4
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 775
Kapitel 15
Andere Sprachen in Ve Verbindu ndung mit Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 777
15.1
C/C++ – Unterschiede und Gemeinsamkeiten sowie die Einbindung . . . . . . . . . . . . 777 Unterschiede und Gemeinsamkeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 777
15.2
Die Verbindung von Java und nativem Code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 784 Konventioneller Einbau von C-Code in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 785 Das Java Native Interface (JNI) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 790 JNI-Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 791 Datenaustausch zwischen Java und C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 793 Java-C++-Verbindung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 794 Alternativen zum direkten Einbinden von nativen Methoden . . . . . . . . . . . . . . . . . . . . . . . 795
15.3
Verbindung von Java zu JavaScript und anderen Scriptsprachen . . . . . . . . . . . . . . . 795 Kleiner Exkurs zu JavaScript-Interna . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 797 Das Objektmodell von JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 807 Verbindung von Java und JavaScript. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 811 Applets dynamisch schreiben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 823 Verbindung mit weiteren Techniken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 826
15.4
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 827
Java 2 Kompendium
19
Inhaltsverzeichnis Kapitel 16
Weiterführ ührende nde Th Themen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 829
16.1
Reflection und Serialization. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 829 Reflection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 830 Serialization. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 831
16.2
JavaBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 832 Wie passen JavaBeans in Java? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833 Beans erstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838 Spezielle Anwendungen von JavaBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 841 Beans einer IDE bereitstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 842
16.3
Verteilte Systeme – RMI, IDL und CORBA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 842 Java IDL oder wie ist RMI in Bezug auf CORBA zu sehen? . . . . . . . . . . . . . . . . . . . . . . . . 844 Entwicklung einer CORBA-Anwendung in Java. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 846
16.4
Netzwerkzugriffe, Sockets und Servlets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853 Java-Servlets, JSP und SSI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853 Allgemeine Netzwerkzugriffe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 870 Sockets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 874
16.5
Datenbanken und JDBC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 880 Was sind relationale Datenbanken?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 881 Was ist SQL?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 883 JDBC versus ODBC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 883 Grundaufbau von JDBC und des JDBC-Managers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 884 Woraus besteht das JDBC-API? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 885 Die JDBC-Treiber. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 888 Schematischer Aufbau einer Datenbank-Applikation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 889 Praktischer Einsatz von JDBC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 891
16.6
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 904 Anhang A . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 905
A.1
Ergänzungen zu den JDK-Tools. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 905 Erweiterte Basisprogramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 905 Internationalization Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 927 Security Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 928 Java IDL- und RMI-Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 936
20
Java 2 Kompendium
Inhaltsverzeichnis A.2
IDEs für Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 938 JCreator für Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 938 Forte 2.0 for Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 941 JBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 948 Kawa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 951 Anhang B . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 955
B.1 B.2
Das Java-1.3-API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 956 Beschreibung der Pakete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 959 java.applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 960 java.awt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 960 java.awt.color . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 966 java.awt.datatransfer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 967 java.awt.dnd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 967 java.awt.event . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 968 java.awt.font . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 970 java.awt.geom. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 971 java.awt.im . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 972 java.awt.im.spi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 973 java.awt.image . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 973 java.awt.image.renderable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 976 java.awt.print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 976 java.beans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 977 java.bean.beancontext . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 978 java.io. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 979 java.lang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 983 java.lang.ref . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 988 java.lang.reflect. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 988 java.math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 989 java.net. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 989 java.rmi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 991 java.rmi.activation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 992 java.rmi.dgc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 992 java.rmi.registry. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 993 java.rmi.server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 993 java.security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 995 java.security.acl. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 997
Java 2 Kompendium
21
Inhaltsverzeichnis java.security.cert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 997 java.security.interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 998 java.security.spec . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 998 java.sql . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 999 java.text . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1000 java.util . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1002 java.util.jar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004 java.util.zip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004 javax.accessibility . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1005 javax.naming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1006 javax.naming.directory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1007 javax.naming.event, javax.naming.ldap und javax.naming.spi . . . . . . . . . . . . . . . . . . . . . . 1007 javax.rmi und javax.rmi.CORBA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1008 javax.sound.midi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1008 javax.sound.midi.spi, javax.sound.sampled und javax.sound.sampled.spi . . . . . . . . . . . . . 1009 javax.swing & Co . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1009 javax.swing.event. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1014 javax.swing.undo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1016 Die CORBA-Pakete. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1016 Nicht enthalten – das Servlets-API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1017 B.3
Die veralteten Elemente des Java-API 1.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1017 Klassen (deprecated) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1018 Interfaces (deprecated). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1018 Exceptions (deprecated) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1018 Felder (deprecated) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1018 Methoden (deprecated) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1019 Constructors (deprecated) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1025
B.4
HTML-Elemente und -Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1025 HTML-Tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1025 Die HTML 4.0-Attribute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1030
B.5
JavaScript- Token . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1070 Anhang C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1075
C.1
JAR-Archive oder wie arbeiten Komprimierungstechnologien? . . . . . . . . . . . . . . . . . 1075 Komprimierungsverfahren und Programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1075 Der Huffman-Algorithmus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1078
22
Java 2 Kompendium
Inhaltsverzeichnis Selbstextrahierende Programme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1082 Wie groß ist die Reduzierung der Datenmenge?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1083 C.2
Wie funktionieren Verschlüsselungsverfahren? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1083 Verschlüsselungs- bzw. Kryptographieprogramme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1084 Einige Verschlüsselungsverfahren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1086 PGP oder wie Java verschlüsselt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1089 Die heutigen Standard-Algorithmen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1089 Eine kleine Abschlussbemerkung zum Thema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1090
C.3
Von der Dezimalrechnung abweichende Rechenarten . . . . . . . . . . . . . . . . . . . . . . . . 1091 Binärrechnung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1091 Oktalrechnung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1092 Hexadezimalrechnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1093
C.4
Die Theorie des Zweierkomplements bei ganzen Zahlen . . . . . . . . . . . . . . . . . . . . . . 1095
C.5
Farbangaben in Java und JavaScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1097 Die direkte Angabe eines Farbnamens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1097 Die Farbangabe mittels RGB-Werten in Hexadezimalform. . . . . . . . . . . . . . . . . . . . . . . . . 1097
C.6
Erläuterung der Kurzschreibweisen von Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . 1098
C.7
Java-Quellen im Internet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1099 Anhang D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1101
D.1
Neuerungen der Java-2-Plattform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1101 Stichwortverzeichni hnis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1105
Java 2 Kompendium
23
Vorwort
Wíllkommen zu Java! Vielleicht stellen Sie sich gerade die Frage: »Was kann ich mit Java machen?« Eine einfache Antwort: Fast alles! Zumindest, wenn Sie an Programmierung denken. Grafische Animationen, Chats im Rahmen von Webseiten, Spiele, Verschlüsselungsprogramme, interaktive Webseiten, Musik, Textverarbeitungen, kleine und große Internet-Applets, riesige Programmpakete, Programme zur Bildverarbeitung, neuartige Benutzeroberflächen, Übersetzungsprogramme, Bestellsysteme, Lernanwendungen, Uhren, Office-Programme und noch viel mehr. Mit anderen Worten: Mit der Programmiersprache Java kann man jedes denkbare Programm schreiben. Zuerst profitieren natürlich das Internet und das WWW davon – auf allen möglichen WWW-Seiten werden Java-Applets eingesetzt. Aber auch jenseits des Internets gibt es einen unerschöpflichen Fundus an potenziellen Anwendungen. Sie finden mittlerweile zahlreiche in Java erstellte Applikationen auf den verschiedensten Computersystemen. Das Einsatzgebiet von Java ist jedoch nicht nur auf reine Computersysteme beschränkt, sondern erstreckt sich insbesondere auch auf die Programmierung von einer Vielzahl verwandter Geräte, die einen Prozessor beinhalten. Das sind einmal naheliegende Beispiele wie Mobiltelefone, insbesondere solche, die den neuen UMTS-Standard – Universal Mobile Telecommunication System (universelles mobiles Telekommunikationssystem) – unterstützen sollen und Videorecorder, aber auch viele andere Geräte des täglichen Gebrauchs, von denen einige auch erst in der Zukunft eine Zielplattform für eine umfangreiche Programmierung bieten. Sei es der voll programmierbare Kühlschrank, der mit einem Warenmanagementsystem selbst seinen Inhalt verwaltet und bei Bedarf selbstständig eine Bestellung per Internet aufgibt oder die Mikrowelle, die aus dem Auto heraus via Handy und Internet angeschaltet werden kann. Diese und viele andere Geräte sind keine Fiktion, sondern bereits Realität, und es ist nur noch eine Frage der Zeit, wann sie zu selbstverständlichen Gebrauchsgegenständen werden. Und mit Java steht die Technik bereit, den damit verbundenen Anforderungen der Programmierung zu begegnen.
erstellt von ciando
Auf jeden Fall ist Java »hipp«, ist heiß. Fast alle wichtigen Firmen der Computerbranche setzen seit längerer Zeit verstärkt auf Java. Zwar hatte sich die anfängliche Euphorie um Java zwischenzeitlich etwas gelegt, aber mittlerweile ist die Bedeutung von Java wieder erheblich gestiegen (nicht zuletzt Java 2 Kompendium
25
Vorwort durch die Möglichkeiten bei der Programmierung von intelligenten Geräten des täglichen Gebrauchs). Java hat sich als eine feste Größe in der EDV etabliert und wenn die Visionäre Recht behalten, wird Java bereits in naher Zukunft in fast allen datenbasierenden Geräten zu finden sein. Die immer stärker werdende Nachfrage nach Java-Programmierern zeigt zudem, wie viel Potenzial die Wirtschaft in Java sieht. Seit der Version 1.0 wurden Java und das zugehörige Entwicklungspaket JDK (Java Development Kit) immer weiter verbessert. Vor allem kann man seit dem JDK 1.2 davon ausgehen, dass Kinderkrankheiten der ersten beiden Versionen 1.0/1.1 (vor allem der Version 1.0) der Vergangenheit angehören. Das JDK 1.3 als aktuelle Basis der Java-2-Plattform hat sich insbesondere noch einmal der Performance von Java-Programmen angenommen und Java ist damit zu einer der leistungsfähigsten Entwicklerplattformen überhaupt geworden. Vor allem ist Java aber spannend und eine der innovativsten Entwicklungen der EDV-Welt seit vielen Jahren. Viel Spaß beim Erforschen, Erlernen und Programmieren wünscht Ihnen Ralph Steyer HTTP://WWW.RJS.DE
26
Java 2 Kompendium
Hinweise zum Buch
Um sich die Arbeit mit dem Buch und den Beispielen zu erleichtern, sollten Sie folgende Hinweise beachten: Beachten Sie die Tipps, Warnungen und Hinweise außerhalb des Fließtextes, ebenso besonders hervorgehobene Textpassagen. Sie finden die Beispiele und die dort verwendeten Dateien (Bilder, Datenbanken usw.) allesamt auf der Buch-CD. Aus didaktischen Gründen ist jedoch ein explizites Abtippen der Quelltexte immer sinnvoller. Aus satztechnischen Gründen ist es in einigen Listings notwendig, Strings (in Hochkommata eingeschlossene Texte) auf mehrere Zeilen aufzuteilen. Das darf im Editor bei der Eingabe des Quelltextes aber nicht gemacht werden. Mit anderen Worten – Strings müssen unbedingt in eine Zeile geschrieben werden. Zwischen den Versionen von Java bestehen erhebliche Differenzen und teilweise Inkompatibilitäten. Darauf wird an diversen Stellen im Buch hingewiesen. Die Entwicklungen rund um Java sind permanent im Fluss. Deshalb sollten Sie immer aktuelle Entwicklungen im Internet verfolgen und neueste Programme und Dokumentationen aus dem Internet bei Bedarf parat haben.
Java 2 Kompendium
27
1
What's new?
Lassen Sie uns gleich damit beginnen, uns an die faszinierende Welt von Java heranzutasten. Bevor wir jedoch zur eigentlichen Java-Schnuppertour kommen, sollen für die Leser, die Java bereits kennen, kompakt die Neuerungen von Java 2.0 und dem JDK 1.2/1.3 aufgeführt werden. In diesem Abschnitt wird eine gewisse Vertrautheit mit den wichtigsten Begriffen von Java und seinem Umfeld vorausgesetzt. Wer sich mit Java noch nicht auskennt, kann gerne später auf diesen Abschnitt zurückkommen.
1.1
Java 1.2, Java 2.0, JDK 1.2 und JDK 1.3
Java 2.0! Erheblich verspätet, aber dafür mit umso lauterem Getöse ging Java nach dem fulminanten 1.0-Einstieg und den Zwischenversionen 1.1 und 1.2 (Beta) Anfang 1999 in die zweite Runde. Im Dezember 1998 hatte Sun Microsystem (der »Eigentümer« von Java) endlich die bereits Anfang 1998 angekündigte und mehrfach verschobene Finalversion des JDK 1.2 (Java Development Kit) – der Java-Entwicklungsumgebung – freigegeben. Kurz danach gab Sun auf der Java Business Expo bekannt, dass es nicht nur ein neues JDK, sondern ein vollständiges Plattform-Update unter dem Namen Java 2.0 gibt. Diese Namenspolitik überraschte zum damaligen Zeitpunkt doch ziemlich, denn es schien bis dahin klar, dass das vollständige Update der bis dahin vertriebenen JDK-Finalversion 1.1 und seiner ergänzenden Tools als Version 1.2 in Umlauf kommt. So ganz überzeugt von seiner Namenspolitik scheint auch Sun nicht gewesen zu sein, denn das erste JDK von Java 2 – Kern der Java-2.0-Plattform – wurde innerhalb der Java-2.0-Plattform als JDK 1.2 eingeführt und auch das neue JDK von Java 2 läuft als Version 1.3. Sogar Publikationen zur Gesamtplattform wurden von Sun Microsystems noch Anfang 1999 unter dem Titel »Java 1.2« veröffentlicht. Aber um es gleich vorab festzuhalten – die Veränderungen des Java-APIs (API ist die Abkürzung für Application Programming Interface -Programmier- und Anwendungsschnittstelle), die sich noch zwischen den Betaversionen des JDK 1.2 und der als Final freigegebenen Version ergeben haben, erzwangen eine solche Namenspolitik fast unweigerlich. Es war leider so, dass beiJava 2 Kompendium
29
Kapitel 1
What's new? spielsweise das API der dritten Betaversion 1.2 und das 1.2/2.0-Final-API extrem viele Unterschiede aufwiesen. Der Oberbegriff »Java 2« macht den Break zu den Vorgängerversionen (insbesondere den inkompatiblen Betaversionen) deutlich. Mit der Einführung des JDK 1.2 und der Java-2-Plattform hatte Sun endlich einen Stand geschaffen, von dem aus es weitgehend um die Verbesserung der Stabilität (ein rigoroses Qualitätssicherungsprogramm) und Performance (Vervollkommnung der virtuellen Maschine) ging. Davor lag der Hauptfokus auf dem Ausbau und der Entwicklung von neuen Features und der Beseitigung von Schwachstellen. Zwischen dem JDK 1.2 und dem Mitte 2000 eingeführten JDK 1.3 (Codename Kestrel) hingegen sind die Unterschiede nicht mehr so gravierend, weshalb Java 2 ohne gravierende Probleme als Obermenge für beide JDK-Welten fungieren kann. Vor allem sind die Veränderungen von dem JDK 1.3 fast nur als echte Erweiterungen und Verbesserungen zu sehen, die keine gravierenden Inkompatibilitäten zum JDK 1.2 nach sich ziehen. Dementsprechend werden das JDK 1.3 wie auch das JDK 1.2 und die dazwischen liegenden Versionen JDK 1.2.1 und 1.2.2 zur Java-2-Plattform gezählt. Die vielleicht bedeutendste Erweiterung des JDK 1.3 ist die Einführung der HotSpotTechnologie. Diese beinhaltet im Wesentlichen eine so genannte adaptive Compilertechnologie, bei der interpretierte Programmteile bei Bedarf zur Ausführungszeit des Programms in Maschinencode übersetzt werden kann. Dazu zählt ebenso eine geschwindigkeitsoptimierte virtuelle Maschine für den Client und die zugehörigen, mit dem JDK 1.3 neu eingeführten neuen Optionen bei einigen Programmen des JDK. Der Mischmasch der Versionen führt bei vielen Betrachtern zu Verwirrung. Deshalb zur Klärung – wir werden uns in dem Buch mit Java 2.0 und vor allem dem dazu gehörenden JDK 1.3 beschäftigen, aber die Aussagen gelten auch meist für das JDK 1.2. Allgemein wird das gesamte Konzept zur Entwicklung von Applikationen für Java 2 mit dem JDK 1.3 unter »Java 2 SDK« zusammengefasst (SDK steht für Software Development Kit). Wesentlicher Unterschied zwischen der vollständigen Java-Plattform und dem JDK ist, dass die Plattform weitere APIs, Programme, Tools und Konzepte enthält. Hierzu zählen das JSDK (Java Servlet Development Kit), das bis zur Beta 4-Version des JDK 1.2 noch zu diesem gezählt hatte, oder auch andere Tool-Pakete, die die Funktionalität des JDK erweitern. Die aktuelle Java-2-Plattform und das Java 2 SDK (Java 2 Software Development Kit) beinhalten unter anderem folgende Basiselemente: Sichere und signierte (d.h. eindeutig identifizierbare) Applets Ein Collections Framework, d.h. eine einheitliche Architektur für die Darstellung und Manipulation von Collections, unabhängig von den Details ihrer Repräsentation
30
Java 2 Kompendium
Java 1.2, Java 2.0, JDK 1.2 und JDK 1.3
Kapitel 1
JavaBeans, d.h. Komponenten, die in Java erstellt sind und innerhalb von Java-Entwicklungsumgebungen verwendet werden können Die Unterstützung von Ein- und Ausgabe Verfahren zur Internationalisierung Umfangreiche Mechanismen zur Arbeit im Rahmen von Netzwerken Reflection, ein Verfahren, um in Java-Code Informationen über Felder, Methoden und Konstruktoren von geladenen Klassen verfügbar zu machen Sound- und Multimedia-Unterstützung Referenz-Objekte für den limitierten Zugriff auf die Garbage Collection (das Speichermanagement von Java) Object Serialization, um Objekte speichern und anschließend wieder seriell auslesen zu können Zugriff auf JAR-Files (Java-Archive) – ein besonderes Komprimierungsformat für Java Das Java Native Interface (JNI) für die Verbindung zu C/C++-Sourcen Sprach- und Utility-Packages Remote Method Invocation (RMI) für die Arbeit mit verteilten Anwendungen und CORBA (Common Object Request Broker Architecture), den Standard, der die Kommunikation zwischen Objekten und Programmen regelt Unterstützung von mathematischen Vorgängen mit großen Zahlen und hoher Genauigkeit Identifikation von Package-Versionen Plattformneutraler Zugriff auf Systemressourcen Der Extension Mechanism, um einfachen Zugriff auf Pakete zu gewährleisten, die nicht zu den Java-Standard-Packages gehören Die Version 1.3 des Java-2-SDK und der Java-2-Laufzeitumgebung beinhaltet diverse Verbesserungen zur Beschleunigung der Performance Das Konzept der zur Java-2-Plattform gehörenden Java Foundation Classes (JFC) beinhaltet folgende Details: Das Abstract Window Toolkit (AWT) zur Erstellung von einfachen grafischen Benutzeroberflächen Swing-Komponenten zur Erweiterung des AWTs Unterstützung von 2D-Graphics und -Imaging
Java 2 Kompendium
31
Kapitel 1
What's new? Das Input Method Framework für die Zusammenarbeit zwischen texteditierenden Komponenten und Eingabemethoden in den unterschiedlichsten Sprachen und verschiedensten Eingabemedien (Tastatur, Sprache oder auch handschriftlich per Schrift und sensitivem Display) Das Java-Accessibility-API, womit Java-Applikationen mit unterstützenden Technologien wie Spracherkennungssystemen oder Eingabebildschirmen interagieren können Drag&Drop-Datentransfer zum Datenaustausch zwischen Java- und nativen Applikationen, zwischen verschiedenen Java-Applikationen oder auch nur innerhalb einer einzelnen Java-Applikation Zu den erweiterten Features des Java-2-SDKs zählen die folgenden Konzepte: Als Erweiterung des Remote Method Invocation (RMI) die RMI-IIOPTechnik und Interface Definition Language (IDL) für die Erstellung von CORBA-kompatiblen Schnittstellen. RMI-IIOP ist eine neu eingeführte Technologie, die Java RMI und Java IDL verbindet und CORBA-kompatible Schnittstellen direkt in Java erstellen lässt. In dem neuen SDK verwendet Java IDL eine neue Version des Java-to-IDLCompilers. Dieser Compiler unterstützt einen neuen CORBA-Standard. Java Database Connectivity (JDBC) für den leichten und plattformneutralen Zugriff auf Datenbanken unter Java Das Java Naming and Directory Interface (JNDI) für die Angabe von Ressourcen (Verzeichnisse, Drucker usw.) über einen plattformunabhängigen Namen aus einer Java-Applikation heraus. Die JNDI-Architektur basiert auf einem eigenen API und einem SPI (Service Provider Interface). Neu in der aktuellen Java-2-Plattform ist, dass das vorher nur als Standarderweiterung vorhandene Interface nun voll integriert ist. JNDI beinhaltet u.a. Support für LDAP-v3-Erweiterungen sowie das Lightweight Directory Access Protocol (LDAP), den CORBA Object Services Naming Service (COS) und das Java Remote Method Invocation Registry (RMI). Das Java-2-SDK beinhaltet zudem einen Tool Support, der folgende Konzepte enthält: Die Java Platform Debugger Architecture (JPDA) zur Bereitstellung von drei Schnittstellen, die von Debuggern in Entwicklungsumgebungen verwendet werden können. Das Java Virtual Machine Debugger Interface definiert die Dinge, die eine JVM (Java Virtual Machine) zur Unterstützung bereitstellen muss. Das Java Debug Wire Protocol definiert die geforderten Formate und das Java Debug Interface die Informationen und Anworten auf User-Ebene.
32
Java 2 Kompendium
JavaSoft und Sun
Kapitel 1
Das Java Virtual Machine Profiler Interface (JVMPI) als eine experimentelle, nicht standardisierte Schnittstelle zum Profiling (Anpassen von Programmen an unterschiedliche Bedürfnisse) Die wesentlichen Neuerungen der Java-2-Plattform gegenüber den Vorgängerversionen konzentrieren sich auf die Bereiche Sicherheit, Interoperabilität mit anderen Systemen, Plattformneutralität, Geschwindigkeitssteigerung, Internationalisierung und Vereinfachung der Entwicklungstätigkeit. Prinzipiell sollte man dabei festhalten, dass schon im Schritt von 1.0.x auf die Final 1.1.x-Versionen erhebliche Veränderungen stattfanden. Leider gab es aber auch viele Veränderungen im Laufe der vier Betaversionen des JDK 1.2, weshalb diese Betaversionen in vielen Bereichen nicht mehr mit dem Finalrelease 1.2 (und natürlich erst recht nicht dem JDK 1.3) übereinstimmen. Gerade der Wechsel von der Beta-3-Version auf die wenig beachtete Beta-4-Version des JDK 1.2 beinhaltete zahlreiche und sehr massive Modifikationen, insbesondere auf Ebene des API, aber auch bei Tools. Viele Umsteiger von einem JDK 1.1.x oder einer der drei ersten Betaversionen 1.2 hatten deshalb ziemliche Umstellungsprobleme. Die wichtigsten dieser Reformen und Erweiterungen von Java und des JDK bis zu der aktuellen Version sollen im Rahmens dieses Buchs näher erläutert werden. Dabei sind die Änderungen im Detail natürlich so umfangreich, dass wir sie hier nicht allesamt ansprechen können. Glücklicherweise sind eine Menge von Veränderungen auch so speziell, dass »normale« Programmierer davon kaum berührt werden.
1.2
JavaSoft und Sun
»Verantwortlich« für Java ist Sun Microsystems (http://java.sun.com) bzw. JavaSoft – eine Tochterfirma der Firma Sun Microsystems. Wir werden im Folgenden nicht so genau zwischen Sun und JavaSoft trennen, da diese organisatorischen Strukturen für Sie nur am Rande interessant sein dürften. Wie dem auch sei – Sun und JavaSoft halten im Internet permanent die aktuellsten Informationen um Java bereit. Die wichtigsten Informationen kann man in folgende Bereiche klassifizieren: Neues und Aktuelles zu Java, Veränderungen u.ä. (http://java.sun.com/ products/jdk/1.3/relnotes.html bzw. http://java.sun.com/products/ jdk/1.3/docchanges.html) Bugs (http://java.sun.com/products/jdk/1.3/bugs.html) Tipps für Entwickler und FAQs (häufig gestellte Fragen) (http:// java.sun.com/products/jdk/faq.html) Kompatibilitätsfragen (http://java.sun.com/products/jdk/1.3/compatibility.html)
Java 2 Kompendium
33
Kapitel 1
What's new? Downloadmöglichkeiten für diverse Produkte (http://java.sun.com/ products/jdk/1.3/index.html bzw. http://java.sun.com/products/) Die
offizielle
Java-Sprachspezifikation
(http://java.sun.com/docs/
books/jls/html/index.html)
Die Spezifikation der virtuellen Maschine (http://java.sun.com/docs/ books/vmspec/2nd-edition/html/VMSpecTOC.doc.html) Informationen zur Java-Laufzeitumgebung und dem Java-Plug-In (http://java.sun.com/products/jdk/1.3/jre/)
1.3
Die Java-Neuerungen
Behandeln wir zuerst die Neuerungen, die Java im weiteren Sinn betreffen.
1.3.1
Kompatibilität und das Java-Plug-In
Im Allgemeinen gilt, dass Entwicklungen, die mit einer älteren Version von Java erstellt wurden, ebenso in der virtuellen Maschine der Folgeversionen ohne Probleme laufen sollten. Dies gilt sowohl auf binärer Ebene als auch auf Ebene des Quelltextes (allerdings definitiv ohne Gewährleistung durch Sun). Ausnahmen sind explizit diejenigen Java-Programme, die mit einer der Java-Vorgängerversionen erstellt wurden und die auf Klassen zurückgreifen, in welchen sicherheitsrelevante Löcher festgestellt wurden. Auch einige Java-Programme, die auf Klassen mit Implementations- oder Designbugs zurückgreifen, können unter neuen Versionen unter Umständen nicht mehr laufen. Solche Applikationen müssen bei einer Portierung von älteren auf eine neuere JVM neu kompiliert werden. Bei der Neukompilierung von älterem Java-Quellcode werden dann ziemliche Schwierigkeiten auftreten, wenn dort Java-Pakete importiert werden, die in dem neuen Konzept nicht mehr vorhanden sind (das ist zwar selten, aber möglich) oder verlagert und/oder umbenannt wurden (das ist leider sehr oft der Fall). Beispielsweise sind die Pakete des gesamten Swing-Konzeptes ab dem JDK 1.2 gegenüber der bisherigen Konzeption (Version 1.1 und sogar Beta 1.2) vollständig verlagert und umbenannt worden. In solchen Fällen muss in dem Java-Quelltext die import-Struktur dem neuen API natürlich angepasst werden. Sie finden dazu im Anhang eine Tabelle. Insgesamt gab es in der 1.1.1-Version als erste richtige Finalversion nach dem 1.0.x-Standard eine ganze Menge an neuen Funktionalitäten. Innerhalb der einzelnen Zwischenvarianten der 1.1-Versionen fanden dahingegen keine echten Erweiterungen statt, sondern weitestgehend nur Fehlerbereinigungen und interne Optimierungen.
34
Java 2 Kompendium
Die Java-Neuerungen
Kapitel 1
Die erste öffentliche JDK-Version 1.2 Beta wurde während des Jahreswechsels 1997/98 vorgestellt und enthielt doch einige Überraschungen. Insbesondere wurden einige 1.1-Entwicklungen bzw. Features der Vorgänger wieder zu den Akten gelegt, weil sie nicht ganz die Erwartungen erfüllt hatten (ein Sicherheitstool und einige Optionen). Dies bedeutet, dass in der Sicherheitsfunktionalität von Java eine gewisse Inkompatibilität zwischen Java 1.1.x und den Folgeversionen besteht. Zwischen der JDK-Version 1.2 und 1.3 wurden dann kaum noch solche Änderungen durchgeführt, die zu echten Inkompatibilitäten führen können. Applets Eine gewisse Schwierigkeit bei Java-Applets ist die Integration von JavaVersionen jenseits von Java 1.0.2 (!) in die gängigen Browser. Applets, die neuere APIs nutzten, setzen einen entsprechend kompatiblen Browser oder Viewer voraus. Dies war (und ist!) ein nicht ganz unbeträchtliches Problem, denn viele der heute noch im Internet verwendeten Browser unterstützen maximal Java 1.0.2, können also mit auf dem 1.1-API (oder Folgeversionen) basierenden Funktionalitäten nichts anfangen. Die meisten Programme, die Java unterstützen, wurden erst Anfang 1998 auf die Unterstützung von Java 1.1.3 upgedatet. So kann der Netscape Communicator in den Versionen 4.03-4.05 nur mit Java-1.1-Funktionalität umgehen, wenn er mit dem JDK-1.1-Patch ausgestattet ist. Ab der Version 4.06 ist JDK-1.1-Unterstützung dann teilweise (!) integriert. Der Microsoft Internet Explorer kann ab der Version 4.01 mit Java-1.1-Funktionalität umgehen (mit den üblichen Einschränkungen durch die Auffassung von Microsoft, was Java genau sein soll). Java 2.0 und das JDK 1.2 bzw. 1.3 mit den zugehörigen Klassen erzeugen nun aber erneut das Problem. Zusammenfassend muss man festhalten: Es gibt eine Vielzahl von Problemen, wenn Sie Applets mit Funktionalitäten erstellen, die über die Version 1.0.2 hinausgehen. Die ganze Problematik bedeutet dennoch nicht unbedingt, dass Sie für die Erstellung von Applets mit einem alten JDK arbeiten müssen. Sofern Applets mit einem beliebigen JDK erstellt und kompiliert wurden und nur auf Java-Standard-1.0.2 basierende Funktionalitäten nutzten, sollten sie auch in nur diesen Standard unterstützenden Browsern/Containern dargestellt werden können. Diese Abwärtskompatibilität wird allerdings von Sun nicht ausdrücklich garantiert. Das Java-Plug-In Die Java-2.0-Plattform beugt – im Gegensatz zu den Vorgängerversionen – Inkompatibilitäten mit Browsern vor und beinhaltet ein Java-Plug-In für Webbrowser (ehemals bekannt als Activator), das automatisch von der Installationsroutine des JDK bzw. der Laufzeitumgebung mit installiert wird. Mittels dieses Tools kann die Java-Laufzeitumgebung eines Browsers durch eine beliebige andere Java-Laufzeitumgebung ersetzt werden. Damit
Java 2 Kompendium
35
Kapitel 1
What's new? ist im Prinzip immer eine vollständig zu einer beliebigen JVM kompatible Laufzeitumgebung für Applets vorhanden. Das Java-Plug-In wurde erstmals mit dem JDK 1.2 bzw. der zugehörigen Laufzeitumgebung JRE 1.2 ausgeliefert und installierte unter Windows in das Startmenü eine Aufrufmöglichkeit.
Abbildung 1.1: Das Java-Plug-In, das mit dem JDK 1.2 ausgeliefert wurde
Im JDK 1.3 hat sich die Situation insoweit verändert, als dass das Java-PlugIn unter Windows nun über die Systemsteuerung zur Verfügung steht. Abbildung 1.2: Das Java-Plug-In des JDK 1.3 lässt sich über die Systemsteuerung starten
Nachdem Sie das Java-Plug-In gestartet haben, können Sie das als Laufzeitmanager konzipierte Tool über verschiedene Registerblätter konfigurieren.
36
Java 2 Kompendium
Die Java-Neuerungen
Kapitel 1
Am wichtigsten ist wohl, dass man in dem Registerblatt ADVANCED bzw. ERWEITERT verschiedene Java-Laufzeitumgebungen (alle auf Ihren Rechner vorhandenen) einstellen kann, die als Java-Plug-In für Browser fungieren. Es ist also nicht nur möglich, zwischen verschiedenen bei Ihnen aktuell auf dem Rechner installierten Java-Laufzeitumgebungen zu wechseln. Sie können darüber hinaus jederzeit die neueste Java-Laufzeitumgebung auf Ihrem Rechner installieren und diese steht dann theoretisch denjenigen Browsern zur Verfügung, die eine externe Java-Laufzeitumgebung verwenden können. Abbildung 1.3: Einstellen der Laufzeitumgebung
Leider funktioniert das Plug-In nicht bei allen Browsern und sie können sich nicht unbedingt darauf verlassen, dass die Browser mit dem 1.3-API oder sogar schon viel früher eingeführten Techniken wie Java 2D oder Swing tatsächlich zurechtkommen. Insbesondere Sicherheitsrestriktionen der Browser hebeln neuere Techniken immer wieder aus (Firewalls, keine Installationen von Plug-Ins auf Clientrechnern erlaubt, allgemeine Sicherheitsbedenken usw.). Die hauptsächlichen Probleme mit dem Java-Plug-In beruhen aber darauf, dass Sie bei Anwendern nicht voraussetzen können, dass das Plug-In und vor allem eine passende andere Java-Laufzeitumgebung auch wirklich installiert ist1. Ein Problem kann darin bestehen, dass die Verwendung des Java-Plug-Ins die Einbindung von Applets in Webseiten mittels des oder <EMBED>-Tags voraussetzt. Meist wird jedoch das einfachere <APPLET>Tag verwendet, und dann kann das Java-Plug-In nicht genutzt werden. Es gibt zwar von Sun einen vollständig in Java geschriebenen HTML-Konverter (zu laden von der Sun-Plug-In-Homepage http://java.sun.com/products/ 1
Dies betrifft z.B. Anwender mit einem Internet Explorer, die nicht zusätzlich eine JRE von Sun installiert haben (das ist meist der Fall).
Java 2 Kompendium
37
Kapitel 1
What's new? plugin), der aus einer Webseite mit dem <APPLET>-Tag eine solche mit -Tag (für den Internet Explorer) bzw. <EMBED>-Tag (für den Net-
scape Navigator) macht. (Defaulteinstellung ist, dass beide Versionen in die Webseite eingefügt werden). Dies hilft jedoch keinem Anwender unmittelbar, wenn er eine Seite mit einer <APPLET>-Referenz aus dem Netz lädt. Abbildung 1.4: Die Plug-In-Downloadseite von Sun
Auf Seite 35 finden Sie den Einsatz des Java-Plug-Ins konkret besprochen. Zusammenfassend kann man sagen, dass es theoretisch möglich ist, in einem moderneren Browser Applets zu verwenden, die die gleichen APIs nutzen wie eine eigenständige Java-Applikation. Das setzt aber beim Anwender erhebliche Faktoren voraus:
38
1.
Es muss eine passende Java-Laufzeitumgebung vorhanden sein. Die Java-Umgebung, die vom Browser mitgeliefert wird, reicht in der Regel nicht aus. Entweder ist also die Laufzeitumgebung des Betriebssystems ausreichend oder der Anwender muss explizit eine Laufzeitumgebung nachinstalliert haben. Das kann man bei den meisten Anwendern definitiv nicht voraussetzen.
2.
Das Java-Plug-In muss vorhanden sein oder zumindest bei Bedarf nachinstalliert werden können. Letzteres wird in professionell gemanagten Netzwerken mit Firewall und zentraler Verwaltung natürlich verhindert. Aber auch im Bereich der Standalone-Rechner verhindern viele
Java 2 Kompendium
Die Java-Neuerungen
Kapitel 1
fortgeschrittene Anwender diese Nachinstallation (Sicherheits- und Stabilitätsbedenken, unerwünschter Ressourcenverbrauch auf dem eigenen Rechner, hohe Downloadkosten usw.). 3.
Der Ersteller einer Webseite muss das veraltete und – im Vergleich zum <APPLET>-Tag – recht komplizierte <EMBED>-Tag zum Einbinden von Applets verwenden, wenn er den Navigator unterstützen will. Der Internet Explorer verlangt gar das -Tag, das die meisten Anwender wegen seiner ActiveX-Verbindung generell nicht akzeptieren. Sollen beide Browservarianten unterstützt werden, müssen (wie in unserem Beispiel gezeigt) beide Varianten in einer Webseite notiert und getrennt werden. Und damit hat man ältere Browser und einige Browser von anderen Herstellern explizit ausgeschlossen.
In einem Intranet können die genannten Faktoren leicht vorausgesetzt werden, weshalb dort Java-Applets voll ausgereizt werden können. Im Internet wird es noch einige Zeit dauern, bis die Voraussetzungen akzeptabel sind. Was heißt deprecated? Über die Entwicklung von Java wurden von Sun immer wieder Java-Elemente als »deprecated« bezeichnet, was übersetzt in etwa »missbilligt«, »veraltet« oder »verworfen« bedeutet2. Dies bedeutet aber nicht, dass Sie diese Elemente vergessen können oder nicht mehr verwenden dürfen. Diese Methoden lassen sich durchaus noch anwenden und sogar mit neueren Methoden – mit der nötigen Vorsicht – mischen. Und nicht nur das – es gibt Situationen, in denen zwingend als deprecated gekennzeichnete Techniken verwendet werden müssen! Insbesondere bei der Entwicklung von JavaApplets werden Sie normalerweise gezwungen sein, das als veraltet gekennzeichnete Eventmodell 1.0 zu verwenden. Wir werden im Abschnitt über die Ereignisbehandlung von Java sowie den Applets noch genauer darauf eingehen.
1.3.2
Interoperabilität
Es gibt mittlerweile zahlreiche Java-APIs, nicht nur von Sun, sondern von diversen Herstellern, die sich mit Java beschäftigen. Um das Zusammenspiel zwischen diesen verschiedenen APIs zu gewährleisten (die so genannte Interoperabilität), wurde das Java Collection Framework, eine formalisierte Schnittstelle zum Einbinden von neuen Java-Technologien, definiert. Dieses gehört in der Java-2-Plattform zu den Kerntechnologien.
2
Das gleiche Verfahren findet man auch bei HTML.
Java 2 Kompendium
39
Kapitel 1
What's new?
1.3.3
Anpassung einer Applikation an verschiedene Länderstandards
Eine der wichtigsten Neuerungen im Sprung von den 1.0.x-Versionen aufwärts war die mögliche Anpassung einer Java-Applikation an verschiedene Länderstandards. Eine Applikation kann so beispielsweise landesspezifische Schreibweisen berücksichtigen, wie zum Beispiel die Zeit oder das Datum. Des Weiteren ist es nun erlaubt, Texte in Menüs und Dialogen in verschiedenen Sprachen auszugeben. Der 16 Bit große Unicode kann vollständig angezeigt werden, soweit dieser bisher mit Zeichen gefüllt ist (da ist noch viel Platz). Dieser Vorgang, der von Sun mit Internationalisierung beschrieben wird, betrifft im Wesentlichen das java.text-Package und das java.ioPackage. Das zugehörige, in der Version 1.1 neu hinzugekommene Programm native2ascii konvertiert native-verschlüsselte 8-Bit-Zeichen in Unicode.
1.3.4
Erweiterung der Sicherheitsschnittstelle von Java
Java ist eine der sichersten Programmiersprachen bzw. Plattformen der EDV-Welt. Aber natürlich nicht perfekt. In der Geschichte von Java wurden – wie bei jeder vergleichbaren Umgebung – immer wieder Sicherheitslücken aufgedeckt. Die immer wieder nachgeschobenen kleinen Releasewechsel beseitigten nach und nach bekannt gewordene Sicherheitslücken (so etwa 23 der 24 in der Version 1.1 im Frühsommer 97 durch Forscher der University of Washington im Rahmen des Kimera Project entdeckten Sicherheitsrisiken) und sonstige Bugs. Eine wichtige Erweiterung der ersten Java-Plattform betraf die Sicherheitsschnittstelle von Java. Diese verbindet ab der Version 1.1 so genannte Low-Level- und High-Level-Sicherheitsfunktionalität. So können ab diesem Release Applets und Daten mit einer digitalen Unterschrift versehen werden. Das Konzept wurde im Laufe der Updates noch erweitert um abstrakte Schnittstellen für die Verwaltung von Schlüsseln, das Zertifikats-Management und die Zugriffskontrolle. Spezifische APIs zur Unterstützung von X.509 v3-Zertifikaten und anderer Zertifikatformate sowie eine umfangreiche Funktionalität im Bereich der Zugriffskontrolle sind weitere Sicherheits-Highlights der neuen JDK-Versionen. Seit der JDK 1.1-Version ist im JDK-Paket ein Tool enthalten, mit dem Sie so genannte Java-Archive (Erweiterung .jar) signieren können. JARDateien sind neu in der Version 1.1 eingeführt worden und fassen einzelne Java-Dateien zu einem Paket zusammen – später mehr dazu. Der Appletviewer erlaubt jedem aus dem Netz geladenen Applet in Form einer JARDatei, die als vertrauenswürdig eingestuft und mit diesem Tool entsprechend signiert wurde, mit denselben Rechten auf dem lokalen Rechner zu
40
Java 2 Kompendium
Die Java-Neuerungen
Kapitel 1
laufen wie eine lokale Applikation. Dies hat extrem weitreichende Konsequenzen, denn ein solches Applet ist nicht mehr Bestandteil des »Laufstalls«, in den das Java-Sicherheitsmodell Applets normalerweise zwingt. Das zugehörige Java-Sicherheitsprogramm der JDK-Version 1.1 heißt javakey. Dieses Tool ist als eine der bedeutendsten Neuerungen in der Version 1.2 durch die Programme keytool und jarsigner ersetzt worden. Im JDK 1.3 wurden die beiden Tools nochmals um eine neue Option erweitert (-provider). Daneben wurden bereits im JDK 1.2 die Sicherheitsprogramm jar und policytool hinzugefügt. Das JDK 1.2 erweiterte den Umfang der Tools, die von dem Sicherheitsmodell von Java betroffen sind, in der Finalversion um ein weiteres Programm (oldjava). Dies ist zwar nur ein Interpreter, aber dessen Hauptfunktion ist es, Applikationen zu unterstützen, die über einen eigenen Security Manager verfügen, der auf dem originalen Sicherheitsmodell von Java 1.0/1.1 basiert. Dieser wird unter der Java-2-Plattform eine Exception auswerfen und nicht starten. Solche Applikationen können mit dem Programm oldjava als Interpreter jedoch weiterverwendet werden.
1.3.5
Verschlüsselung in Java
Die Sicherheitsschnittstelle von Java bietet seit der Version 1.1 eine Unterstützung für die so genannte Public-Key-Verschlüsselung. Bekanntestes Beispiel für eine Public-Key-Verschlüsselung ist wohl PGP (Pretty Good Privacy). Die Public-Key-Verschlüsselung ist eine relativ neue und extrem zuverlässige Verschlüsselungsvariante, die mit zwei Schlüsseln arbeitet: einem privaten Schlüssel, der nur beim Sender verbleibt, und einem öffentlichen Schlüssel, der verschickt wird. Diesen zweiten Schlüssel darf jeder kennen, denn er wird ausschließlich zum Kodieren einer Nachricht benutzt. Zum Dekodieren kann er nicht verwendet werden. Die Folge ist, dass bis jetzt nur der Empfänger des Schlüssels an den Sender des Schlüssels eine kodierte Botschaft senden kann, die ausschließlich dieser dann mit seinem privaten Schlüssel dekodieren kann. Will der potenzielle Sender eine kodierte Nachricht verschicken, muss er also erst von dem potenziellen Empfänger den öffentlichen Schlüssel erhalten. Dieses Verfahren hat den riesigen Vorteil, dass der Dekodierungsschlüssel niemals verteilt werden muss und es äußerst sicher ist. Nachteil ist andererseits unleugbar, dass man einen großen Aufwand mit dem Verschicken und Verwalten der verschieden Kodierungs-Schlüssel betreiben muss. Durch die Kombination der digitalen Unterschrift und der Public-Key-Verschlüsselung können selbst sensible Daten in einer Java-Applikation verarbeitet und im Internet bereitgestellt werden.
Java 2 Kompendium
41
Kapitel 1
What's new? Zu der Funktionsweise von Verschlüsselungsverfahren im Allgemeinen finden Sie im Anhang einen Beitrag, der auf einige Grundlagen eingeht.
1.3.6
Das Abstract Window Toolkit
Als ein großer Nachteil von Java in der Version 1.0 wurde oft angeführt, dass Java durch seine Plattformunabhängigkeit für alle Architekturen und Betriebssysteme Vorsorge treffen muss und deshalb sehr oft nur den kleinsten gemeinsamen Nenner aller Fähigkeiten der einzelnen Plattformen nutzen kann. Java-Applets können immer nur die Möglichkeiten verwenden, die in ihrer internen Laufzeitbibliothek verankert sind (z.B. die Grafik-, Kommunikations-, Multithreading-Klassen bzw. die Klassen für die grafische Benutzeroberfläche). Da die Klassenbibliothek für den Entwurf einer grafischen Benutzeroberfläche – das AWT (Abstract Window Toolkit) – in der Version 1.0 relativ klein und allgemein gehalten wurde, konnten die Applets zu dieser Zeit nur eine Auswahl der unter Windows bekannten Elemente bieten. Hauptargument der Kritiker war, dass auf der WINTEL-Plattform (Windows und INTEL) basierende Computer die verbreitetsten Rechner im Internet sind (über 80 % der angeschlossenen Rechner) und Java für weniger als 20 % der Internetteilnehmer die vollständige Windowsfunktionalität aufgab. Das AWT hat in der Version 1.1 sehr weitreichende Erweiterungen erfahren. Dazu zählen eine einheitliche Druckerschnittstelle, damit Applikationen darüber plattformunabhängig drucken können (selbst dies war in der Version 1.0 noch nicht gegeben), aber auch schnelleres und einfacheres Scrolling, bessere Grafikmöglichkeiten sowie flexiblere Font-Unterstützung. Eine Unterstützung von Pop-up-Menüs und der Zwischenablage waren weitere wichtige Erweiterungen. Das 1.2/1.3-API hat gerade hier noch einmal zugelegt und viele weitere neue Funktionalitäten und Erweiterungen folgen lassen. Das neue Paket beinhaltet die erste vollständige Implementation der Java Foundation Classes (JFC), einem Satz von APIs und vorkompilierten Komponenten. Die JFC schließt nun Java 2D zur Erstellung von 2D-Grafiken, UI Components (Swing Package), Zugriffsmöglichkeiten auf diverse Hilfstechnologien (Accessibility), Drag&Drop und Application Services ein. Insbesondere das Swingkonzept erlaubt statt der davor recht rustikalen Oberfläche von JavaAnwendungen ein mehr dem durch Windows geprägten Massengeschmack angepasstes Aussehen. Das in der Version 1.0 noch sehr starr ausgelegte Eventhandling (also die Reaktion auf Ereignisse) wurde bereits für die Java-Version 1.1 völlig überarbeitet und wurde damit wesentlich flexibler. Das 1.1-Eventmodell arbeitete als Neuerung mit so genannten Delegates, d.h. Objekten, die die »Delegierten« von anderen Objekten sind. Ein Fenster erhält zum Beispiel ein 42
Java 2 Kompendium
Die Java-Neuerungen
Kapitel 1
Delegate-Objekt, an das dann eine Menge von Methoden geschickt wird, die das Delegate dann abarbeiten kann. Je nach dem Rückgabewert der Methode in dem Delegate wird das Fensterobjekt dann unterschiedlich reagieren. Das Delegate-Konzept an sich ist nicht neu und bereits ziemlich ausgereift, denn es wird schon seit Jahren unter dem Betriebsystem Nextstep, aber auch unter Windows NT und in der Entwicklungsumgebung OpenStep verwendet. Die Win-32-lmplementation des AWT wurde ebenfalls komplett überarbeitet, da die alte Version zu langsam war und viele Inkonsistenzen im Vergleich mit anderen Plattformen hatte. Damit war bereits das AWT 1.1 insgesamt erheblich schneller und stabiler geworden. Zu der Erweiterung des AWTs zählt gleichfalls das so genannte Input Method Framework. Darunter versteht man die Eingabe und Verwendung von Text, der in beliebigen Sprachen (etwa Japanisch, Chinesisch oder Koreanisch) geschrieben sein kann. Das Besondere daran ist, dass diese Zeichen über Tastenkombinationen eingegeben werden können. Sie können Tausende von Zeichen aus den unterschiedlichsten Sprachen mit Tastenkombinationen erzeugen und Java kann damit umgehen (sowohl bei der Eingabe, aber auch im AWT allgemein oder anderen Ausgaben). Die Technik ist wichtig, um Geräte zu unterstützen, denen einige Tasten fehlen (etwa Handheld-Computern). Damit wird ein wichtiger Schritt in Richtung Plattformunabhängigkeit gemacht.
1.3.7
Java-Archive
Netscape hatte bereits im Navigator der Version 3.0 das Packen mehrerer Java-Kompilate (also .class-Dateien) in eine Datei implementiert. Umgesetzt hat Sun diese Idee seit der Version 1.1 in den so genannten JARDateien (Java-Archive sind Dateien mit der Erweiterung .jar). In diesen JAR-Archiven können neben .class-Dateien gleichermaßen Image- und Sound-Dateien verpackt werden. Statt vieler einzelner und unkomprimierter Dateien wird beim Laden aus dem Netz ein gepacktes Archiv übertragen. Der Vorteil dieses Konzepts liegt darin, dass die Applikation in einer einzigen HTTP-Transaktion übertragen wird und nicht in vielen einzelnen Übertragungsschritten. Natürlich kann durch die Komprimierung der Daten zusätzlich die Transferzeit erheblich gesenkt werden. Die JAR-Funktionalität wird in dem ab der Version 1.1.x neu hinzugekommenen Package java.util.jar realisiert. Das zugehörige Java Archive Tool heißt jar. Das Tool wurde für das JDK 1.3 nochmals erheblich überarbeitet und arbeitet gegenüber den Vorgängerversionen bedeutend schneller.
Java 2 Kompendium
43
Kapitel 1
What's new?
1.3.8
Datenbankunterstützung
In Version 1.0 war für Java-Applikationen noch keine Datenbankunterstützung implementiert, was sich ab der Version 1.1 änderte. Das JDK bot nun die Möglichkeit, auf SQL-Datenbanken zuzugreifen. Bemerkenswert an dem JDK 1.2 waren insbesondere die neuen Zugriffsmöglichkeiten auf SQL-Datenbanken (inklusive SQL-3-Datentypen). Dazu dient auf der Seite von Java 2.0 die JDBC-2.0-Schnittstelle (Java Database Connectivity). Diese wiederum greift über die standardisierte ODBC-Schnittstelle auf eine SQLDatenbank zu. Die ODBC-Schnittstelle (Open Database Connectivity) stammt von Microsoft und basiert auf dem gleichen Konzept wie JDBC – dem X/Open SQL CLI (Call Level Interface). In dem Package java.sql steckt die wesentliche JDBC-Funktionalität von Java.
1.3.9
Verteilte Programmierung und Object Serialization
Im Bereich der verteilten Programmierung entwickelte sich Java über die verschiedenen Versionen erheblich. Das Remote Method Invocation Interface (RMI) bietet die Möglichkeit, beliebige Java-Klassen, die auf einer anderen virtuellen Maschine laufen, anzusprechen. Dabei ist es egal, ob die virtuelle Maschine lokal vorhanden ist oder irgendwo im Internet ausgeführt wird. Die Erweiterung des RMI-Konzeptes 1.2 erlaubt es nun, Objekte anhand einer Referenz zu reaktivieren, wenn diese zuvor persistent (dauerhaft gespeichert) gemacht wurden (Remote Object Activation). Zwei neue Programme, rmic – der Java RMI Stub Compiler, der übrigens im JDK 1.3 diverse neue Optionen hinzugefügt bekam – und rmiregistry (Java Remote Object Registry) dienen ab der Version 1.1.x zur programmiertechnischen Umsetzung des RMI-Konzeptes. Neu im JDK 1.2 ist das Tool rmid (Java RMI Activation System Daemon). In diesem Zusammenhang wurde gleichfalls das Konzept der so genannten Object Serialization aufgenommen. Es ermöglicht das Abspeichern der Inhalte eines Objekts in einen Stream. Dieser kann z.B. eine beliebige Datei sein. Ein Objekt kann in einem Stream zwischengespeichert und zu einem späteren Zeitpunkt daraus wieder aufgebaut werden. Die Lebensdauer eines Objekts kann also über die eigentliche Laufzeit eines Programms hinaus verlängert werden. Hauptanwendung hierfür ist das Versenden von Objekten über das Netzwerk im Zusammenhang mit dem RMI-Konzept. Das Package java.io ist von den entsprechenden Erweiterungen betroffen. Das JDK 1.3 erlaubt es mittlerweile, dass auch Strings, die länger als 64 KByte sind, serialisiert werden können. Das Object Serialization Tool für Java heißt serialver. 44
Java 2 Kompendium
Die Java-Neuerungen
1.3.10
Kapitel 1
Java IDL
Als eine logische Fortsetzung dieser RMI-Entwicklung folgte die Java IDL (Interfaces Definition Language), die es Java ermöglicht, eine Verbindung zu anderen Verteilungsplattformen wie zum Beispiel CORBA aufzubauen, d.h. entfernte Schnittstellen über IDL zu definieren. IDL ist eine Definitionssprache, die die Kommunikation zwischen verschiedenen Programmiersprachen über Schnittstellen ermöglicht und in das CORBA-Konzept (Common Object Request Broker Architecture) integriert. CORBA liegt derzeit in der Version 2.0 vor und ist ein plattformunabhängiger Standard, der die Kommunikation von Objekten im Netzwerk definiert. Java 2.0 bietet vollständigen CORBA-Support, indem der CORBA-Standard mithilfe des CORBA IDL Compilers integriert wird. Die Internetadresse und einige andere interessante Links zu CORBA folgen in der Tabelle: URL
Beschreibung
http://siesta.cs.wustl.edu/~schmidt/ corba.html
Detaillierte Informationen zu CORBA
http://siesta.cs.wustl.edu/~schmidt/ corba-urls.html
Eine CORBA-Link-Sammlung
http://www.sun.com/
Die Homepage von Sun lässt ebenfalls eine Suche nach dem Begriff CORBA zu.
Tabelle 1.1: CORBA-Quellen
Seit der Finalversion des JDK 1.2 haben sich in der Java IDL zahlreiche Veränderungen ergeben, die im Wesentlichen auf Grund der 2.3 OMGSpezifikation notwendig waren. Das neue API des JDK 1.3 berücksichtigt die Neuerungen mit neuen Paketen bzw. Erweiterungen der bestehenden OMG-Pakete.
1.3.11
JavaBeans
In den letztgenannten RMI-Kontext fallen ebenso die so genannten JavaBeans – Java-Komponenten innerhalb eines Objektmodells. JavaBeans ist ein portables, plattformunabhängiges, in Java geschriebenes Komponentenmodell, das von JavaSoft in Kooperation mit führenden Industrieunternehmen der Computerbranche (klangvolle Beispiele sind Apple, Borland, IBM, JustSystem, Microsoft, Netscape, Rogue Wave, SunSoft, Symantec und viele andere) entwickelt wurde. Erstmals wurde das Modell am 4. September 1996 im Internet als Konzept vorgestellt, die konkrete Realisierung dauerte natürlich länger. Die JavaBeans sind eine der wichtigsten Erweiterungen des Java-SDK 1.1 (SDK steht für Software Development Kit). In das JDK 1.2 gehörte die nächste Generation der JavaBeans (Codename Glasgow) als fes-
Java 2 Kompendium
45
Kapitel 1
What's new? ter Bestandteil. Vergleichbar sind JavaBeans mit ActiveX-Controls oder OCX-Controls. Sie können wie diese visuell manipuliert werden und bieten im Allgemeinen über so genannte Bridges eine Schnittstelle zu Komponenten wie ActiveX-Controls oder OLE-Komponenten an. Im Gegensatz zu diesen Komponenten sind JavaBeans jedoch explizit plattformunabhängig und vor allen Dingen im Sicherheitskonzept von Java integriert. Häufig wird gefragt, ob JavaBeans nicht dasselbe wie Applets sind. JavaSoft gibt als wesentlichen Unterschied die Möglichkeit der visuellen Erstellung und eine relativ eng ausgelegte Zielfunktionalität von Beans an. Allerdings stellt JavaSoft ebenso fest, dass Applets so entwickelt werden können, dass sie wie Beans aussehen und arbeiten. Um JavaBeans entwickeln und dann zu komplexen Anwendungen kombinieren zu können, musste ein eigenes Beans Developement Kit (BDK 1.0) von Sun dem JDK 1.1 (und folgende) beigefügt werden. Dieses gehört nicht zum JDK 1.2 und ist eine der Erweiterungen, die den Unterschied zwischen der vollständigen Plattform und dem JDK ausmachen. Mittlerweile sind alle wichtigen kommerziellen Java-Entwicklungstools in der Lage, JavaBeans zu erstellen. Einmal entwickelte Beans werden üblicherweise in die oben beschriebenen JAR-Dateien verpackt und beim Enduser in das Applet oder die Applikation integriert.
1.3.12
Servlets
Das Java Servlet API erlaubt die Erstellung von so genannten Java Servlets. Eingeführt wurde diese Technologie während der 1.1.x-Upgrades und richtig manifestiert in der Version 1.2. Allerdings zählt im Rahmen der Java-2Plattform auch das Servlet-API (javax.servlet.*) nicht mehr zum JDK (wie noch bis zur JDK-1.2-Beta-3-Version), sondern gilt als eigenständiges Produkt – das Java Servlet Development Kit. Es ist wie das JDK frei von Sun zur Verfügung gestellt und kann von der Servlet Product Page unter http:// java.sun.com/products/servlet/index.html heruntergeladen werden. Servlets bedeuten eine Verlagerung von Funktionalität vom Client auf den Server. Die Assoziation zu CGI-Scripts ist naheliegend. Servlets verbrauchen jedoch viel weniger Ressourcen und sind – da sie in Java geschrieben sind – im Gegensatz zu CGI-Scripts plattformunabhängig.
1.3.13
Inner Classes und Anonymous Classes
Neu in 1.1 wurden die so genannten Inner Classes eingeführt. Klassen und Interfaces können damit innerhalb anderer Klassen eingebettet werden. Solche Klassen werden innere Klassen genannt. Sie können ausschließlich die Klassen unterstützen, in die sie integriert sind.
46
Java 2 Kompendium
Die Java-Neuerungen
Kapitel 1
Damit unterstützt Java die bisher schon bei vielen Programmiersprachen praktizierte Blockstruktur innerhalb einer Klasse bzw. das dort verwendete Konstrukt. Anonymous Classes steht für eine Abart der inneren Klassen. Es handelt sich um eine Kurzform von inneren Klassen. Sie haben allerdings keinen Namen, nur eine Implementation mit new. Der Compiler generiert bei den anonymen Klassen eine namenlose Klasse, die wie spezifiziert eine bestehende Klasse dann überschreibt. Das Ende einer anonymen Klasse wird durch das Ende des mit new eingeleiteten Ausdrucks festgelegt.
1.3.14
Native Methoden
Das API, um C-Implementationen für Java-Methoden zu schreiben, ist seit der Version 1.1.x komplett gegenüber der Version 1.0.x geändert worden. Das Mapping wurde einheitlich geregelt und es ist nur ein innerer Bestandteil der Java Virtual Machine. Das Java Native Interface (JNI) ist viel einfacher anzuwenden und zu lernen als das davor verwendete Konzept. Das JNI ist eine Standardprogrammierschnittstelle, um native Java-Methoden zu schreiben und die JVM in native Applikationen einzubetten. Das primäre Ziel ist die binäre Kompatibilität von nativen Methodenbiliotheken über alle JVM-Implementationen auf den unterstützten Plattformen. JDK 1.2 erweiterte gegenüber dem JDK 1.1 das Java Native Interface mit einige neuen Features, es bleibt jedoch weitgehend gleich. Wichtig ist, dass es nun getrennte Unterstützung von dem Impelemntation von Native-Code über das JNI und älteren Schnittstellen gibt. Der resultierende Code ist erheblich effizienter als zuvor.
1.3.15
Reference Objects
Neu im JDK 1.2 wurde das Reference-Objects-Konzept eingeführt. Darunter versteht man, dass die Referenz auf ein Objekt wie ein Objekt selbst behandelt wird und damit genauso manipuliert und untersucht werden kann (siehe auch RMI). Dies funktioniert sogar noch dann, wenn auf das Objekt selbst gar nicht mehr zugegriffen werden kann (etwa, weil der Garbage Collector das Objekt gelöscht hat). Eine potenzielle Anwendung für diese Referenzobjekte ist der Aufbau eines einfachen Caches.
1.3.16
Multimedia-Unterstützung in Java 2
Multimedia nimmt in der Java-2-Plattform großen Raum ein. Mit der neuen Java-Version wird beispielsweise die Audio-Unterstützung erweitert. Sowohl in Applikationen als auch in Applets lassen sich nun MIDI-Dateien (Typ 0 und Typ 1) sowie RMF-, WAVE-, AIFF-, und AU-Dateien in hoher
Java 2 Kompendium
47
Kapitel 1
What's new? Tonqualität abspielen und zusammenmischen. Das JDK 1.3 stellt insbesondere für die Arbeit mit MIDI-Dateien einige neue Pakete zur Verfügung. Das vollständige Java Sound API bleibt bei dieser Erweiterung weitgehend erhalten, nur die Engine wurde ausgetauscht. Sie wird als eigene Sammlung ausgeliefert. Allgemein wird die Multimedia-Unterstützung von Java immer mehr in ein eigenes Framework verlagert. Zu der Java-2-Plattform zählt als eigenes Paket das Java Media Framework (JMF), das eine sehr komfortable Verbindung von verschiedenen Mediatypen mit Java-Applets und -Applikationen erlaubt (http://java.sun.com/products/java-media/jmf/). Das JMFAPI unterstützt eine einfache und vereinheitlichte Synchronisation, Kontrolle, Verarbeitung und Präsentation von komprimierten, Zeit-basierenden Mediadaten. Dies beinhaltet sowohl Javastreams als auch MIDI, Audio und Video auf allen Java-Plattformen.
1.3.17
Die Java-2D-API-Referenz
Das im JDK 1.3 enthaltene 2D-API bietet umfangreiche Klassen für die Erstellung und Entwicklung von grafischen Applikationen und Applets. Der Anspruch dieses APIs geht erheblich über das hinaus, was davor in der Grund-Java-Grafik vorgesehen war. So stehen dort primitive Grafikformen (etwa die verschiedensten Geometrieformen) sowie transparente Images (Alpha Channel) direkt als vorgefertigte Methoden zur Verfügung. Die 2DAPI lässt sich zudem zur elektronischen Bildbearbeitung oder für Präsentationen in Java verwenden. Leider muss man festhalten, dass das Java-2D-API seit der Finalversion des JDK 1.2 vielfach inkompatibel zu den davor verbreiteten Java-2D-APIs ist (sogar späten JDK-1.2-Betaversionen). Es gibt diverse Methoden, Felder und ganze Klassen, die nicht nur verlagert, sondern teilweise vollständig abgelöst wurden. Und nicht etwa, indem sie als deprecated erklärt wurden wie bei sonstigen Bestandteilen des JDK-APIs. Es gibt sie teilweise einfach nicht mehr. Man findet keinen Hinweis darauf, dass sie in einer Vorgängerversion verwendet wurden und was jetzt als Ersatz für die Funktionalität zu verwenden ist. Wenn Sie beispielsweise die Klasse java.awt.font.StyledString – eine finale Subklasse von font in der Beta 3-Version des JDK 1.2 – suchen, werden sie in der gesamten Dokumentation des JDK 1.2 bzw. 1.3 keinen Hinweis mehr darauf finden. Zwar werden das Konzept von Java 2D und die allgemeinen Veränderungen über die einzelnen Versionen davon in der offiziellen Dokumentation recht ausführlich behandelt. Dies hilft aber herzlich wenig, wenn Sie einen Java-Quelltext nach dem alten Konzept erstellt haben, ihn mit dem neuen Compiler übersetzen und nur die nichtssagende Fehlermeldung erhalten, ein bestimmtes Element sei nicht vorhanden. Es gibt keinen Hinweis auf eine Veränderung der API, und der Anwender steht da, als ob er einen Fehler 48
Java 2 Kompendium
Die Java-Neuerungen
Kapitel 1
gemacht hätte. Obwohl das neue Java-2D-Konzept mit einigen Detailmängeln der Vorgängerversionen aufgeräumt hat (insbesondere in der Darstellung des Hintergrundes bei Rotationen), werden viele Anwender ihren Wortschatz an Flüchen herauskramen, wenn bisher fehlerfreie Quelltexte scheinbar ohne Grund nicht mehr zu übersetzen sind.
1.3.18
Swing JDK 1.2/1.3 und die Java Accessibility API
Swing ist der Teil der Java Foundation Classes (JFC), der einen vollständigen Satz von GUI-Komponenten (Graphical User Interface = grafische Benutzerschnittstelle) implementiert. Das Look and Feel von Java-Benutzerschnittstellen passt sich immer mehr den Standards der GUI-Welt an. Das Swing-Konzept geht jedoch noch weiter. Swing ist vollständig in reinem Java entwickelt und dort ohne Widersprüche implementiert. Swing basiert auf dem JDK 1.1 Lightweight UI Framework und versetzt Sie in die Lage, einen Satz von GUI-Komponenten zu entwickeln, die sich automatisch zur Laufzeit dem passenden Look and Feel für jede Betriebssystemplattform (Windows, Solaris, Macintosh) anpassen – wenn Sie es wollen. Swing-Komponenten beinhalten alle bereits vorher existierenden AWT-Komponentensätze (Button, Scrollbar, Label usw.) sowie einen großen Satz von HigherLevel-Komponenten (Baumansicht, Listboxen usw.). Mit dem Java Accessibility API (ab 1.2) können Entwickler Java-Applikationen generieren, die mit innovativen Hilfstechnologien (etwa Spracheingabesystemen oder Blindensprache-Terminals) interagieren können. Die daraus resultierenden Applikationen sind nicht auf bestimmte technische Plattformen beschränkt, sondern können auf jeder Maschine eingesetzt werden, die die virtuelle Javamaschine unterstützt. Die neue Java Accessibility API ist nun eines der Kernbestandteile der Java Foundation Classes. Die Finalversion des JDK 1.2 hat bezüglich der Swing- und AccessibilityPackages eine erhebliche Veränderung gegenüber den Vorgängerversionen (auch den Betaversionen des JDK 1.2 bis Beta 3) erfahren. Die vorher in dem Namensraum com.sun.java.* (oder kurz java.*) untergebrachten Pakete wurden samt und sonders in den Namensraum javax.* verlagert. Außerdem wurde die Paketstruktur erheblich verändert. Die alte SwingAPI-Referenz (vor dem JDK 1.2 Final) sah wie folgt aus: java.awt.swing java.awt.swing.basic java.awt.swing.beaninfo java.awt.swing.border java.awt.swing.event java.awt.swing.jlf java.awt.swing.motif java.awt.swing.multi
Java 2 Kompendium
49
Kapitel 1
What's new? java.awt.swing.plaf java.awt.swing.table java.awt.swing.target java.awt.swing.text java.awt.swing.undo
Die ehemalige Accessibility-API.Referenz war Folgende: java.awt.accessibility
Ab dem JDK 1.2 Final und im JDK 1.3 gilt (inklusive der anderen in dem Namensraum javax.* vorhandenen Pakete) folgende Struktur (auch die wurde gegenüber dem JDK 1.2 Beta erweitert): javax.accessibility javax.naming javax.naming.directory javax.naming.event javax.naming.ldap javax.naming.spi javax.rmi javax.rmi.CORBA javax.sound.midi javax.sound.midi.spi javax.sound.sampled javax.sound.sampled.spi javax.swing javax.swing.border javax.swing.colorchooser javax.swing.event javax.swing.filechooser javax.swing.plaf javax.swing.plaf.basic javax.swing.plaf.metal javax.swing.plaf.multi javax.swing.table javax.swing.text javax.swing.text.html javax.swing.text.html.parser javax.swing.text.rtf javax.swing.tree javax.swing.undo javax.transaction
1.3.19
Drag&Drop
Java unterstützt den Datenaustausch zwischen Programmen per Drag&Drop (kurz DnD). Das Drag&Drop-API der Java-2-Plattform zählt ebenfalls zu der JFC und ermöglicht den Datentransfer zwischen Java und 50
Java 2 Kompendium
Die Java-Neuerungen
Kapitel 1
Native-Applikationen. Die Integration in das Swingkonzept wurde bereits in den ersten Betaversionen des 1.2-JDK vollzogen. Es gab dort jedoch durch einen Fehler in dem Swing-Eventhandling in den ersten 1.2-Betaversionen noch diverse Probleme, sodass erst ab dem 1.2-Final von einer echten Implementation gesprochen werden kann. Vollständig unterstützt werden Drag&Drop für Win32 und OSF/Motif (auf Solaris), d.h., der Datentransfer innerhalb einer JVM, zwischen verschiedenen JVMs und sogar zwischen einer JVM und einer nativen Plattform, die ihrerseits DnD-fähige Applikationen beinhaltet. Vollständig implementiert, getestet und unterstützt sind u.a. DnD-Transfers von Text (ASCII, ISO8859-1, Unicode). Transfer von Text der Form X11 Window System mit COMPOUND_TEXT-Verschüsselung wird nicht unterstützt (nicht kompatibel zu Unicode). Daneben können auch Dateien und Klassen per DnD transferiert werden (bis auf wenige Situationen getestet und vollständig unterstützt). DnD von Datentypen (plattformspezifisch oder selbst definiert), Instanzen oder serialisierten Java-Objekten sind in der Java-2-Plattform ebenfalls möglich.
1.3.20
Die Java-Standardklassen und die Datei classes.zip
Zwischen der Version 1.1 des JDK bzw. den ersten drei Betaversionen des JDK 1.2 auf der einen Seite und der Finalversion 1.2ff auf der anderen Seite hat sich der Zugriff auf die Laufzeitumgebung von Java erheblich verändert. Insbesondere wird seit dem JDK-1.2-Final die Datei classes.zip nicht mehr benötigt (sie wird auch nicht mehr zur Verfügung gestellt – Ersatz ist im Wesentlichen die Datei rt.jar). Diese hatte in den ersten Versionen von Java die Standardklassen von Java enthalten und war dementsprechend zwingend notwendig. Jedoch hat sich die Laufzeitumgebung von JDK 1.2 vollständig geändert. Seit dem JDK 1.2 verwendet das JDK für den Zugriff auf die Systemklassen nun einen Bootstrap Class Loader, der seinen eigenen Pfad für die Suche der Systemklassen verwendet. Die Folge ist, dass im neuen JDK auch nur noch selbst erstellte Klassen bei Bedarf in den CLASSPATH aufgenommen werden müssen, wobei diese Bemerkung noch ausführlicher diskutiert werden muss. Das soll aber erst bei der Besprechung der JDK-Tools erfolgen.
1.3.21
Veränderungen bei den Tools
Nicht nur neue Klassen und Methoden kamen von der Java-Einführung bis hin zu der aktuellen Java-Version hinzu. Einige der neuen Java-Fähigkeiten konnten damit praktisch nutzbar gemacht werden, indem die bereits vorhandenen JDK-Programme erweitert wurden. Aber viele der neuen Funktionalitäten machten gänzlich neue Java-Tools notwendig. Die Programme
Java 2 Kompendium
51
Kapitel 1
What's new? werden ausführlich im Rahmen des Abschnitts über die JDK-Tools beschrieben. Hier ist jedoch schon einmal vorab eine Liste der Programme, die ab der Version 1.1 hinzukamen: Das Java Archive Tool (jar) Das Digital Signing Tool (javakey) – nur in der Version 1.1 vorhanden Der Native-To-ASCII Converter (native2ascii) Der Java RMI Stub Converter (rmic) Das Tool Java Remote Object Registry (rmiregistry) Das Serialisierungstool Serial Version Command (serialver) Das Konvertierungstool AWT 1.1 Conversion Tool (updateAWT) Das Programm extcheck, ein Diagnose-Tool für Jar-File-Versionskonflikte Mit oldjava bzw. oldjavaw stehen zwei Versionen eines Javainterpreters zur Verfügung, der zum Ausführen von älteren Java-Applikationen genutzt werden kann. Dies ist unter anderem dann vonnöten, wenn diese über einen eigenen Sicherheitsmanager verfügen, der auf dem alten Sicherheitsmodell von Java beruht. Das Tool tnameserv erlaubt den Zugriff auf den benannten Service. Selbstverständlich wurden auch die bestehenden Tools im Laufe der Releasewechsel immer wieder überarbeitet, sodass hier nur ein paar besonders wichtige Details genannt werden sollen. Der Java-Compiler javac wurde für das JDK 1.3 komplett überarbeitet und bzgl. der Performance verbessert. Bereits seit dem JDK 1.2 gibt es die Option -target version. Über die Versionsangaben kann festgelegt werden, auf welcher virtuellen Maschinen eine Applikation laufen soll. Der Java-Interpreter und einige weitere Tools verstehen im JDK so genannte Non-Standard-Options. Neben dem normalen Satz von Standardoptionen gibt es die Möglichkeit, einen Satz von weitergehenden Kommandozeilenoptionen zu verwenden. Diese Non-Standard-Options beginnen fast immer mit einem -X, etwa -Xdebug oder -Xverify. Wichtigster Unterschied zwischen den Standardoptionen und den Nicht-Standardoptionen ist, dass die Unterstützung für die Standardoptionen im JDK 1.2 und allen zukünftigen Versionen der JVM von Sun garantiert wird. Eine Unterstützung für die Nicht-Standardoptionen wird jedoch ausdrücklich für zukünftige Versionen der JVM nicht garantiert.
52
Java 2 Kompendium
Die Java-Neuerungen
Kapitel 1
In Bezug auf die Sicherheit von Java haben sich über die verschiedenen Versionen des JDK häufig Veränderungen ergeben. Besonders wichtig war die Ersetzung des javakey-Tools durch keytool, jarsigner und policytool im JDK 1.2.
1.3.22
Neues Lizenzierungsmodell für Java 2.0
Mit der neuen Java-Plattform 2.0 und dem JDK 1.2 wurde auch ein neues Lizenzierungsmodell eingeführt, das die Java-Entwicklung weiter vorantreiben sollte. Dieses erleichterte insbesondere die Unterstützung von nichtkommerziellen Entwicklungen. Die Idee beruhte darauf, dass der Sourcecode des Java Runtime Environment im Internet bereitgestellt wird und von Entwicklern kostenlos benutzt und für eigene Zwecke erweitert werden darf. Und dies ohne die bis dahin vorhandene Verpflichtung, die Neuerungen von Sun wieder kostenlos zur Verfügung zu stellen. Für nichtkommerzielle Anwendungen beinhaltete das Lizenzierungsmodell auch keinerlei weitere Lizenzgebühren, wohingegen bei kommerziellen Entwicklungen – aber erst beim konkreten Vertrieb dieser Produkte – weiterhin Lizenzgebühren an Sun fällig wurden. Sun machte diese neue Lizenzpolitik folgendermaßen schmackhaft: »Das neue Modell ist eine Investition in die Zukunft unserer Kunden. Unter diesem neuen Modell verdienen auch wir kein Geld, bis diese mit Java Geld verdienen.« Sun behielt sich ansonsten eine Kompatibilitätskontrolle von Weiterentwicklungen ihrer Java-Umgebung vor. Beides – die offene Lizenzpolitik auf der einen Seite und die Kontrolle von Kompatiblitätsstandards auf der anderen Seite – sollte nach Aussage von Sun eine Balance zwischen einer offenen Weiterentwicklung von Java und einem harmonischen Plattformstandard gewährleisten. Diese Lizenzpolitik erwies sich aber entgegen der Marketingaussagen von Sun nicht als Initialzündung für das JDK 1.2 und Java 2, sondern das Gegenteil war der Fall. Die Industrie konnte sich mit dem Lizenzierungsmodell überhaupt nicht anfreunden und dementsprechend wurde der Java-2Standard nur sehr langsam umgesetzt. Da das JDK 1.2 in Bezug auf Performance nicht das hielt, was man sich davon versprochen hatte, dauerte es bis zur Einführung des JDK 1.3, bis die Euphorie der ersten Java-Versionen die Java-2-Plattform erreichte. Das JDK 1.3 hat aber dann auch bei der bis dahin skeptischen Industrie für Java den endgültigen Durchbruch geschafft.
Java 2 Kompendium
53
Kapitel 1
What's new?
1.4
Zusammenfassung
Zusammenfassend wollen wir festhalten, dass Java 2.0 sehr viele Neuerungen gebracht hat. Zum großen Teil sind sie nur für fortgeschrittene Programmierer interessant, die vor allem im professionellen Bereich Anwendungen erstellen. Dazu zählen RMI, Sicherheitsaspekte, Datenbankzugriffe oder Reflection. Andere Neuerungen sind jedoch auch schon für den OttoNormal-Programmier und sogar den Einsteiger sehr interessant. Insbesondere sollte die HotSpot-Technologie des JDK 1.3 zur Beschleunigung von Java-Prozessen den letzten echten Mangel von Java beseitigt haben.
54
Java 2 Kompendium
2
Schnuppertour Java
Obwohl Java noch nicht alt ist, hat es bereits eine bewegte Vergangenheit hinter sich. So hat Java Gegner zu gemeinsamen Projekten vereint, die ohne diese revolutionäre Technik sich wahrscheinlich nie an einen Tisch gesetzt hätten. Apple und Microsoft kooperieren beispielsweise seit geraumer Zeit bei der Entwicklung ihrer virtuellen Java-Maschinen. Aber Java erzeugt auch Unfrieden. Bekanntlich laufen diverse Klagen zwischen Sun und Microsoft. Diversen Quellen zufolge ist der Java-Erfinder Sun Gegner Nummer 1 von Microsoft. Dies macht sicher deutlich, wie mächtig Java ist, welches gewaltige Sprengpotenzial sich hinter diesem kleinen Wort verbirgt. Ob in Kooperation oder ohne Partner – zahlreiche Giganten der Computerbranche setzen mittlerweile auf Java. Die Liste liest sich wie das »Who is who« der EDV-Welt. Aber auch außerhalb der EDV-Kernbranche gibt es mehr und mehr Java-Projekte: Industrie, Banken, Versicherungen, Kreditkartenfirmen. Es gibt wahrscheinlich keine Branche, wo keine großen Java-Projekte laufen. Insbesondere nach der Jahrtausendwende und dem Freiwerden der davor in Altprojekten gebundenen Ressourcen haben Java-Projekte erheblich zugenommen. Java hat sich als eine der wichtigsten Programmiertechniken der Gegenwart etabliert. Und obwohl niemand in die Zukunft sehen kann, riskiert man wohl keine Fehlaussage, wenn man Java als die Programmiersprache der Zukunft bezeichnet. Bevor wir mit Java als Programmiersprache beginnen, soll auf die Java-Welt und das Java-Umfeld im weiteren Sinn eingegangen werden. Java unterscheidet sich in vielerlei Hinsicht von anderen Programmiersprachen wie COBOL, FORTRAN, BASIC, PASCAL oder aber auch SMALL TALK und C/C++. Die Unterschiede beschränken sich nicht auf die oft als Hauptkriterium genannte Objektorientierung von Java. Die Objektorientierung gilt zwar als eine der herausragenden Eigenschaften von Java und dürfte ein entscheidender Grund für den phänomenalen Erfolg von Java sein. Die Differenzen umfassen jedoch die komplette Java-Welt und das Java-Umfeld selbst. Immerhin gab es auch schon vor Java objektorientierte Sprachen wie Lisp oder Small Talk, die allerdings nie über ein »Mauerblümchendasein« hinaus kamen. Java muss also mehr bieten als nur Objektorientierung. Java ist für eine heterogene Welt, sei es das Internet mit seinen diversen Rechnermodellen, sei es ein PC, ein Mac, ein Unix-Rechner, sei es nur eine Kaffeemaschine oder ein Videorecorder, entwickelt worden. Die damit zusammenJava 2 Kompendium
55
Kapitel 2
Schnuppertour Java hängende Plattformunabhängigkeit ist das zweite wichtige Kriterium, um die Bedeutung von Java einschätzen zu können. Deshalb ist die Beschäftigung mit der Java-Welt sicher ein guter und gewinnbringender Einstieg in die Materie.
2.1
Was ist Java?
Java ist eng mit dem Begriff Internet verbunden. Vielfach wird Java sogar als eine reine Internet-Sprache bezeichnet. So stimmt das aber nicht, zumal Java ursprünglich gar nicht auf das Internet zielte. Internet-Sprache als Charakterisierung für Java fasst einfach nicht das ungeheure Potenzial, das in der Technologie steckt. Das oft zitierte Beispiel eines Java-Betriebssystems für eine Kaffeemaschine oder eine Waschmaschine macht die allgemeinere Bedeutung sicher deutlich. Trotzdem nimmt das Internet eine zentrale Stelle in der Java-Welt ein. Vielleicht kann man das Internet etwas unseriös als »Hebamme« für die Geburt von Java bezeichnen. Wir wollen uns Java aus diesem Grund über die Geschichte des Internets näheren.
2.1.1
Das Internet
Das Internet und seine Firmenableger – die Intranets – wachsen permanent. Das Internet boomt! Der Computer als eigenständige, unabhängige Recheneinheit gehört selbst im Privatbereich der Vergangenheit an. Kontakt zu einem Netzwerk und/oder zum Internet ist die Regel. Insbesondere sind über das Internet unzählige Rechner unterschiedlichster Bauart und mit den verschiedensten Betriebssystemen zusammengeschlossen. Das World Wide Web und die anderen Internet-Dienste sind ein riesiges, geniales, dezentrales, dynamisches, unstrukturiertes und- im besten Sinn des Wortes – chaotisches System, das sämtliche Bereiche des täglichen Lebens durchdrungen hat. Eine E-Mail-Adresse und eine Homepage sind für jedes wichtigere Unternehmen Pflicht, aber auch im Privatbereich selbstverständlich. Besonders beeindruckend ist vor allem das immer noch anhaltende rasende Wachstum des Internets. Und ein Ende ist noch nicht abzusehen. Da das Internet immer mehr von Nichtfachleuten genutzt wird, kennen auch prozentual gesehen immer weniger Anwender Details davon. Früher nutzten das Internet hauptsächlich Experten. Heute sind die Experten absolut in der Minderheit. Und so kommt es, dass das Internet von Laien oft mit dem World Wide Web (WWW) gleichgesetzt wird (so wie viele Amerikaner Bayern mit Deutschland gleichsetzen und viele Deutsche Holland mit den Niederlanden :-)). Dies kommt nicht zuletzt daher, dass die Geschichte und die anderen Dienste des Internets kaum bekannt sind. Obwohl das WWW inzwischen unbestreitbar die wichtigste Säule ist, besteht das Internet natür56
Java 2 Kompendium
Was ist Java?
Kapitel 2
lich aus mehr Diensten, ist mehr als nur das populäre WWW. Das Internet ist ein gigantisches, weltweites Computernetzwerk, das die unterschiedlichsten Dienstleistungen anbietet, die vielfach weit älter sind als das WWW. Abbildung 2.1: Das News-Fenster des Netscape Navigators
Elektronische Post, Möglichkeiten von weltweiter Werbung und Repräsentation, Diskussionsforen, das Suchen von Informationen in einer riesengroßen Informationsquelle, das Ausführen von Programmen auf entfernten Computern oder das Laden von Dateien und Programmen von – über die ganze Welt verteilten – Rechnern auf den eigenen Computer und wieder zurück sind nur einige dieser Dienste. Dazu kommen Internet-Telefonie, die Verzahnung von Arbeit auf dem lokalen Rechner und permanenten Zugriffen auf Internet-Server, Online-Bankgeschäfte und einkaufen per Internet. Wer will, kann sein ganzes Leben rund um das Internet aufbauen. Viele dieser Möglichkeiten haben primär nichts mit dem WWW zu tun (obwohl sie oft darüber mittels Verweisen genutzt werden können). Im Internet gibt es natürlich nicht nur Licht. Diverse Probleme werfen dort Schatten. Gerade die Heterogenität der Plattformen und Rechner ist sicher ein Hauptproblem für Software im Internet. Andere wesentliche Probleme betreffen die Interaktion zwischen Anwendern an ihren Clients und den Servern sowie Sicherheitsfragen. Java bietet dafür und für viele andere InternetFragen einen wichtigen Lösungsansatz.
Java 2 Kompendium
57
Kapitel 2
Schnuppertour Java
2.1.2
Ein kurzer Abriss der Internet-Geschichte
Die Geschichte des Internets zeigt eines der wenigen nützlichen Resultate des kalten Kriegs der vergangenen Jahre. Die Furcht amerikanischer Militärs vor einem Atomschlag durch die ehemalige UdSSR veranlasste in den späten Sechzigerjahren die Vereinigten Staaten von Amerika, eine Organisation namens Advanced Research Projects Agency (ARPA) zu beauftragen, für das US-Verteidigungsministerium mit großem finanziellem Aufwand ein Rechnersystem zu entwickeln, das selbst nach einem atomaren Erstschlag der UdSSR noch funktionieren sollte und den Gegenschlag organisieren konnte. Erstes Resultat war im Jahre 1969 ein Forschungsnetzwerk aus vier miteinander verbundenen Großrechnersystemen. Ein zentraler Großrechner als Mittelpunkt dieses Rechnersystems kam nicht in Frage, weil bei seinem Versagen ein Gesamtausfall des Rechnersystems die Folge gewesen wäre. Kleinere und unabhängig voneinander aufgebaute Rechnersysteme mussten entwickelt werden. Dabei war es unmöglich, nur homogene Rechnersysteme zu fordern. Die Verbindung von heterogenen Rechnersystemen war notwendig. Diese Verbindung zwischen den einzelnen Systemen sollte unter allen Umständen funktionieren – sogar beim Ausfall eines beliebigen Rechners im Netz. Da feste Standleitungen mit Sicherheit bei einer solchen Katastrophe wie einem Atomschlag zerstört würden, reichten diese als einzige Verbindung nicht aus. Zusätzlich musste das Netzwerk – ursprünglicher Name ARPANET bzw. gelegentlich ARPNET genannt – über flexible Leitungen, etwa Telefonleitungen, kommunizieren können. Für eine maximale Fehlertoleranz und Sicherheit des Netzes sollten immer mehrere Wege zwischen sämtlichen Computern im Netzwerk möglich sein. Nachrichten im Netz mussten in der Lage sein, quasi selbstständig den Weg zum Adressaten zu finden. An jedem Knotenpunkt von Informationswegen sollte eine Nachricht selbstständig den optimalen freien Weg zum nächsten Knotenpunkt finden. Dies erzwang als eine Konsequenz die Zerlegung von Informationen in kleinere Datenpakete, die unabhängig voneinander verschickt werden konnten. Für die Datenhaltung auf den einzelnen Rechnern sah das ursprüngliche Konzept folgende Logik vor: Die Daten und Funktionalitäten sollten nicht nur auf einem Rechner, sondern auf allen unabhängigen Rechnern gehalten werden (eine Art Backup-Verfahren). In regelmäß igen Abständen sollten die Daten abgeglichen werden. Dabei wurden in der Anfangsphase immer nur komprimierte Datenpakete übermittelt, die man dann offline auswerten musste. Online-Übertragung mit direkter Verwendung der Daten, wie sie heute etwa im WWW praktiziert wird, kannte man in der Anfangszeit des Internets noch nicht. Online-Anwendungen kamen erst später hinzu.
58
Java 2 Kompendium
Was ist Java?
Kapitel 2
In der Anfangsphase wuchs das ARPANET langsam (was auf Grund der zu dieser Zeit immensen Kosten sicher verständlich ist) und bestand 1972 aus ungefähr 50 Systemen. Insbesondere zwang der Kostendruck die Militärs, das Netz für zivile Zwecke zu öffnen. Besonders die National Science Foundation (NSF), eine Dachorganisation verschiedener Bildungseinrichtungen in den USA, zeigte Interesse am Internet und sorgte dafür, dass im Laufe der Zeit zahlreiche Universitäten und andere Forschungseinrichtungen an das Internet angeschlossen wurden. Damit erlangten immer mehr Personen Zugang zum Netz, die nicht unbedingt als militärisch zuverlässig zu betrachten waren. Die Militärs begannen um die Sicherheit ihrer Geheimnisse zu bangen. Große Teile des militärischen Bereichs wurden deshalb Anfang der Achtzigerjahre in ein eigenes Netz, das MILNET, ausgegliedert. Der zivile Teil wurde Internet genannt. Woher der Name »Internet« kommt, ist nicht ganz unumstritten. Es gibt einige Varianten. Folgende ist aber die wahrscheinlichste: Das Internet wird oft als das »Netz der Netze« bezeichnet. Warum gerade »Netz der Netze« und nicht »Zusammenschluss vieler Netzwerke« oder ähnlich? Der Begriff Internet steht für Interconnected Networks. Übersetzt heißt das »Netz der verbundenen Netze«. Da zentrale Ideen des Internets flexible Möglichkeiten der Datenübertragung und die Unterstützung heterogener Rechnerplattformen waren, mussten verschiedene Protokolle entwickelt werden, über die sich die Rechner verständigen konnten und die unabhängig von der eigentlichen Rechnerarchitektur und dem normalen Befehlssatz des jeweiligen Betriebssystems waren. Ein Protokoll ist allgemein als eine Vereinbarung zu verstehen, wie bestimmte Prozesse ablaufen. Das kann sowohl auf der Ebene von zwischenmenschlichen Beziehungen (etwa einem Staatsempfang) notwendig sein, aber erst recht, wenn verschiedene Computersysteme an einer Aufgabe beteiligt sind. Andere Protokolle mussten die Verbindung zwischen den Systemen regeln. Es war ja durchaus vorgesehen, dass Verbindungen über unterschiedlichste Wege aufgebaut werden, etwa einen Telefonanschluss. Und da muss beispielsweise ein kontaktierter Rechner einen Anruf eines anderen Rechners von einem Telex-, Fax- oder Sprachanruf unterscheiden können. Zusätzlich Vereinbarungen innerhalb von Protokollen regeln die konkrete Datenübertragung und überprüfen die übertragenen Daten auf Fehlerfreiheit. Da bei jeder Datenübertragung Fehler entstehen können, sind bessere Protokolle ebenfalls in der Lage, fehlerhafte Daten zu erkennen und gegebenenfalls während der Übertragung vom Sender noch einmal anzufordern.
Java 2 Kompendium
59
Kapitel 2
Schnuppertour Java Viele im Internet gebräuchliche Protokolle basieren auf Unix-Protokollen. Grund ist, dass das ursprünglich im ARPANET hauptsächlich verwendete Betriebssystem Unix war und so waren die am Anfang verwendeten Protokolle natürlich Unix-Datenübertragungsprotokolle. 1973 wurde mit IP (Internet Protocol) ein Transportprotokoll präsentiert, das plattformunabhängigen Transport von Daten garantieren sollte. Bereits Anfang 1974 erschien eine Verbesserung – das auf IP basierende Erweiterungsprotokoll TCP (Transmission Control Protocol), das eine noch fehlerfreiere Übertragung gewährleistete. TCP funktioniert nur mit IP als Unterbau, gibt aber diesem erst seine Übertragungssicherheit. Und so kommt es, dass heute beide Protokolle meist nur noch in Verbindung verwendet werden (TCP/IP). Seit 1983 ist TCP/IP das Internet-Standard-Protokoll für Direktverbindungen und dient sogar zur Definition der Begriffe Internet/Intranet (alle auf dem TCP/IP-Protokoll basierenden Netzwerke). Es löste das bis dahin verwendete Internet-Standard-Protokoll NCP (Network Control Protocol) ab. TCP/IP ist ein sehr leistungsfähiges Transportprotokoll, aber eben nur ein reines Transportprotokoll. Man kann sich die Situation ganz gut vorstellen, wenn man sie mit dem Eisenbahnverkehr vergleicht. TCP/IP ist in dieser Vorstellung das Schienennetz, über das der eigentliche Verkehr rollt. Auf diesen Schienen rollen in unserem Gedankenmodell also Züge, die als Dienstprotokolle oder Internet-Dienste bezeichnet werden. Je nach Aufgabe gibt es Personenzüge, Güterzüge, Postzüge, Wartungszüge oder kombinierte Varianten. Für verschiedene Aufgaben werden verschiedene Zugarten (Dienste) eingesetzt. Aber so, wie man in einem Personenzug auch Waren transportieren kann, so können manche Dienste im Internet auch vielfältig eingesetzt werden. Vielleicht nicht so effektiv wie die Spezialvariante, aber dennoch mit Einschränkungen möglich. Auf das Internet bezogen stellt man sich TCP/IP als untere Schicht, Dienstprotokolle als eine Schicht darüber vor. Man spricht im Zusammenhang mit dem Internet-TCP/IP-Protokoll auch von einem so genannten Schichtprotokoll. Die Dienstprotokolle, die auf dem TCP/IP-»Schienennetz« aufsetzen, sind Dienste wie Telnet, FTP oder auch das WWW. Das aus HTML aufgebaute World Wide Web wurde im Mai 1991 auf den Rechnern des Kernforschungszentrums CERN (European Organisation for Nuclear Research, Genf) erstmals offiziell vorgestellt. Die ersten Ansätze dieses Projekts gehen allerdings bereits bis in den März 1989 zurück. Damals schlug ein Mitarbeiter von CERN, Tim Berners-Lee, ein Hypertext-Projekt für das Internet vor, um darüber verteilte Inhalte miteinander zu verbinden. Es sollte ein vernetztes Hypertext-System geschaffen werden, in dem die vielen Informations-
60
Java 2 Kompendium
Was ist Java?
Kapitel 2
quellen von CERN über eine gemeinsame und vor allem einfach zu bedienende Oberfläche verfügbar sein sollten. Eigens für dieses Projekt wurde eine Organisation namens W3C (http://www.w3.org) gegründet, deren ursprüngliches Ziel es also war, Wissenschaftlern aller Fachbereiche eine leicht zu bedienende Struktur zu schaffen. Viele Wissenschaftler aus EDV-fremden Sparten waren Ende der Achtzigerjahre nicht in der Lage oder gewillt, sich mit der relativ komplizierten Befehlsstruktur von FTP, Telnet oder den anderen Diensten auseinander zu setzen. Das WWW sollte auch Nicht-EDV-Freaks unter den Wissenschaftlern die Möglichkeit eröffnen, Daten und Informationen auszutauschen und in weltweiten Datenbeständen zu recherchieren. Dabei war von vornherein vorgesehen, über reinen Text hinausgehende Daten mit einzubeziehen. Basis für eine Sprache zu Beschreibung eines solchen Hypertext-Systems war SGML (Standard Generalized Markup Language – siehe: http:// www.w3.org/MarkUp/SGML/), eine bereits seit den Sechzigerjahren verwendete Beschreibungssprache zur Darstellung von Inhalten auf unterschiedlichen Plattformen. Daraus entstand die neue Beschreibungssprache HTML (Hypertext Markup Language), die mit einer geeigneten Darstellungssoftware (dem so genannten Browser) diesen Anforderungen genügte. Mit der ersten Version von HTML präsentierte das W3C zwar nur einen aus heutiger Sicht sehr einfachen Standard, in dem zunächst nur die Möglichkeit bestand, relativ simple HyperText-Systeme im Internet aufzubauen. Diese konnten jedoch bereits wie geplant neben einfachem Text und Hyperlinks bereits Grafiken enthalten. Insbesondere war damit das daraus und dem zusätzlich entwickelten Protokoll HTTP (Hypertext Transfer Protocol) entstehende WWW bereits den bisherigen Internet-Diensten in Bezug auf Anwenderfreundlichkeit überlegen. Richtig populär wurde das Internet freilich erst durch den Mosaic-Browser, den ersten WWW-Browser mit einer grafischen Oberfläche. Die gemeinsame Erfolgsstory von WWW und dem Browser begann im Jahr 1993, als dieser von Marc Andreessen am National Center for Supercomputing Applications (NCSA – http://www.ncsa.uiuc.edu/) an der Universität von Illinois zum ersten Test freigegeben wurde. Erstmals nahm neben den bisherigen Internet-Anwendern (Militärs, Wissenschaftler und EDV-Experten) eine private Öffentlichkeit Notiz vom Internet und begann eine erste Erkundungstour mit diesem Browser. Lange Zeit stand der NSCA-Mosaic als Synonym für die Darstellungssoftware des WWW. Insbesondere ist er der Vorfahr des Netscape Navigators, den Marc Andreessen 1994 entwickelt hatte, nachdem er NSCA verlassen und mit Jim Clark die Firma Netscape gegründet hatte.
Java 2 Kompendium
61
Kapitel 2
Schnuppertour Java
2.1.3
HTML
HTML ist wie gesagt die Abkürzung für Hypertext Markup Language und wurde aus der in der ISO-Norm 8779:1986 festgeschriebenen Sprache SGML (Standard Generalized Markup Language) entwickelt. HTML ist als Ableger von SGML im Gegensatz zu SGML speziell auf Hypertext-Funktionen ausgerichtet (wie man bereits aus dem Namen ableiten kann). HTML ist für die Arbeit mit Java eine zentrale Grundlage, denn die Funktionalität von Java-Applets basiert auf einer Verknüpfung mit HTML. HTML ist keine (!) Programmiersprache wie Java, PASCAL oder C/C++, sondern eine so genannte Dokument-Beschreibungssprache (oder Dokumentenformat genannt). Mit einer Dokument-Beschreibungssprache werden die logischen Strukturen eines Dokuments beschrieben und kein Programm im eigentlichen Sinn erstellt. Insbesondere fehlen HTML Variablen und Programmfluss-Anweisungen, die zentrale Bestandteile einer Programmiersprache sind. Im Grunde gibt ein Dokumentenformat nur unverbindliche Empfehlungen an eine Darstellungssoftware (bei HTML Browser genannt), wie eine bestimmte Dokumentenstruktur darzustellen ist, damit sie dem geplanten Layout und der vorgesehenen Funktionalität entspricht. Es gibt allerdings keine absolute Darstellungsvorschrift, weswegen sich Darstellungen von HTML-Seiten in verschiedenen Browsern oft erheblich unterscheiden können (eine Folge der geplanten Plattformunabhängigkeit). Zu einer durch HTML beschriebenen logischen Dokumentenstruktur gehören Verweise, aber auch Kapitel, Unterkapitel, Absätze usw. HTMLDateien bestehen dabei aus reinem Klartext. Dadurch bleiben HTMLDokumente plattformunabhängig. Wie später bei Java war diese Plattformunabhängigkeit neben der extrem einfachen Benutzerführung per Hyperlinks in einer so heterogenen Welt wie dem Internet der wichtigste Schlüssel für den Erfolg des WWW. Plattformabhängig ist im WWW immer nur die Software zum Interpretieren der HTML-Dateien (der Browser). Da von Anfang an ein in HTML geschriebenes Dokument mit den Texten, Grafiken sowie einigen weiteren multimedialen Elementen (Sound, Video usw.) verknüpft werden sollte, mussten entsprechende Techniken entwickelt werden. Elemente, die jenseits von Textanweisungen zu sehen sind, werden in einer Webseite als Referenz auf eine entsprechende externe Datei notiert. Wenn diese in einer Webseite dargestellt werden soll, muss natürlich die Präsentations-Software entsprechende Softwaremodule und die Hardware die zugehörigen Komponenten (beispielsweise eine Soundkarte für akustische Daten) verfügbar haben. Eine weitere wichtige Eigenschaft von HTML ist, Verbindungen zu anderen Internet-Diensten in eine Webseite aufnehmen zu können. Diese werden als
62
Java 2 Kompendium
Was ist Java?
Kapitel 2
Referenz in einer Webseite notiert, weshalb unter der Oberfläche des WWW viele Dienste wie E-Mail oder FTP verfügbar gemacht werden können. Es ist sogar eingeschränkt möglich, mit HTML Datenbankabfragen zu formulieren, die Resultate optisch aufzubereiten und Menüstrukturen aufzubauen. Auch Interaktion mit Anwendern ist – allerdings mit erheblichen Einschränkungen – in purem HTML zu realisieren. Hinter der Normung von HTML stand und steht auch heute noch das World Wide Web-Consortium (W3C – http://www.w3.org) mit Sitz in Genf. HTML beinhaltete in der Version 1.0 nur wenige der heute im Web zu findenden Möglichkeiten. Da bereits der Mosaic-Browser diverse eigene Features implementiert hatte, die von dem einfachen HTML-1.0-Standard stark abwichen, und sich der Browser (und noch einige andere grafische Browser) rasend schnell verbreitete, versuchte das W3C relativ zügig, einen um einige dieser neuen Möglichkeiten erweiterten HTML-Standard zu schaffen. Der im November 1993 gestartete Versuch – ein Diskussionspapier mit dem Namen »HTML + Discussion Document« – konnte sich allerdings nicht als neuer Standard durchsetzen. Das W3C hatte sich bereits als Forum von unterschiedlichsten Interessengruppen von einer effektiven Arbeit verabschiedet. Erst im September 1995 konnte der nächste HTML-Standard, die Version 2.0, verabschiedet werden. Dieser 2.0-Standard enthielt eine ganze Menge Gestaltungsmöglichkeiten für das WWW, die sich seit dem 1.0-Standard schon in diversen Browsern als zusätzliche Features etabliert hatten. Dazu gehörten unter anderem die Elemente der äußeren Dokumentenstruktur (zum Beispiel Kopfteil mit Meta- und Titelzeile, die Body-Struktur), verschiedene Arten der Überschrift, Hyperlinks, Hervorhebungen, Befehlsstrukturen zu einer flexiblen Grafikeinbindung, aber auch bereits Tabellen, Listen und Formulare. Dies waren nur ein Teil der potenziellen HTML-Möglichkeiten, denn durch die Trägheit des W3C (in Bezug auf das unglaublich dynamische Internet) hatten sich derweil verschiedenste Browser-spezifische Dialekte gebildet, unter denen eine Standardisierung des WWW auch heute noch krankt. Die nächste HTML-Version (3.0) wurde wegen der mangelnden Konsensfähigkeit der am W3C beteiligten Organisationen und Unternehmen nie offiziell verabschiedet. Allerdings war die Version 3.0 durch viele mehrfach vorhandene, aber syntaktisch unterschiedliche Anweisungen so aufgebläht, dass die in der Ende 1996 offiziell verabschiedete Version 3.2 vorgenommene Straffung dringend notwendig war. Zwar hatte HTML 3.2 nicht mehr alle in 3.0 versuchten Möglichkeiten. Dafür wurde nun offiziell die Fähigkeit integriert, Objekte aus anderen Internet-Techniken in eine Webseite einzubauen. Insbesondere lassen sich seit dem 3.2-Standard Java-Applets in jede beliebige Webseite integrieren.
Java 2 Kompendium
63
Kapitel 2
Schnuppertour Java Der HTML-Standard 3.2 hatte ungefähr ein Jahr Bestand. Ende 1997 fand die offizielle Verabschiedung eines neuen HTML-4.0-Standards statt, der auch heute noch aktuell ist. Dieser neue HTML-Standard beinhaltet einige interessante Details, die in großen Teilen von der Java-Entwicklung beeinflusst wurden oder zumindest parallel dazu gehen.
Abbildung 2.2: Der HTML-4.0Standard wird auf den W3C-Seiten erstmals postuliert.
2.1.4
Die Organisation des Internets
Das Internet ist im besten Sinne ein chaotisches System. Das bedeutet, es gibt keine oberste Instanz, kein Kontrollorgan, keine Organisation zur Zensur. Zwar gehören einzelne Teile des Internets (Hosts, WANs, LANs, der private Rechner,...) irgendwelchen Besitzern, jedoch das ganze Netz selbst gehört niemandem. Es gibt keine zentrale Gesellschaft, die das Internet überwacht und lenkt. Es existieren jedoch einige Gruppen und Organisationen, die sich mit Entwicklungen im Internet befassen, versuchen Standards zu definieren, Absprachen zur Kontrolle zu treffen und das Internet (in gewissen Grenzen) lenken. Sie sind allerdings auf relativ freiwillige Kooperation der InternetTeilnehmer (vor allem der einflussreichen kommerziellen Unternehmen) angewiesen. Hier ist eine kleine Liste von wichtigen Organisationen (ohne Anspruch auf Vollständigkeit).
64
Java 2 Kompendium
Was ist Java?
Kapitel 2
Bezeichnung
Bedeutung
Beschreibung
ISOC
Internet Society
Eine nicht-kommerzielle Vereinigung von freiwilligen Mitgliedern. Sie beschäftigt sich im Rahmen von diversen Unterorganisationen mit den unterschiedlichsten Aspekten des Internets. De facto ist sie das Management des Internets (http://www.isoc.org).
IAB
Internet Architecture Diese Organisation (http://www.iab.org) hat die technische Entwicklung des Board Internets im Auge und ist in mehrere Gruppierungen unterteilt. Neue Technologien werden beobachtet und ggf. gefördert, neue Standards werden festgelegt. Dazu zählt als eine der wichtigsten Aktionen die Vergabe der IP-Adressen (vgl. folgenden Abschnitt).
DE-NIC
Deutsches Network Information Center
Für eine eindeutige Vergabe von Rechneradressen ist in jedem Land eine eigene Organisation verantwortlich. In Deutschland ist dies DE-NIC (http:// www.denic.de).
W3C
World Wide WebConsortium
Das W3C (http://www.w3c.org) mit Sitz in Genf ist für die Standards im WWW verantwortlich und hat sich mit diesem und HTML ein (Internet-)Denkmal geschaffen. Allerdings ist das W3C in vielen Bereichen eine zahnloser Tiger, denn die Browser-Hersteller kümmern sich oft nicht um die Empfehlungen des W3C.
NIC bzw. InterNIC
Internet Network Information Center
Dies ist die internationale Dachorganisation der regionalen Vertretungen und die oberste Ebene zur Verwaltung von Domainnamen (http://www.internic.net).
2.1.5
Tabelle 2.1: Organisationen im Internet
Die Adressierung im Internet
Unbestritten ist das Internet ein äußerst großes und komplexes Gebilde. Mainframes, eigenständige Netzwerke, einzelne Rechner – alle sind zu dem Netz der Netze zusammengeschlossen. Wie finden Daten in solch einem scheinbaren Chaos den Weg vom Sender zum Empfänger? Und bei einer Anfrage den Weg wieder zurück? Für diese Weiterleitung von Daten gibt es
Java 2 Kompendium
65
Kapitel 2
Schnuppertour Java im Internet spezielle Server mit Adressinformationen und einer Weiterleitungsfunktionalität – so genannte Router. Router erledigen die Weiterleitung von Daten durch das Netz, indem sie ein Datenpaket jeweils in die optimale Richtung schicken, damit das Datenpaket dem Ziel »näherkommt«. Wenn die kürzeste Wegstrecke jedoch verstopft ist (also fast immer :-)), kann die optimale Wegstrecke ein Datenpaket physikalisch vom Ziel entfernen. »Näherkommen« ist also in Bezug auf die Ankunftszeit zu sehen und irgendwann kommen die meisten Daten beim Adressat dann doch an. Wie aber sieht die Verarbeitung von Adressinformationen auf den Routern aus? In einem derartig komplizierten Computernetzwerk ist eine Orientierung und Navigation nur dann möglich, wenn es dort ein eindeutiges Adresskonzept gibt. Dabei müssen sowohl die einzelnen Rechner, aber auch die Softwarebestandteile eindeutige Adressen haben.
2.1.6
Die IP-Nummern
Zunächst zu den Computern selbst: Für jeden einzelnen Rechner innerhalb eines Netzwerks muss eine eindeutige Zuordnung existieren. Dies gilt selbstverständlich auf für das Internet. Diese Zuordnung geschieht im Internet über eine eindeutige Adresse, die unter dem Transportprotokoll TCP/IP genau vier Byte lang ist. Sie wird als IP-Nummer bezeichnet. Da in einem Byte 256 verschiedene Zeichen binär dargestellt werden können (2 hoch 8 = 256), lässt sich in jedem der vier Byte eine Zahl zwischen 0 und 255 verschlüsseln. Insgesamt sind so also rein theoretisch 4.294.967.296 (256 hoch 4) Computer im Internet adressierbar. Gewöhnlich werden die IP-Nummern im Dezimalsystem darstellt und jedes Byte mit einem Punkt abgetrennt (zur besseren Lesbarkeit). Eine fiktive IP-Nummer eines Host wäre also so darstellbar: 123.187.111.189 Das Adresskonzept der IP-Nummern sieht eine Gliederung der vier Byte in logische Abschnitte vor. Die Gliederung ist hierarchisch und in zwei wesentliche logische Abschnitte unterteilt. Der erste Teil der vier Byte ist die eindeutige Adresse eines Netzwerks, das mit dem Internet verbunden ist (der so genannte Netzwerkidentifikator). Der zweite Teil ist die eindeutige Adresse des einzelnen Rechners innerhalb dieses von dem ersten Byte eindeutig bestimmten lokalen Netzwerks (Hostidentifikator). Ein Datenpaket wird nur dann in einem lokalen Netzwerk weitergeroutet, wenn der Netzwerkidentifikator korrekt ist. Wie viele Bytes dabei für die Adresse des Netzwerks und wie viele Bytes für die Adresse des einzelnen Rechners verwendet werden, ist vom Typ des Netzwerks, d.h. der Grö ß e des lokalen Netzwerks, abhängig. Ein weltweit gültiges Regelwerk sorgt für die eindeutige Zuordnung und Klassifizierung. Zwar klingt das im ersten Moment ziemlich kompliziert und willkürlich, es
66
Java 2 Kompendium
Was ist Java?
Kapitel 2
ist dennoch gut durchdacht und bei näherem Hinsehen logisch. Lokale Netzwerke werden im Internet in drei Klassen unterteilt. Klasse-C-Netz: Das kleinste Netzwerk. Für die Adresse dieses Netzwerks im Internet werden die ersten drei Bytes der IP-Nummer herangezogen. Da dann nur noch ein Byte für die Adressen der einzelnen Rechner innerhalb dieses lokalen Netzwerks übrig ist, ergibt sich zwingend die maximale Grö ß e diese Netzwerktyps. Maximal 256 Rechner sind innerhalb eines C-Netzes theoretisch adressierbar. Davon gehen dann zwei reservierte Nummern noch ab. Klasse-B-Netz. Das B-Netz benutzt die ersten zwei Bytes für Adresse des Netzwerks innerhalb des Internets. Die übrigen zwei Bytes werden für eine Adressierung im lokalen Netz verwendet. Also stehen darin dann maximal 65.536 (256 * 256) eigenständige Rechneradressen im Rahmen der lokalen Netzwerks zur Verfügung (wieder abzüglich zweier reservierter Nummern, was die verfügbaren Hosts auf 65.534 reduziert). Klasse-A-Netz: Das A-Netz kann die grö ß te Anzahl von Rechnern beinhalten. Hier wird als konkrete Netzwerkadresse nur noch ein Byte genommen. Damit stehen drei Bytes zur lokalen Adressierung zur Verfügung (in der Realität bedeutet das 16.777.214 verfügbare Hostadressen pro Netzwerk). Wann eine IP-Adresse welchem Typ zuzuordnen ist, wird durch ein Konzept von Zahlengruppen festgelegt, die das erste Byte betreffen. Es muss ja eindeutig festgelegt sein, ob das zweite und dritte Byte bereits den lokalen Rechner adressiert. Das erste Byte von einem Klasse-A-Netz hat immer einen Wert zwischen 1 und 126. Dementsprechend gibt es maximal 126 verfügbare Netzwerke dieser Klasse. Der B-Netz-Bereich geht von 128 bis 191 (daraus resultieren maximal 16.3841 verfügbare Adressen für B-Netzwerke) und der Wert des ersten Byte von einem C-Netz liegt zwischen 192 und 223, was maximal über zwei Millionen verfügbare Adressen für C-Netzwerke bedeutet. Außer den Nummernkreisen ist keine andere Zuordnung festgelegt. Die Lücken in den Nummernkreisen sind für diverse Sondernetze reserviert. So entspricht die IP-Nummer 127.0.0.0 immer dem lokalen Host in einem Netzwerk. Aber auch einige Nummern, die mit einem der gerade beschriebenen Werten anfangen, werden nicht im Internet verwendet. IP-Nummern, die mit 192.168 beginnen, sind für lokale Adressierungen innerhalb eines Intranets reserviert.
1
16.384 = 64 * 256.
Java 2 Kompendium
67
Kapitel 2
Schnuppertour Java Durch die hierarchische Struktur der IP-Nummern wird ein Datenblock auf seinem Weg vom Sender zum Empfänger von einem Router zuerst nur in eine Grobrichtung weitergeleitet, die sich aus der ersten logischen Adressangabe (je nach Klasse dem ersten, den ersten beiden oder den ersten drei Bytes) ergibt. Erst wenn der Datenblock an dem Router angekommen ist, zu dem das lokale Netzwerk gehört, werden die genauen Adressangaben von innerhalb des Netzes liegenden Adress-Servern ausgewertet. Es gibt Überlegungen, das Adressierungskonzept zu erweitern, denn die Anzahl der Rechner und sonstigen Geräte mit Internetkontakt droht den Adressvorrat zu sprengen. Diskutiert wird eine abwärtskompatible Erweiterung der IP-Nummern auf 128 Bit.
2.1.7
Das DNS-Konzept
Bei fast allen Datenübermittlungen im Internet werden IP-Nummern verwendet, obwohl Anwender sie selten sehen. IP-Nummern sind zwar hervorragend dazu geeignet, in kompakter und eindeutiger Form eine Adressierung von Rechnern vorzunehmen, jedoch für Menschen sind diese abstrakten Zahlenkolonnen oft lästig. Aus diesem Grund wurde den Zahlencodes zusätzlich ein eindeutiger Alias-Name zugeordnet und diese Zuordnung weltweit auf speziellen Namensservern dokumentiert. In Gegensatz zu der Zuordnung der IP-Nummern auf Grund der Grö ß e der Netzwerktopologie erfolgt die Vergabe der eindeutigen Namen nicht über irgendwelche Grö ß enangaben oder sonstige topologische Eigenschaften, sondern ist ein System von logisch und inhaltlich zusammengehörigen Rechnergruppen. Dennoch ist auch dieses Namensystem hierarchisch geordnet. Logisch zusammengehörende Bereiche werden Domain genannt, woraus sich der Name für dieses Namenssystem ableiten lässt: Domain-Name-System, kurz DNS. Genau wie bei den IP-Nummern werden die einzelnen Bestandteile eines DNS-Namens mit Punkten getrennt, die hierarchische Wertigkeit der Stufen ist jedoch umgekehrt, also von hinten nach vorne zu lesen. Der hinterste Teil eines solchen Alias-Namens stellt die gröbste logische beziehungsweise inhaltliche Einteilung da (die so genannte Top Level Domain), etwa eine Nation oder eine Organisationsform. Der unter Umständen zweiteilige Mittelteil (die so genannte Local Level Domain (Teil 1 des Mittelteils) und die Second Level Domain (Teil 2 des Mittelteils – von hinten gelesen) ist eine genaue Beschreibung des Rechnerverbandes bzw. des Rechners selbst. Der vorderste Teil bezeichnet direkt den einzelnen Server auf einem Rechner bzw. Rechnerverband.
68
Java 2 Kompendium
Was ist Java?
Kapitel 2
Wenn Sie in einem Browser bei der Kontaktaufnahme zu einem Server die Statuszeile im Auge behalten, werden Sie dort kurz die IP-Nummer sehen, auch wenn Sie im Adresseingabefeld des Browsers oder beim Klick auf den Hyperlink nur den DNS-Namen verwendet haben. Gültige Alias-Namen (rein fiktiv) für eine Adressangabe in diesem DNSKonzept sind: ftp.cs.tu-muenchen.de www.rjs.de webscripting.de java.sun.com www.mut.de
Der hinterste Teil des DNS-Namens wird für Rechner, die ihren Standort in den USA haben, seit Beginn des Internets nach einem eigenen Regelwerk ausgewählt. In der Regel erfolgt kein direkter Hinweis auf die Nation. Es gibt in diesem nur in den USA gültigen (was bedeuten soll, die Rechner sind dort registriert, adressiert werden können sie von überall her und auch die physikalische Präsens ist davon unberührt) Regelwerk nur sechs (sieben mit dem nachfolgend letztgenannten Spezialfall) logische Bereiche, in die alle Computer in den USA unterteilt werden (daher ist die Nation implizit klar). In der folgenden Tabelle sind sie alphabetisch aufgelistet. Name des Bereichs
Abkürzung für
Bedeutung
com
commercial
Alle von kommerziellen Unternehmen betriebenen Rechner
edu
educational
Rechner von Ausbildungsinstitutionen (Universitäten, Schulen usw.)
gov
government
Regierungsbehörden
mil
military
Militärische Computer
org
organization
Rechner von nicht kommerziellen Organisationen
net
network
Organisationen, die ein eigenes Netzwerk betreiben
arpa
Advanced Research Die Gründungsorganisation des InterProjects Agency nets hat eine eigene Sonderform für ihre Top Level Domain. Sie gilt nur für diese Organisation.
Java 2 Kompendium
Tabelle 2.2: Top-Level in den USA
69
Kapitel 2
Schnuppertour Java Beispiele für gültige Namen für Rechner in den USA sind: altavista.digital.com www.webcrawler.com ourworld.compuserve.com
Ende 2000 wurde eine Erweiterung der Top-Level-Domains vorgenommen. Beschlossen wurden info (einzig offene neue Erweiterung. Markennamen werden bevorzugt), name (Domain-Erweiterung für Namen von privaten Personen, nur in Verbindung von Vor- und Nachname), pro (Freiberufler), biz (kommerzielle Unternehmen; Alternative zu com), museum (Museen), aero (Unternehmen der Luftfahrt) und coop (genossenschaftliche Unternehmen) Außerhalb den USA werden die Top Level Domain-Namen als Abkürzungen für die Ländernamen genommen. Diese Ländercodes sind in der ISO3166-Norm (http://www.din.de/gremien/nas/nabd/iso3166ma/) festgelegt. Ein paar wichtige Beispiele folgen: Tabelle 2.3: Top-Level außerhalb der USA
70
Top Level Domain
Abkürzung für
at
Österreich
au
Australien
be
Belgien
br
Brasilien
ca
Kanada
ch
Schweiz
de
Deutschland
dk
Dänemark
es
Spanien
fr
Frankreich
gr
Griechenland
hk
Hongkong
il
Israel
mx
Mexiko
nl
Niederlande
no
Norwegen
Java 2 Kompendium
Was ist Java?
Kapitel 2
Top Level Domain
Abkürzung für
pl
Polen
pt
Portugal
ru
Russland
se
Schweden
tr
Türkei
uk
Großbritannien
za
Südafrika
Tabelle 2.3: Top-Level außerhalb der USA (Forts.)
Für die USA ist die Top Level Domain us reserviert, obwohl dort ein anderes Konzept priorisiert wird. Wie wir bereits diskutiert haben, verwendet das TCP/IP-Protokoll IP-Nummern zur Adressierung. Die DNS-Namen müssen durch spezielle NamensServer erst in die zugehörigen IP-Nummern übersetzt werden. Da das Internet so groß und komplex ist, übersteigen die gesamten Alias-Namen die Kapazität eines einzelnen Namens-Servers. Sofern ein Alias-Name nicht auf dem zuerst kontaktierten Namens-Server zuzuordnen ist, wird entsprechend der Namenshierarchie in einem komplexen Verfahren der Übersetzungsauftrag an andere Namens-Server weitergeroutet, bis die IP-Nummer vollständig ermittelt ist.
2.1.8
Uniform Resource Locator
Computer sind über die IP-Nummern beziehungsweise ihre Alias-Namen eindeutig adressiert. Innerhalb des Internets müssen aber alle Daten und Programme in Form von unverwechselbaren Internetadressen adressiert werden. Dabei werden neben der Rechneradresse zusätzlich einige andere Angaben notwendig. Der Name dieser Internetadressen für konkrete Adressanfragen an Dokumente (im weitesten Sinn) im Internet lautet URL und steht für Uniform Resource Locator, was übersetzt ins Deutsche ungefähr »einheitliches Adressierungsschema für Objekte im Internet« bedeutet (ziemlich ungünstige Übersetzung, aber leider üblich und abgesehen vom Klang recht treffend). Einheitlich deshalb, weil mit einer URL sowohl verschiedenen Dienste wie WWW, FTP, Gopher usw. als auch Rechner selbst oder direkt Dokumente beschrieben werden können.
Java 2 Kompendium
71
Kapitel 2
Schnuppertour Java Der Begriff Objekt steht in diesem Zusammenhang für so ziemlich alles, was Sie im Netz finden. Die exakte Schreibweise ist je nach Dienstprotokoll leicht unterschiedlich, sieht jedoch in der Regel folgendermaßen aus: :// Dienstprotokoll steht beispielsweise für http, ftp, gopher, news, mailto oder wais. Danach folgt ein Doppelpunkt und fast immer zwei Schrägstriche zur Abtrennung (eine Ausnahme ist mailto).
Mit host.domain wird ein Server im Internet adressiert. Dabei kann direkt die IP-Nummer eingegeben werden, was jedoch nicht üblich ist. Meist nimmt man dafür den DNS-Namen in der Form Server.{LocalDomain}.SecondLevelDomain.TopLevelDomain
Auf einem Internet-Rechner kann unter einem Namen (also der DNSAngabe ohne den Server) eine ganze Reihe von verschiedenen Diensten parallel betrieben werden (üblich sind z.B. ein FTP-Server und ein HTTP-Server). Um auf einem ausgewählten Rechner den gewünschten Dienst zu erreichen, benötigt man oft eine weitere Information, den so genannten Port bzw. Kanal. Innerhalb des TCP-Headers steht ein zwei Byte großes Flag für Port-Nummern zur Verfügung. Damit sind 65.536 numerische Werte möglich (2 hoch 16). Die Port-Adressen 0 bis 1.023 sind dabei reserviert. Sie sind vordefinierten Diensten zugewiesen (wellknown ports). Port-Adressen über 1023 sind aber durchaus möglich. Welcher Dienst darüber angesprochen werden soll liegt in der Verantwortung des Anbieters. Das bedeutet, nahezu jeder Internet-Dienst hat einen Defaultwert, der immer dann verwendet wird, wenn man in einem URL keinen Port notiert. In der Regel braucht deshalb der Port nicht explizit angegeben zu werden. Der Default-Port für zum Beispiel einen HTTP-Server ist 80, ein FTP-Server hat den Port 21, Gopher benutzt den Port 70. Es ist allerdings möglich, die Ports für bestimmte Zwecke zu manipulieren, d.h. es ist optional möglich, in dem URL mit :port festzulegen, auf welchem Kanal dieser Server angesprochen werden soll. Das genaue Objekt, das mit einer DNS-Angabe referenziert werden soll, verbirgt sich hinter der Angabe . Dies ist eine übliche Pfad- und Dateiangabe im Rahmen der Verzeichnisstrukturen eines Rechners. Beachten Sie, dass diese gesamten Angaben von Unix abstammen und deshalb als Trennzeichen kein Backslash (wie unter DOS oder Windows), sondern Slash verwendet wird.
72
Java 2 Kompendium
Die Geschichte von Java
2.2
Kapitel 2
Die Geschichte von Java
Die Geschichte von Java geht bis ins Jahr 1990 zurück, in die Labors der amerikanischen Firma Sun Microsystem. Sun war (und ist) einer der führenden Hersteller von Workstations. Die Sun-Workstations basieren auf dem Unix-Betriebssystem Solaris und Sparc-Prozessoren. Abbildung 2.3: Die Sun-Homepage
Die Geschäfte der Firma Sun mit Workstations und Mainframes liefen zu dieser Zeit zwar gut, aber Sun-PCs waren eigentlich nicht richtig konkurrenzfähig. Als Reaktion auf den drohenden Einbruch im PC-Markt rief Scott McNealy, der Sun-Chef, auf Anraten eines seiner Programmierer – Patrick Naughton – eine Entwicklergruppe mit Namen »Green« ins Leben, dessen zentrale Mitarbeiter neben Naughton James Gosling und Mike Sheridan waren. In dem hochgeheimen Projekt – niemand außer den obersten Führungskräften von Sun wusste in der Anfangsphase Bescheid – sollte der zukünftige Bedarf an EDV analysiert werden, um einen zukunftsträchtigen Markt für Sun zu lokalisieren. Haupterkenntnis des Green-Projektes war, dass die Computerzukunft nicht im Bereich der Großrechner (soweit nichts Besonderes, denn dies ahnten auch damals schon andere), jedoch auch nicht unbedingt bei den PCs zu sehen ist (und dies war neu und nicht unumstritten). Der Consumerbereich der allgemeinen Elektronik (Telefone, Videorecorder, Waschmaschinen, Kaffeemaschinen und eigentlich alle elektrischen Maschinen, die Daten benötigten) war nach Ansicht des Green-Projektes der Zukunftsmarkt der EDV. Wichtigste Forderungen an ein neues, voll-
Java 2 Kompendium
73
Kapitel 2
Schnuppertour Java kommen plattformunabhängiges Betriebssystem für dieses Einsatzfeld waren eine erheblich grö ß ere Fehlertoleranz, eine leichtere Bedienbarkeit und eine bedeutend bessere Stabilität als bei bisherigen Betriebssystemen. Im Frühjahr 1991 entwickelte sich aus den Planungen ein konkretes Projekt zur Generierung eines Prototyps für ein solches universales Betriebssystem. Ab August 1991 wurde – hauptsächlich von James Gosling – nach einer geeigneten Programmiersprache dafür gesucht. Allerdings entschieden sich die Green-Entwickler nicht für eine bereits existierende Programmiersprache, denn diese wiesen zu große Schwächen in Hinblick auf die Stabilität auf. Gerade bei Bedienerfehlern – und diese gestand man beim Green-Projekt der potenziellen Zielgruppe, Consumer, im Gegensatz zur gängigen Praxis bei Computeranwendern einfach zu – waren diese Programme einfach zu intolerant. Eine neue, plattformunabhängige und objektorientierte Sprache musste entwickelt werden. Der Name für diese neue Sprache? Nein, noch nicht Java. Oak – zu deutsch Eiche. Warum Oak? Bekannt ist das Gerücht, dass James Gosling einfach kein passender Name einfiel und er beim Brüten über neue Namen permanent auf eine imposante Eiche vor seinem Büro geblickt haben soll. Eine etwas andere Variante verlegt die Eiche in ein an der Wand hängendes Bild. Dieses ist aber alles inoffiziell und sicher nicht so wichtig. Eine seriöse Erklärung für Oak ist, dass es die Abkürzung für »Object Application Kernel« war. Allerdings findet man diesen Begriff in offiziellen Sun-Quellen nicht sofort, was wohl damit zusammenhängt, dass Sun sich nicht so gerne an Oak erinnert (dazu gleich mehr). 1992 präsentierte das Green-Team der Sun-Führung mit Duke, einer kleinen Trickfigur in einem virtuellen Haus, das erste Ergebnis. Und Duke überzeugte. Ein Sun-Tochterunternehmen namens First Person (im Prinzip das Green-Projekt, aber als unabhängige Firma) wurde gegründet, um das Projekt weiter zu entwickeln und der Öffentlichkeit sowie der Elektronik- und Unterhaltungsindustrie bekannt zu machen. Die Zeit war allerdings noch nicht reif für die neue Technik, die ersten Kontakte verliefen im Sand und First Person verzettelte sich zusätzlich in viele Kleinexperimente. 1994 verschwanden Oak und First Person wieder in der Versenkung und das GreenTeam kehrte zurück zu Sun. Dann aber bewahrte ein anderes Ereignis Oak vor dem völligen Vergessen – der legendäre Mosaic-Browser. Dieser hatte sich mittlerweile als eine feste Grö ß e im Internet etabliert und mit seinen Möglichkeiten wurde plötzlich das heterogene Internet zu einer möglichen Zielplattform für Oak. William Joy, einem Mitbegründer von Sun, ist es zu verdanken, dass Oak Ende 1994 für das Internet umgearbeitet wurde und zudem entsprechend dem gerade vorexerzierten Netscape-Geschäftsmodell über das Netz frei und umsonst verteilt wurde. Die geniale Theorie hinter diesem besagten Netscape-Geschäftsmodell heißt, Marktanteile ohne Gewinn zu erobern, um dann einen Standard festlegen zu können. Kassiert wird danach. 1995 war es soweit – Oak war zum großen Auftritt im Internet bereit. Allerdings musste aus zwei Gründen ein neuer Name gefunden werden. Marketinggründe waren der eine. Oak war ob der gescheiterten
74
Java 2 Kompendium
Die Geschichte von Java
Kapitel 2
Experimente zu negativ belastet. Es gab gleichfalls juristische Schwierigkeiten, denn der Name Oak war einem anderen Produkt zu ähnlich. Und wieder war die Namensgebung eine schwierige Geburt. Man konnte sich nicht auf einen Namen einigen. Dem Gerücht nach wurde der Name dann außerhalb des eigentlichen Brainstormings in der Cafeteria gefunden. JAVA! Der Name Java ist in Amerika – wie inzwischen wohl allgemein bekannt – eine Bezeichnung (eigentlich altenglisch) für das wichtigste Grundnahrungsmittel von Programmierern: Kaffee, heißen, sehr heißen Kaffee (und ist natürlich ebenfalls eine Insel in Indonesien).
2.2.1
Erstes Java-Auftreten, HotJava und das JDK 1.0
Im März 1995 präsentierte Sun Java und das zugehörige Paket von Entwicklungs-Tools (das JDK) der breiten Internet-Öffentlichkeit. Java schlug dort bekanntlich wie eine Bombe ein. In einem Atemzug mit Java wird bei diesem Datum oft der Begriff HotJava genannt. Erst die Kombination mit HotJava verschaffte Java die gebührende Aufmerksamkeit. HotJava war die erste komplexe und vollständig in Java geschriebene Anwendung und naheliegenderweise der erste Java-fähige Browser. Und damit die Präsentationsplattform für die ersten Java-Applets. Zudem war er eine wesentliche Ergänzung der ersten Java-Entwicklungstools von Sun – dem Java Development Kit 1.0 oder kurz JDK 1.0 (HotJava gehörte und gehört immer noch nicht zu dem JDK). Dieses Development Kit soll in der neuesten Version2 natürlich noch ausführliches Thema dieses Buchs sein. Kurz nach Präsentation des JDK 1.0 wurde von der Sun-Tochter Sunsoft mit dem Java-Workshop ein kommerzielles Entwicklungspaket nachgeschoben. Dieser war wie der HotJava-Browser vollständig in Java geschrieben und damit plattformunabhängig. Außerdem bot der Java-Workshop gegenüber dem frei verfügbaren Java Developement Kit statt einer kommandozeilenorientierten Shell, rudimentären Test- und Debug-Möglichkeiten sowie einem Referenzcompiler bereits eine integrierte Entwicklungsumgebung mit Editor, Browser, Project-, Portfolio- und Build-Manager, Debugger, ProjectTester und Online-Hilfe. Andere Hersteller sollten schnell folgen und heute gibt es eine Vielzahl von integrierten Java-Entwicklungsumgebungen. Alle basieren jedoch auf dem JDK. Meist direkt, indem sie die Tools des JDK einfach aufrufen, oder indirekt, indem sie die Funktionalitäten nachbilden. Natürlich gab es im ersten JDK diverse kleinere Kinderkrankheiten. Einige betrafen die Sicherheit, andere fehlende Funktionalitäten. 2
Und auch in älteren Versionen, da es für deren Verwendung immer noch Argumente gibt.
Java 2 Kompendium
75
Kapitel 2
Schnuppertour Java
Abbildung 2.4: Der 1. Java-Workshop von Sunsoft
Dies ist für ein vollkommen neues Produkt verständlich (und leider in der Softwarebranche üblich, wie die permanenten Schnellschüsse Windows oder die verschiedenen Office-Pakete sehr drastisch zeigen) und dürfen auf keinen Fall als Kritikpunkte an Java missbraucht werden. 1997 folgte deshalb nach einigen kleinen Zwischenversionen das erste bedeutende Update mit der Version 1.1 des JDK, der diverse kleinere Verbesserungen folgen sollten. Neben den für Updates üblichen Fehlerbereinigungen enthielten die Versionen 1.1.x einige entscheidende Neuerungen. Diese machten eine ganze Reihe von neuen Tools für das Java-SDK (Software Development Kit) nötig. Bestehende Tools wurde vielfach überarbeitet und sowohl im Layout als auch im Funktionsumfang verändert. Bereits Ende 1997 gab es dann die ersten Betaversionen zum JDK 1.2 und Java 1.2, wie nach den damaligen Veröffentlichungen die komplette Plattform heißen sollte. Das Final wurde für das erste, spätestens aber das zweite Quartal 1998 angekündigt. Daraus wurde jedoch nichts. Die Einführung von Java 1.2 und JDK 1.2 wurde immer wieder verschoben. Insgesamt vier Betaversionen fanden den Weg in die Öffentlichkeit. Diese erwiesen sich als recht stabil und allgemein wurde fast täglich die Freigabe der Finalversion erwartet. Aber erst im Dezember 1998 ließ Sun gleich zweimal eine Bombe platzen. Am 4. Dezember 1998 hatte Sun endlich die Finalversion des 76
Java 2 Kompendium
Die Geschichte von Java
Kapitel 2
JDK 1.2 freigegeben. Pikanterweise erfolgte dies unmittelbar, nachdem im Rahmen des Rechtsstreits mit Microsoft um Java die Redmonder eine erneute Niederlage hinnehmen mussten. Ein Schelm, wer vermutet, Sun nutzte die Aufmerksamkeit, um die Beachtung der neuen Java-Plattform zu erhöhen. Die zweite Bombe explodierte kurz danach auf der Java Business Expo. Nicht nur ein neues JDK, sondern ein vollständiges Plattform-Update unter dem Namen Java 2.0 wurde dort offenbart. Entgegen der allgemeinen Erwartung wurde das vollständige Update nicht als Version 1.2 in Umlauf gebracht. Mitte 2000 erschien dann das JDK 1.3, das das JDK 1.2 im Rahmen der Java-2-Plattform ablöste. Die gesamte Plattform wird aber immer noch Java 2 genannt.
2.2.2
Was macht Java so einzigartig?
Im Gegensatz zu HTML ist Java das Produkt einer Organisation, nicht eines Konsortiums von unterschiedlichsten Interessengruppen. Zudem ist Java vollkommen neu entwickelt worden und muss sich nicht mit Altlasten rumplagen, wie es beispielsweise C++ tun muss. Statt sich immer auf den kleinsten Nenner einigen zu müssen, konnten relativ leicht innovative Ideen und Denkansätze verfolgt und realisiert werden. Dies ist sicher ein Baustein für Erfolg und Leistungsfähigkeit von Java. Ein weiterer Baustein ist das Umfeld, in dem Java das erste Mal präsentiert wurde. Beim Auftreten von Java gab es einige Merkmale für den einschlagenden Triumph. Dabei waren es für verschiedene Gruppen von Leuten durchaus unterschiedliche Aspekte, die Java zu dem durchschlagenden Erfolg verhalfen. Für die reinen Anwender waren es sicher im Wesentlichen zwei Dinge: grafische, dreidimensionale Animationen und Interaktionsmöglichkeiten von Internet-Anwendern. Das Auftreten von Java und etwas später seinem Skript-Ableger JavaScript kam für Internet-Anwender einer Revolution gleich. Dem WWW (von den zeilen- oder Menü-orientieren Diensten ganz zu schweigen) fehlten, mit dem bis zu diesem Zeitpunkt realisierten Stand von HTML, einige ganz entscheidende Merkmale: eine dreidimensionale Darstellung von Objekten, eine bewegte Animation und die Möglichkeit einer vernünftigen Interaktion mit dem Anwender. Java rannte mit seinen Multimedia- und Interaktionseigenschaften schon lange geöffnete Türen ein. Die ziemlich eingeschränkten Interaktionsmöglichkeiten von WWW-Surfern beruhten bis dahin im Wesentlichen auf so genannten Hotspots, sensitiven Elementen auf HTML-Seiten, die beim Anklicken eine Aktion auslösten. Bei der Mausaktion »Klick« muss bei Hotspots die Cursorposition ausgewertet und zum Server zurückgeschickt werden (wie auch immer technisch realisiert). Aber auch eine Tastatureingabe des Anwenders auf einer Java 2 Kompendium
77
Kapitel 2
Schnuppertour Java Webseite musste zum Server übermittelt werden. Auf dem Server wurde die Eingabe verarbeitet und eine neue HTML-Seite zurück zum Client geschickt. Dieser Mechanismus wird CGI (Common Gateway Interface) genannt. Die grö ß te Arbeitslast liegt bei den Servern und den Leitungen des Internets. Der Client steht relativ ungenutzt herum und wartet (meist sehr, sehr lange). Der Ansatz von Java für die Optimierung dieser Vorgänge lag darin, dem Prozessor des Clients einen Teil der Arbeit zu übertragen. Denn obwohl die Rechner der Internet-Anwender immer leistungsfähiger wurden, lagen sie für die Internet-Arbeit normalerweise ziemlich brach. Der Client wurde zum dummen Terminal aus grauer Großrechner-Urzeit degradiert. Es war eigentlich absolut unlogisch, einen Hochleistungs-PC oder einen vergleichbaren Rechner als Client zu verwenden und ihn mit Aufgaben zu betrauen, die ein ZX81 (Kultrechner Anfang bis Mitte der 80er-Jahre mit Folientastatur und 1-16 KByte Hauptspeicher) zur Not noch zu Wege gebracht hätte. JavaApplets sorgten also mit einer Arbeitsverlagerung auf den Client für Aufsehen. Das zweite Java-Highlight für die Anwender – die neuen Darstellungsmöglichkeiten – sorgte zum ersten Mal für echtes Multimedia im Internet. Als Java der Öffentlichkeit präsentiert wurde, fanden Anwender bis dahin beim Surfen nur passive Seiten (zudem noch zweidimensional) vor, die weitgehend in HTML 1.0 oder 2.0 geschrieben waren. Selbst wenn es Texte mit Hyperlinks waren und recht komfortabel Effekte wie Grafiken oder Sounds eingebunden werden konnten, die Einschränkung »Text« blieb. Insbesondere die dreidimensionale Darstellung von Objekten war damit nicht zu realisieren. Genauso wenig eine bewegte Animation. Mit Java änderte sich die Situation schlagartig, die dritte Dimension hielt bewegend Einzug ins Netz. Für die EDV-Spezialisten gab es neben diesen beiden offensichtlichen Knallern jedoch noch andere Gründe. Ein oft genannter Grund ist, dass Java ohne Mitwirkung des »Reichs des Bösen« (liebevoller Kosename für Microsoft – zumindest von allen Nicht-Microsoft-Abhängigen) entstanden ist. Da gab es etwas Neues, Revolutionäres, Innovatives und Bill Gates war nicht dabei. Nicht nur das, Microsoft schätzte als einziges wichtiges EDV-Unternehmen die Internetentwicklung zu dieser Zeit vollkommen falsch ein und ignorierte die ungeheuren Zukunftsperspektiven. Eine in der Computerwelt zu diesem Zeitpunkt einmalige Chance für andere/neue Unternehmen, EDVEntwicklung zu gestalten, ohne von Microsoft die Richtung angezeigt zu bekommen. Firmen wie Sun oder Netscape nutzten die Gunst der Stunde. Bald aber hatte Microsoft seine erste Fehleinschätzung revidiert und sich mit Vehemenz in Entwicklungsprojekte rund um das Internet gestürzt. Allerdings schien es lange so, als ob sich Microsoft bei Java ziemlich kooperativ verhalten wollte. Die Partnerschaft mit Apple bzgl. der JVM- und JRE-
78
Java 2 Kompendium
Die Geschichte von Java
Kapitel 2
Entwicklung (JRE – Java Runtime Environment) signalisierten Kooperationsbereitschaft mit anderen Unternehmen. Diverse Aktionen von Microsoft in der jüngeren Vergangenheit verstärkten jedoch wieder die Befürchtungen der Anti-MS-Gemeinde, Bill Gates wolle doch Java und das Internet umarmen und verschlingen. Dazu zählt beispielsweise die Weigerung von Microsoft, die Java Foundation Classes, die Klassenbibliothek zur Erstellung grafischer Oberflächen, als Bestandteil der Sprache Java anzusehen. Damit wähnt sich Microsoft natürlich frei von etwaigen Lizenzbestimmungen, die Microsoft dazu verpflichten würden, die JFC mit jeder Java-VM auszuliefern – und damit in den Internet Explorer und Windows zu integrieren. Microsoft entwickelte statt dessen zwei Gegenentwürfe: Die eigenen AWTKlassen und J/Direct (Teil der Direct-Technologie von Microsoft), das es Java-Programmen erlaubt, Windows-Routinen zu nutzen. Beides natürlich plattformabhängig an Windows gebunden. Dies und diverse andere Aktionen führten zu mehreren Rechtsstreitigkeiten zwischen Sun und Microsoft, wobei Sun die meisten gewonnen hat. Insbesondere hat Sun erreicht, dass bestimmte Microsoft-Produkte das Java-Logo nicht führen dürfen, wenn sie nicht den Sun-Vorgaben entsprechen. Aber zurück zu den Erfolgsfaktoren von Java: Die Java-Eigenschaften Objektorientiertheit und Plattformunabhängigkeit waren die weiteren und wohl wichtigsten Gründe für den Erfolg. Und last but not least – die extreme Stabilität von Java.
2.2.3
Die Herkunft von Java
Java hat – wie jedes gute Kind – offiziell zwei Elternteile. Die Syntax ist im Wesentlichen eine an C/C++ angelehnte Programmiersprache, die Konzeption und die Objektorientiertheit stammen eher von dem anderen Elternteil – Small Talk. Als »Trauzeugen« werden ab und zu noch Eiffel und Objective-C genannt. Warum aber ist Java so erfolgreich? Eigentlich war es ein einfaches Rezept: Es wurden die Stärken der Vorfahren genommen, die Schwächen ausgemerzt und dann fehlende, sinnvolle Innovationen hinzugefügt. Zwar war einer der Java-Ahnen sowieso objektorientiert (Small Talk), jedoch kaum verbreitet. Dies liegt wohl in der vollständigen Andersartigkeit von Small Talk (gegenüber anderen Programmiersprachen wie C, PASCAL, Basic, COBOL oder FORTRAN). Small Talk ist zwar sehr leicht zu erlernen, jedoch einfach nicht mit gewohnten Befehlsstrukturen vergleichbar. Zumindest aus damaliger Sicht. Java macht nicht den Fehler von Small Talk und vermeidet ein gänzlich neues Befehlskonzept, sondern definiert sich von der Syntax eigentlich als eine Art bessere Untermenge von C++. Der Umstieg von C/C++ auf Java stellt also für die meisten Entwickler keinen großen Aufwand dar.
Java 2 Kompendium
79
Kapitel 2
Schnuppertour Java Von dem anderen Elternteil C/C++ hat sich Java zwar die Syntax geliehen, aber diverser C/C++-Altlasten entledigt und ist erheblich einfacher geworden, ohne viel an Leistungsfähigkeit gegenüber C/C++ zu verlieren. Dies betrifft einmal die Objektorientierung. Obwohl man mit C/C++ objektorientiert programmieren kann, hatte die überwiegende Mehrzahl der Programmierer C/C++ nie so eingesetzt. Die Möglichkeit des prozeduralen (altbekannten) Programmierens untergräbt bei C/C++ den strengen objektorientierten Gedanken. Java lässt einem Programmierer diese Wahl nicht. Man kann nur objektorientiert programmieren. Aber im Gegensatz zu C++ wurde keine Mehrfachvererbung realisiert, was Java-Programme viel besser wartbar macht. Ein weiterer Vorteil von Java gegenüber C/C++ ist, dass die JavaSyntax weniger kompliziert ist. Dies betrifft im Wesentlichen ziemlich üble C/C++-Möglichkeiten wie Zeiger, Operator-Overloading, manuelle Speicherverwaltung (d.h. das Speichermanagement, also das Beschaffen und das Freigeben von Speicher durch den Programmierer), automatische Konvertierung von Datentypen, Headerdateien, Pre-Prozessoren, Strukturen, VariantDatentypen und multidimensionale Arrays. Auf die genauen Unterschiede soll an einer anderen Stelle im Buch eingegangen werden. Insbesondere sollte Java nach Erwartung der Java-Väter (und Mütter) einige der wichtigsten Probleme moderner Programmierung lösen. Kernprinzipien von Java sollten die Eigenschaften kompakt, zuverlässig, portierbar, dezentral, echtzeitfähig und integriert sein. Die offizielle Definition von Sun Microsystems zu Java lautet folgendermaßen: Java: eine einfache, objektorientierte, dezentrale, interpretierte, stabil laufende, sichere, architekturneutrale, portierbare und dynamische Sprache, die Hochgeschwindigkeits-Anwendungen und Multithreading unterstützt. Im Einzelnen bedeutet dies: Java ist einfach, obwohl sehr nahe an der (ziemlich komplizierten) C/C++-Syntax entworfen wurde. Dadurch soll Java für C/C++-Progammierer schon auf den ersten Blick vertraut und verständlich sein und damit die Einarbeitungszeit kurz halten. Dass Java einfach zu erlernen ist (wie Sun behauptet), dem werden jedoch vor allem Programmieranfänger wohl trotzdem kaum zustimmen. Dazu ist Java auch zu mächtig. Aber da auf viele C/C++-Spezialitäten verzichtet wurde, hat Java unter der Prämisse »Weniger ist mehr« erheblich gewonnen. Hinzugefügt wurden dafür selektive und bisher nicht in C/C++ implementierte Funktionalitäten, die die Entwicklung, Implementation und Instandhaltung der Software erleichtern sollen. Obwohl beispielsweise OperatorenÜberladung weggelassen wurde, wurde das Überladen von Methoden beibehalten. Oder für das Speichermanagement, eine der Hauptfehlerquellen bei C/C++-Programmen, verfügt Java über eine automatische Garbage Collection (automatische Speicherbereinigung). Da Java über
80
Java 2 Kompendium
Die Geschichte von Java
Kapitel 2
diesen automatischen Garbage Collection-Mechanismus verfügt, vereinfacht es nicht nur die Programmierung, sondern verringert daneben die Anzahl der Fehler und beseitigt das alte C/C++-Problem des manuellen Speichermanagements. Java ist klein, was unter anderem ein angenehmer Nebeneffekt der Einfachheit ist. Eines der ursprünglichen Ziele von Java war, die Entwicklung von Software zu erleichtern, die »stand alone« auf kleinen Rechnern (ab mindestens 4 MByte RAM) oder sogar in Kaffeemaschinen oder Videorecordern läuft. Die Grö ß e des Basisinterpreters und die Klassenunterstützung betragen in etwa 40 KByte RAM. Zusätzliche Standardbibliotheken und Thread-Unterstützung benötigen weitere 175 KByte. Diese 215 KByte sind wesentlich kleiner als jede andere vergleichbare Programmiersprache oder -umgebung. Java ist objektorientiert. Es zählt zu einer Familie von Sprachen, die Daten als Objekte definieren und Methoden verwenden, um diese Objekte zu bearbeiten. Einfach gesagt, beschreiben objektorientierte Sprachen (OO ist die Abkürzung für Object Orientation) Interaktionen zwischen Datenobjekten. Allerdings hat Java gegenüber einigen anderen objektorientieren Sprachen eine entscheidende Einschränkung – es gibt keine Mehrfachvererbung. Dafür werden jedoch abstrakte Klassen und ein Schnittstellenkonzept unterstützt. Damit ist es möglich, bedeutend transparenter die Möglichkeiten der Mehrfachvererbung zu kompensieren. Damit werden einige der zentralen Probleme umgangen, die die tatsächliche Mehrfachvererbung aufwirft, wohingegen die meisten der Vorteile bewahrt werden. Mehr dazu später. Java ist dezentral, denn Java erfüllt ein wesentliches Charakteristikum von Client/Server-Anwendungen: die Fähigkeit, Informationen und die Last für die Berechnung der Daten zu verteilen. Der Begriff »dezentral« beschreibt dabei die Beziehung zwischen Systemobjekten, gleichgültig, ob sich diese Objekte nun auf lokalen oder auf entfernten Systemen befinden. Einer der großen Vorteile von Java-Applets und -Anwendungen ist, dass sie Objekte über URLs im gesamten Web genauso wie auf dem lokalen Rechner öffnen und auf diese zugreifen können. Dabei können bereits wichtige Teile der Anwendung bzw. der Daten lokal vorhanden sein, andere werden hingegen erst bei Bedarf geladen. Der schon beschriebene Mangel bei anderen Internetsystemen bzw. -sprachen wie HTML (der Client ist im Prinzip zur Arbeit bereitet, hat aber nichts zu tun und Server und Netzleitungen schaffen sich fast tot) wird umgangen. Dabei steht dem Java-Programmierer eine implementierte, umfangreiche Programm-Routinen-Bibliothek für die Zusammenarbeit mit TCP/IP-Diensten wie HTTP und FTP zur Verfügung. Das neue RMI-Konzept ist ein weiterer Schritt in diese Richtung.
Java 2 Kompendium
81
Kapitel 2
Schnuppertour Java Java ist interpretiert, denn ein gewisser Teil des Java-Codes (zwar nur ca. 20 % – das sind jedoch die kritischen 20 %) werden vom Container, z.B. dem Browser, interpretiert. Manchmal sagt man deshalb sogar, dass Java interpretiert und kompiliert zur gleichen Zeit ist, was auf den ersten Blick ja ein Widerspruch zu sein scheint. Sowohl die wesentlichen Aspekte der Java-Sicherheit, als auch die Fähigkeit, auf verschiedenen Systemen zu laufen, rühren von der Tatsache her, dass die letzten Schritte der Kompilierung lokal abgearbeitet werden. Vorher wurde der Java-Quellcode mit dem Java-Compiler in Bytecode kompiliert. Bei dem Bytecode handelt es sich um ein architekturneutrales Object-Codeformat. Ferner ist er binär und so lange nicht vollständig und lauffähig, bis er von der Java-Laufzeitumgebung interpretiert wird. Da jede Java-Laufzeitumgebung plattformspezifisch ist, arbeitet das endgültige ausgeführte Programm auf dieser spezifischen Plattform. Diese Kombination von Kompilierung und Interpretation ist vorteilhaft, da zunächst einmal Sicherheit und Stabilität erhöht werden. Die Java-Umgebung enthält ein Element namens »Linker«, das die in ihr System eingehenden Daten überprüft, um sicherzustellen, dass sie weder schädigende Daten enthalten (Sicherheit) noch Daten, die den Systembetrieb ihres Computers unterbrechen könnten (Stabilität). Außerdem wird die Pflege von Versionsnummern erleichtert. Die Tatsache, dass der letzte Teil der Übersetzung des Bytecodes von einem plattformspezifischen Programm auf der Plattform des Endanwenders ausgeführt wird, nimmt dem Entwickler die Verantwortung, verschiedene Quellen für verschiedene Plattformen halten zu müssen. Die Interpretation erlaubt zudem, Daten zur Laufzeit zu laden, was die Grundlage für das dynamische Verhalten von Java ist. Java ist stabil in der Bedeutung von »zuverlässig«. Je stabiler eine Sprache ist, desto unwahrscheinlicher ist es, dass in dieser Sprache geschriebene Programme abstürzen. Ein wesentliches Kriterium für die Stabilität einer Programmiersprache ist, dass bereits während der Kompilierungsphase der grö ß te Teil der Datentyp-Überprüfung ausgeführt wird, nicht erst zur Laufzeit wie bei nicht so stabilen Sprachen. Man nennt dies »stark typisiert«. Eine stark typisierte Sprache wie Java ermöglicht also bereits ein intensives Überprüfen des Codes während der Kompilierungsphase. Damit können Fehler relativ früh gefunden werden. Ein weiteres Stabilitätskriterium von Java-Programmen ist, dass sie – im Gegensatz zu Programmen, die in vielen anderen Sprachen geschrieben sind – keinen Zugriff auf den vollständigen Speicherbereich eines Computers, insbesondere den Systemspeicher, haben. Java besitzt eine eingebaute Begrenzung der Zugriffsmöglichkeiten. Damit verringert sich die Absturzwahrscheinlichkeit eines Java-Programms erheblich. Schlimmstes Negativbeispiel für eine Programmiersprache, die den umgekehrten Weg verfolgt und Programmieren weitgehend ungeprüfte
82
Java 2 Kompendium
Die Geschichte von Java
Kapitel 2
Zugriffe auf sämtliche Speicherbereiche des Rechners ermöglicht, ist C/ C++. Die Stichworte Zeigerarithmetik und implizite Deklarationen sind mit höchster Gefahr gleichzusetzen. Bei C/C++ liegt eindeutig der Schwerpunkt auf maximaler Geschwindigkeit, plattformnaher Programmierung und Flexibilität, bei Java auf Stabilität und Sicherheit. Ein weiterer Stabilitätsaspekt von Java ist die abschließende Sicherheitsüberprüfung durch einen Linker. Der Linker ist Teil der Laufzeitumgebung. Er versteht das Typensystem und wiederholt während der Laufzeit viele der Typenüberprüfungen, die der Compiler durchführt. Java gilt als sehr sicher. So ist die Unterbindung von beliebigen Speicherzugriffe durch Java nicht nur ein Stabilitätskriterium, sondern trägt gleichfalls zur Sicherheit bei. Da Java-Programme zuerst in BytecodeAnweisungen und Proto-Programme übersetzt werden, lassen diese sich dann recht gut überprüfen. Bytecode-Anweisungen sind nicht plattformspezifisch und enthalten zusätzliche Typinformationen. Diese Typinformation kann für die Überprüfung des legalen Status und von möglichen Sicherheitsverletzungen verwendet werden. Mehr zur Sicherheit folgt noch an anderer Stelle. Java ist architekturneutral, d.h., es ist auf verschiedenen Systemen mit unterschiedlichen Prozessoren und Betriebssystemarchitekturen lauffähig. Der kompilierte Java-Bytecode kann auf jedem Prozessor ausgeführt werden, der einen Java-fähigen Browser bzw. die virtuelle Maschine von Java im Allgemeinen unterstützt. Der Java-Compiler erzeugt niemals plattformabhängigen Binärcode, sondern neutralen Java-Bytecode. Dieser wird erst während der Laufzeit in systemeigenen Maschinencode übersetzt. Und dennoch ist Java eine vollständige Programmiersprache. Java ist portierbar, was eine wesentliche Folge der Architekturunabhängigkeit ist. Darüber hinaus fallen implementationsabhängige Aspekte, wie man sie in C und C++ findet, bei Java durch die Standards für Datentypen weg. In Java wird die Grö ß e einfacher Datentypen genau spezifiziert, und auch, wie sich die Arithmetik gegenüber diesen Datentypen verhält. Fast alle wichtigen Prozessoren unterstützen diese Java-Spezifikation und außerdem beinhalten die Java-Bibliotheken portierbare Schnittstellen für die wichtigsten Plattformen. Java ist sehr leistungsfähig, denn in Tests von Sun auf einer Sparc Station 10 hat sich gezeigt, dass die Performance von Java-Bytecode, der in Maschinencode umgewandelt wurde, von native C oder C++ bei vielen Funktionen nicht zu unterscheiden ist. Allerdings ist dabei die Zeit für die Laufzeit-Kompilierung nicht mit einbezogen. Der Start der virtuellen Maschine beim Aufruf einer Java-Applikation ist zudem zeitaufwändig. Bei allem Java-Lob muss man in dem Punkt Performance realistisch bleiben. Nicht umsonst zählt die absolut mangelhafte Performance früher Java-Versionen zu den Hauptkritikpunkten. Die Java-2-Plattform
Java 2 Kompendium
83
Kapitel 2
Schnuppertour Java beinhaltet diverse Neuerungen zur Steigerung der Performance (wir sind im ersten Kapitel darauf eingegangen). Die Geschwindigkeit von interpretiertem Java-Bytecode ist dennoch auf leistungsschwachen Plattformen recht niedrig, aber für die meisten Aufgaben ausreichend. Und für den Fall, dass eine höhere Performance notwendig ist, kann native Code integriert werden (wovon jedoch aus Sicherheitsgründen dringend abzuraten ist). Ein Ansatz zur Steigerung der Performance ist die Entwicklung von Just-in-Time-Compilern (JIT) durch diverse Hersteller von Java-Entwicklungsumgebungen. Insbesondere gehört in der Java-2Plattform ein JIT-Compiler zum Lieferumfang. Nach Angaben einiger Hersteller von Entwicklungstools kann die Leistungsfähigkeit von JavaApplikationen und Applets um das Fünf- bis Zehnfache erhöht werden – unabhängig davon, mit welchem Tool sie erstellt wurden. Ein JIT (Just-in-Time-Compiler) hat grob gesagt die Funktion, ein Java-Applet oder – Programm vor seiner Ausführung bereits zu übersetzen, um damit eine bessere Performance zu erreichen. Genauer genommen übersetzt der JIT nur häufig benötigte Funktionalitäten, d.h., beim ersten Aufruf einer Methode wird deren Bytecode in Maschinenbefehle übersetzt und im RAM gehalten. Beim erneuten Aufruf dieser Methode wird dann der bereits kompilierte Code verwendet. Zudem steigt durch die »Just-in-Time«-Funktionalität die Geschwindigkeit bei der parallelen Abwicklung mehrerer rechenintensiver Softwareapplikationen. Ein JITCompiler ist aber kein Allheilmittel, denn in der Praxis zeigt sich unter ungünstigen Umständen, dass durch Laden des JIT sogar eine Verringerung der Ausführungsgeschwindigkeit die Folge sein kann. In der Regel ist jedoch eine Steigerung der Performance wirklich oft zu beobachten. Die im JDK 1.3 eingeführte Hotspot-Technologie ist ein neuer Ansatz, die Leistungsfähigkeit von Java erheblich zu steigern. Java unterstützt Multithreading. Multithreading bedeutet zunächst nur, dass mehrere Aufgaben oder Prozesse quasi gleichzeitig ausgeführt werden können. Einfachstes (und bestes) Beispiel für ein Multithreadingsystem ist ein Mensch, der viele Dinge gleichzeitig erledigt. Bei Computersystemen werden solch natürliche Dinge wie Multithreading zu einem großen Problem. Viele ältere Betriebssysteme wie DOS waren nie in der Lage, Multithreading auch nur ansatzweise auszuführen. Nicht einmal Multitasking (das parallele Abarbeiten von mehreren Programmen) war bei diesen Betriebssystemen möglich. Auch das Multitasking von Windows 3.x war nie echtes Multitasking, geschweige denn Multithreading. Neben den Betriebssystemen unterstützten zudem die Konzepte bisheriger Programmiersprachen den Multithreading-Vorgang gar nicht oder nur sehr eingeschränkt. C/C++ ist ebenfalls auf Single-Threaded-Programme ausgerichtet. Bei Java ist die Beschränkung auf Single-Threading aufgehoben. Allerdings gilt vor übereilter Euphonie über Multithreading, dass die Vorteile von Multithreading (bessere interaktive Antwortfähigkeit, besseres Laufzeitver-
84
Java 2 Kompendium
Die Geschichte von Java
Kapitel 2
halten) stark von der zugrunde liegenden Plattform abhängen. Selbst wenn eine Plattform Multithreading unterstützt, Java-MultithreadingAnwendungen sind hauptsächlich für eine Multiprozessor-Umgebung geeignet und haben eigentlich nur dort ein optimales Laufzeitverhalten. Multithreading-Verhalten wird zwar funktionieren, wenn Sie eine JavaMultiprozessor-Anwendung unter Windows 98 auf einem PC laufen lassen, jedoch kaum gute Ergebnisse bieten. Im Prinzip bedeutet Multithreading ja nichts anderes, als dass mehrere Aufgaben gleichzeitig ausgeführt werden können. Bei mehreren Prozessoren kann jeder Prozessor einen Thread abarbeiten, was echte Gleichzeitigkeit darstellt. Was bei einem Prozessor Gleichzeitigkeit bedeutet, kann auf philosophischer Ebene bis zum Exzess diskutiert werden, jedoch ist dies durch die kurzen Intervalle der Zeitzuweisungen an einzelne Threads im Grunde mü ß ig. Die Einschränkungen auf Grund der Zyklen von Kapazitätszuweisungen sind aber offensichtlich. Der Vorgang des Multithreading sollte freilich noch einmal etwas genauer beleuchtet werden. Eigentlich ist die oft verwendete Übersetzung von Threads mit Aufgaben ungenau und verschleiert den Unterschied zu Multitasking, was ja streng genommen bedeutet, dass mehrere Aufgaben (Tasks) gleichzeitig ausgeführt werden können. Ein Thread ist im Grunde statt mit »Aufgabe« besser (wie es im Wörterbuch steht) mit »Faden«, »Faser« oder am besten »Zusammenhang« zu übersetzen. Nicht die gleichzeitige Ausführung von mehreren Programmen wie beim Multitasking, sondern die gleichzeitige, parallele Ausführung von mehreren einzelnen Programmschritten (oder zusammenhängenden Prozessen) ist echtes Multithreading. Dies kann auch bedeuten, dass innerhalb eines Programmes mehrere Dinge gleichzeitig geschehen, mehrere Fäden/Fasern eines Programms gleichzeitig verfolgt und abgearbeitet werden. Beispielsweise kann ein Thread eines Programms eine lange und hochkomplizierte Berechnung ausführen, während sich ein anderer Thread um die Bildschirmausgabe kümmert und ein dritter Thread die Usereingabe bearbeitet. Und dies im Sinne von »computergleichzeitig«. Bei Java ist das Multithreadingkonzept voll integrierter Bestandteil der Philosophie. Der hochentwickelte Befehlssatz in Java, um Threads zu synchronisieren, ist in die Sprache integriert, macht diese stabil und einfach in der Anwendung. Das Multithreadingkonzept an sich ist freilich schon viel älter als Java und auch das Java-Multithreadingkonzept basiert auf dem Cedar/Mesa-System von Xerox. Die einfachen Thread-Anweisungen von Java beruhen auf dem 20 Jahre alten Paradigma von Steuerund Bedingungsvariablen von C. Anthony Hoare. Allerdings hat Sun mit Java in dem äußerst wichtigen und komplizierten Bereich der Synchronisation von Threads viel Neues entwickelt und viele der Synchronisationsschwierigkeiten bisheriger Multithreading-Umgebungen aus dem Weg geräumt.
Java 2 Kompendium
85
Kapitel 2
Schnuppertour Java Java ist dynamisch, d.h., es kann sich an eine sich ständig weiterentwickelnde Umgebung anpassen. Sun zieht zur Verdeutlichung dieser Eigenschaft von Java das Beispiel C++ heran und definiert den Vorteil von Java gegenüber Entwicklungen mit C++ so, dass Entwickler bei C++ von jemand anderem abhängig werden. Grund dafür sind die Klassenbibliotheken, eine Sammlung von Plug-and-Play-Komponenten, in denen der C++-Code implementiert wird. Diese werden von fremden Unternehmen ständig verändert oder »upgegradet«. Da C++-Programme die Klassenbibliotheken verwenden, muss deshalb oft der C++Code angepasst werden, nur um die Programme lauffähig zu halten. Dummerweise werden die meisten User bei einem Programmfehler nach einem (vielleicht noch unbemerkten, weil bei einer Installation einer anderen Software erfolgten) Upgrade von Klassenbibliotheken den Fehler dem Programm zuschieben und nicht den neuen Klassenbibliotheken. Java verbindet im Gegensatz zu C++ die einzelnen Module in einer späteren Phase und vermeidet dadurch das Bibliotheken-Problem. Ein weiterer dynamischer Aspekt von Java ist der Mechanismus der Schnittstellen (Interfaces). Mehr dazu im Abschnitt über Schnittstellen. Nur soweit vorab die Information, dass Schnittstellen im Prinzip Klassen sehr ähnlich sind, jedoch im Gegensatz dazu Mehrfachvererbung unterstützen und auch sonst flexibler in bezug auf Vererbung sind, als dies bei Klassen der Fall ist. Eine wesentliche Eigenschaft von dynamischen Sprachen wie Java oder deren dynamischen Vorgängern Small Talk oder auch Lisp ist, dass sie sich auf Grund ihrer Flexibilität hervorragend zur Erstellung von Prototypen eigenen. Ein Hauptgrund dafür ist, dass sie in jeder Phase von Programmierern explizite Entscheidungen fordern, damit durch eine schlechte oder nicht erfolgte Entscheidung (etwa wie bei C/C++ ein Zeiger auf einen unbekannten Objekttyp) ein System nicht zum Absturz gebracht werden kann. Wenn Sie beispielsweise in Java einen Methodenaufruf schreiben und dabei Fehler machen, wird dieser beim Kompilieren bemerkt und Sie bekommen eine Warnmeldung, wenn Sie den Code kompilieren wollen.
2.3
Zusammenfassung
Zusammenfassend kann man sagen, dass Java eine der wohl spannendsten Entwicklungen der letzten Jahre in der EDV war und immer noch ist. Nahezu konkurrenzlos für die Bereiche, wo es auf Plattformneutralität und Stabilität ankommt, hat sich Java zu einer festen Grö ß e entwickelt. Java bietet weit mehr als nur die Möglichkeit, im Internet kleine, bunte »Progrämmchen« zu erstellen. Es ist eine der leistungsfähigsten Entwicklungsumgebungen, die man sich vorstellen kann.
86
Java 2 Kompendium
3
Das JDK
Wir wollen in diesem Kapitel zu den Entwicklungstools für Java kommen. Das Java Development Kit (JDK) ist die Sun-Entwicklungsumgebung zum Erstellen von Java-Applikationen, -Applets und -Komponenten. Es ist Kern sämtlicher Java-Entwicklungswerkzeuge (gleichfalls von Fremdherstellern). Das Kapitel ist relativ knapp gehalten und spricht nur die wichtigsten Tools an. Im Anhang gehen wir intensiver auf das JDK und ergänzende Entwicklungstools ein. Das JDK wird in der aktuellen Version 1.3 (die – um es nochmals zu betonen – das aktuelle Entwicklungspaket der Java-2-Plattform ist) von Sun für Windows 95/98/ME/NT (ab der Version 4.0)/2000 sowie deren Nachfolger und das Solaris-Betriebssystem bzw. das in der letzten Zeit immer populärer werdenden Linux frei zur Verfügung gestellt. Genauere Informationen finden Sie unter http://java.sun.com/products/jdk/faq.html. Beachten Sie, dass das JDK 1.3 an diversen Stellen als SDK 2 – Software Development Kit – bezeichnet wird, womit streng genommen aber eine Obermenge des JDK gemeint ist. Für die Windows-Versionen 3.x und früher gibt es keine JDK-Variante, was jedoch schon deswegen klar ist, da dort lange Dateinamen nicht unterstützt werden. Schwierigkeiten beim Erzeugen einer Multithreading-Umgebung in einer Betriebssystemumgebung, die nicht einmal preemptives Multitasking unterstützt, und fehlende direkte TCP/IP-Unterstützung bei Windows 3.x sind weitere Gründe. Allerdings können Windows 3.1x-Anwender seit einiger Zeit zumindest Java-Applets laufen lassen, denn es gibt sowohl von Netscape als auch von Microsoft mittlerweile Java-taugliche Browser für Windows 3.1x. Das JDK ist bezüglich der minimalen Plattformvoraussetzungen genügsam. Nicht nur Java selbst ist klein, auch das JDK ist relativ klein und kompakt. Die Java-Gesamtkonzeption legt auf solche Eigenschaften ja sehr großen Wert. Das Win32-Release läuft sogar schon auf einem einfachen PC mit einem Pentium-Prozessor der ersten Generation mit nur 32 Megabyte recht gut. Wenn es sein muss, sogar bei noch sparsamerer Ausstattung. Das jewei-
Java 2 Kompendium
87
Kapitel 3
Das JDK lige Betriebssystem oder eine auf dem JDK aufbauende Entwicklungsumgebung wird statt dessen die notwendigen Minimalanforderungen für die Hardware festlegen. Das JDK besteht fast ausschließlich aus Befehlszeilen-orientierten Tools und erreicht damit natürlich nicht den Komfortstandard integrierter Entwicklungsumgebungen (IDE), die eine grafische Benutzerumgebung (GUI – Graphical User Interface) haben. Aber Befehlszeilen-Orientierung ist nicht immer schlecht. Man sollte nur daran erinnern, wie viele PC-Profis sogar heute noch lieber mit DOS-Befehlen, als mit den langsamen Stützrädern der Windows-Programme arbeiten. Die JDK-Werkzeuge (den Compiler eingeschlossen) können über eine einfache Befehlszeileneingabe auf Prompt-Ebene aufgerufen werden. Der JavaSource selbst (eine Datei mit Erweiterung .java) kann mit jedem einfachen Texteditor erstellt und bearbeitet werden. Im Anhang werden wir dennoch als Alternativen zu diesem rustikalen – und aus didaktischen Gründen sehr sinnvollen – Arbeiten einige frei verfügbare IDEs vorstellen. Um nun das JDK auf einem lokalen Rechner zu installieren und anzupassen, sollte man in mehreren chronologischen Schritten vorgehen. Am Anfang steht natürlich der Bezug eines möglichst aktuellen JDKs.
3.1
Bezug des JDK
Natürlichste Quelle für ein Java-Entwicklungstool ist wohl das Internet. Immerhin hat dieses erst den Erfolg von Java ermöglicht und wer mit Java programmieren will, hat auch meistens einen funktionierenden Internetzugang. Es gibt nun zahlreiche Quellen, von wo Sie das jeweils aktuelle JDK (aber auch ältere Versionen) beziehen können. Am einfachsten ist der Weg über eine der vielen Seiten des Sun-Imperiums. Der sinnvollste Einstieg erfolgt über den Java-Bereich von Sun (http://java.sun.com). Dort finden Sie alles rund um Java und natürlich auch die neue Java-2-Plattform samt dem zugehörigen JDK 1.3. Wenn Sie diese Java-Seiten aufrufen, folgen Sie einfach den entsprechenden Links für die gewünschte Java/JDK/SDK-Version und Ihrem Betriebssystem. In der Regel müssen einige übliche Copyright- und die Readme-Dateien auf dem Weg dorthin gelesen und bestätigt werden. Sie können die konkreten Seiten für das JDK natürlich auch direkt anwählen. Das erfolgt meist über eine URL wie die folgende: http://java.sun.com/j2se/
88
Java 2 Kompendium
Bezug des JDK
Kapitel 3 Abbildung 3.1: Alles rund um Java direkt von Sun
Abbildung 3.2: Hier gibt es das JDK.
Java 2 Kompendium
89
Kapitel 3
Das JDK Sie können das JDK auch von Seiten laden, die nicht zum offiziellen SunInternetbereich zählen. Etwa von gespiegelten FTP-Servern diverser Organisationen. Gerade die gespiegelten FTP-Server halten aber nicht immer, was diverse Quellen – sogar die offiziellen Sun-Unterlagen – versprechen. Prinzipiell sollte man ob der permanenten Umstrukturierungen auf den Servern bei Fehlermeldungen auf dem Root-Verzeichnis der jeweiligen Organisation einsteigen und dann sein Glück versuchen. An dieser Stelle stehen Ihnen dann u.a. eine Liste der unterstützten Plattformen und die dafür vorhandenen Versionen des JDK zur Verfügung. Sie werden mit detaillierten Anweisungen und Hyperlinks zum Download für Ihre Version und Plattform geführt. Auf der CD finden Sie ein 1.3-JDK. Allerdings kann es sein, dass es seit der Bucherstellung neuere Versionen gibt. Über die angegebenen URLs laden Sie in der Regel ein selbstextrahierendes Archiv auf den lokalen Rechner, sofern es sich um eine ältere Version des JDK handelt. Ab der Version 1.2 (bzw. sogar schon in 1.1.x-Zwischenversionen) steht – zumindest in der Windows-Version – ein Standard-Setup zur Verfügung. Auf den Sun-Downloadseiten stehen verschiedene Möglichkeiten zum Download des doch ziemlich großen JDK-Paketes zur Verfügung. Es gibt sowohl einen FTP-Download als auch einen HTTP-Download. Wenn es Ihnen möglich ist, sollten Sie einen FTP-Download durchführen. Der ist in der Regel schneller als ein HTTP-Download. Zusätzlich müssen Sie das gesamte Paket nicht als eine Datei laden. Es gibt das JDK auch in kleinen Häppchen. Die genauen Grö ß enangaben für das JDK können je nach Release variieren, aber grob sollte die Installationsdatei des JDK 1.3 ca. 29,4 MByte groß sein und mit allem Drum und Dran nach der Installation auf der Festplatte ca. 50 MByte belegen. Da die genauen Grö ß enangaben sich permanent verändern, macht eine genauere Angabe keinen Sinn. In der Regel wird sowieso immer die neueste Variante des JDK geladen und deren Grö ß enangaben können immer wieder variieren. Bei der Kapazität heutiger Datenspeichermedien spielt dies kaum noch eine Rolle, und das JDK ist auf jeden Fall kleiner als übliche Entwicklungsumgebungen.
90
Java 2 Kompendium
Installation des JDK
Kapitel 3 Abbildung 3.3: Eine Installationsdatei des JDK
3.2
Installation des JDK
Die Installation des JDK ist in neueren Versionen kein Problem mehr. Die ersten Versionen waren da nicht so einfach zu handhaben. Es ist jedoch zu empfehlen, ein neues JDK nicht über ein altes Release zu installieren. Wenn Sie eine ältere Version ersetzen wollen, werden als Installationsorte sowieso defaultmäß ig verschiedene Verzeichnisstrukturen vorgeschlagen. Wollen Sie jedoch die bereits vorhandene Verzeichnisstruktur bzw. die bisherigen Namen der Verzeichnisse verwenden (etwa, um diverse Pfade und Einstellungen nicht mehr ändern zu müssen), sollten Sie vor der Installation einer neuen JDK-Version eine gegebenenfalls vorhandene Altversion vollständig beseitigen, damit die beiden Varianten sich nicht in die Quere kommen. Falls Sie vor einer Installation die alte Version beseitigen, sollten Sie natürlich gegebenenfalls vorhandenen eigenen Java-Source und sonstige selbst erstellten Dokumente in dem Verzeichnis in Sicherheit bringen, bevor Sie das alte Verzeichnis liquidieren. Die genauen Schritte bei der Installation sind für die unterschiedlichen Betriebssysteme leicht verschieden, entsprechen aber den üblichen Schrittfolgen bei Installationen unter den jeweiligen Plattformen. Die genauen Installationshinweise für jedes Release werden auf Java-Webseiten unter der zu jedem Release gehörenden Verzeichnisstruktur zur Verfügung gestellt. Wir werden als Beispiel die Installation unter dem Betriebssystem Windows durchsprechen. Ab der Version 1.1.x verwendet das JDK den Standardvorgang zum Installieren unter Windows, den InstallShield. Positiv zu erwähnen ist dabei, dass selbst ein Aufruf des Installationsprogrammes auf Befehlzeilenebene keine sonst übliche Fehlermeldung der Art »This program requires Windows« erzeugt, sondern direkt zum InstallShield übergeht. Der InstallShield bietet alle bekannten Einstellmöglichkeiten in Bezug auf das Installations-Verzeichnis und zu installierende Komponenten. Außerdem wird das Ziellaufwerk überprüft.
Java 2 Kompendium
91
Kapitel 3
Das JDK
Abbildung 3.4: Der Beginn des Installationsvorgangs ist WindowsAnwendern bekannt
Abbildung 3.5: Standardeinstellungsmöglichkeiten
Ziemlich störend ab der Version 1.2 sind die zahlreichen Stellen, wo Sie Lizenzbedingungen akzeptieren müssen. Wenn man die zusätzlichen Bestätigungen der Lizenzbedingungen vor dem Download dazu zählt könnte man auf die Idee kommen, Sun würde einen Augapfel opfern. Das Defaultverzeichnis setzt sich aus der Laufwerksangabe JDK und der Versionsnummer, durch Punkte getrennt, zusammen, zum Beispiel C:\JDK1.1.1 oder C:\JDK1.3. Dies erleichtert eine parallele Führung von mehreren Versionen erheblich.
92
Java 2 Kompendium
Installation des JDK
Kapitel 3
Der Setup-Wizard installiert neben dem JDK noch zusätzlich eine JavaLaufzeitumgebung in ein separates Verzeichnis. Dies ist etwas ärgerlich, weil Sie diese zweite Laufzeitumgebung nicht benötigen – das JDK enthält sowieso eine solche.
3.2.1
classes.zip, src.zip, src.jar, rt.jar & Co.
Zwischen dem JDK 1.1 und der Finalversion 1.2 (bzw. natürlich auch dem Wechsel von JDK 1.2 auf JDK 1.3, aber diese sind nicht ganz so massiv) haben sich zahlreiche Veränderungen ergeben, die die interne Arbeitsweise der JDK-Tools und die Voraussetzungen für deren Aufruf betreffen. Hier soll ein wichtiges Detail hervorgehoben werden – die Dateien Classes.zip und Src.zip sowie die Laufzeitumgebung von Java. Bis zu der JDK-Version 1.1.7 (und sogar den meisten Betaversionen des JDK 1.2) erzeugte das Extrahieren des JDK-Archives beim Installieren normalerweise (u.a.) zwei interessante Dateien bzw. Verzeichnisse: Src.zip im Java-Verzeichnis selbst bzw. das Verzeichnis src und Classes.zip in dessen Unterverzeichnis lib.
Beide ZIP-Dateien sollten normalerweise nicht (!) extrahiert werden. Classes.zip war wesentlicher Teil des RUNTIME-Moduls (die Systemklassen) von Java in den damaligen Versionen. Die Datei enthält den vollständigen, kompilierten Code von Java und muss in diesen Versionen des JDK einigen JDK-Tools (insbesondere dem Compiler und dem Interpreter) zur Laufzeit zur Verfügung stehen. Ein Entpacken der Datei ist so gut wie nie notwendig, denn Java kann ZIP-Dateien in komprimierter Form verwenden. Falls Sie die Datei dennoch entpacken, erreichen Sie nur eine geringfügige Steigerung der Performance und verlieren viel Platz auf der Festplatte. Die Datei Src.zip beinhaltete in den älteren Versionen den eigentlichen Quellcode von Java. Normalerweise werden Sie diesen Quelltext nicht benötigen. Mit einer Ausnahme – diese Source-Files enthalten zum einen wichtige Informationen über Java, zum anderen können sie das Lernen von Java unterstützen, indem man den Source analysiert. Die Klassen sind in der API-Reference-Dokumentation beschrieben, die mit dem Tool javadoc erstellt wurde. Aber um es nochmals zu betonen – ab der Finalversion des JDK 1.2 werden Sie die Dateien Src.zip und Classes.zip nicht mehr finden. Die Datei Src.zip bzw. das Verzeichnis SRC ist durch die Datei Src.jar ersetzt worden. Diese ist in ihrer Funktionalität identisch. Sie können deren Installation im Setup-Programm mit angeben. Ein .jar-File ist ein Kompri-
Java 2 Kompendium
93
Kapitel 3
Das JDK mierungsformat, mit dem Java direkt arbeiten kann. Es muss genauso wenig extrahiert werden, wie die bisherige ZIP-Dateien. Die Laufzeitumgebung des JDK-1.2-Finalrelease hat sich ebenso vollständig gegenüber den Vorgängern geändert. Die Datei Classes.zip ist im Wesentlichen durch die Datei rt.jar (rt steht für RunTime) ersetzt worden. Darauf kommen wir aber gleich wieder zu sprechen.
3.2.2
Verzeichnisstruktur innerhalb des JDK-Verzeichnisses
Innerhalb des Installationsverzeichnisses des JDK wird von dem Setup-Programm eine Unterstruktur angelegt. Diese hat sich über die verschiedenen JDK-Versionen öfters verändert. Außerdem ist die genaue Verzeichnisstruktur davon abhängig, welche Optionen Sie bei der Installation angegeben haben. Sie werden bei einer vollständigen Installation des JDK 1.3 normalerweise die folgende Struktur finden: Tabelle 3.1: Die Verzeichnisstruktur des JDK
Verzeichnis
Inhalt
\bin
In diesem Verzeichnis befinden sich (wie bei vielen Entwicklungsumgebungen anderer Sprachen) die JDK-Programme, also z.B. der Compiler, der Interpreter, ein Appletviewer, der Debugger, der Disassembler oder das Dokumentationstool. Dieses Verzeichnis ist immer vorhanden – es ist das JDK.
\lib
In diesem Verzeichnis befinden sich defaultmäßig StandardJava-Klassen des JDK. Im Wesentlichen ist das in den alten Versionen des JDK die Datei Classes.zip, ab dem JDK 1.2 (Final) sind es die Dateien Tools.jar, Jvm.lib und Dt.jar. Dazu kommem im JDK 1.3 die Dateien ir.idl, jawt.lib und orb.idl. Tools.jar beinhaltet die Non-Core-Klassen zur Unterstützung der Tools und Utilities im JDK. Dt.jar (DesignTime-Archive) ist dafür da, über BeanInfo-
Dateien interaktiven Entwicklungsumgebungen (IDE's) Informationen zur Verfügung zu stellen, wie sie die Java-Komponenten darstellen sollen und wie sie Entwickler dort für ihre Applikationen anpassen können. Die Datei Jvm.lib ist eine Bibliothek für die virtuelle Maschine von Java. Auf diese Thematik werden wir gleich noch etwas näher eingehen. Die beiden Dateien ir.idl und orb.idl dienen der Zusammenarbeit von Java mit der IDL-Sprache, jawt.lib mit dem AWT Native Interface.
94
Java 2 Kompendium
Installation des JDK
Verzeichnis
Kapitel 3
Inhalt Beachten Sie, dass zwar in den JDK-Versionen vor 1.2 in diesem Verzeichnis die Datei classes.zip zu finden war, aber in neuerern JDK-Versionen nicht deren wesentlicher Ersatz rt.jar. Diese befindet sich an anderer Stelle innerhalb der Verzeichnisstruktur (im Unterverzeichnis \jre).
\include
Der C/C++-Programmierern sicher bekannte Ausdruck »include« steht für ein optionales Verzeichnis, das diverse Header-Dateien für die gemeinsame Verwendung von Java und C/C++ enthält. Außerdem gibt es dort ein Unterverzeichnis \win32, das weitere Header-Dateien beinhaltet. Die CHeaderfiles in diesem Verzeichnis sind ausschließlich für die Unterstützung von Nativecode-Programmierung über das Java Native Interface und das Java Virtual Machine Debugger Interface gedacht.
\include-old
Ab dem JDK 1.2 (Final) gibt es optional dieses Verzeichnis, in dem aus Gründen der Abwärtskompatibilität Header-Dateien zur Unterstützung von Nativecode-Programmierung über ältere Schnittstellen zur Verfügung stehen. Diese Dateien gelten als deprecated (veraltet), werden nicht weiter unterstützt und stehen nicht auf allen Plattformen zur Verfügung.
\demo
Das optionale Demoverzeichnis beinhaltet Beispielprogramme. Es hat einige Unterverzeichnisse (u.a. applets und jfc).
\src
In der JDK-Version 1.1.x und den meisten Betaversionen des JDK 1.2 können Sie das Verzeichnis SRC mit installieren. Darin befinden sich dann die entkomprimierten Java-Dateien, die in diesen JDK-Versionen sonst nur im gepackten Zustand in der Datei Src.zip vorhanden sind. Das Verzeichnis ist durch die Datei Src.jar ab dem JDK 1.2 ersetzt worden, die seitdem im Hauptverzeichnis befindet.
\jre
Das Verzeichnis beinhaltet die Laufzeitumgebung von Java. Es beinhaltet die zwei Unterverzeichnisse bin und lib. Im Wesentlichen finden Sie die Datei rt.jar in lib und in bin diejenigen Programme, die zum Ausführen von Java-Applikationen notwendig sind (ohne Entwicklungstools).
Tabelle 3.1: Die Verzeichnisstruktur des JDK (Forts.)
Nach erfolgreicher Installation können Sie normalerweise das Setup-File des SDK von der Festplatte wieder löschen. Es wird nicht mehr benötigt und belegt nur Platz. Überdies ist es im Gegensatz zu gekaufter Software jederzeit erneut zu beziehen. Jedoch sollten Sie sich darüber im Klaren sein, dass Ihnen dann im Falle einer Neuinstallation erneut ein längerer Download bevorsteht.
Java 2 Kompendium
95
Kapitel 3
Das JDK
3.2.3
Die Java-Laufzeitumgebung jre
Hinter dem Begriff Java Runtime Environment (JRE) verbirgt sich die JavaLaufzeitumgebung, der Minimalstandard, um Java-Programme laufen lassen zu können. Das Java Runtime Environment besteht aus der Java Virtual Machine, Java Core Classes und aufseiten der Tools hauptsächlich aus dem Java-Interpreter, ein paar ergänzenden Programmen sowie einigen dazu gehörenden DLLs. Insbesondere sind keinerlei Entwicklungstools enthalten und kein Tool zum Starten und Ansehen von Applets. Laden können Sie das Java Runtime Environment separat von denselben Quellen, wo auch das JDK zu finden ist. Sie können (und müssen!!) es aber auch in der Setuproutine des JDK mit installieren. Das JRE wird dann wie oben beschrieben im Unterverzeichnis \jre installiert. Sie werden auf Ihrem Rechner diverse Java-Laufzeitumgebungen finden. Das ist einmal diejenige, die vom JDK in dessen Installationsverzeichnis angelegt wird, aber auch an unterschiedlichsten anderen Stellen werden Sie – teils differierende Versionen – finden. Die verschiedensten Programme installieren eine solche Umgebung – in den unterschiedlichsten Versionen.
3.2.4
Das Java-Plug-In
Wir wollen hier den Einsatz des Java-Plug-In (siehe dazu auch Seite 35) durchspielen. Dies wird Ihnen dann die Möglichkeit eröffnen, ihre mit erweiterten Java-Technologien erstellten Java-Applets nicht nur im Appletviewer des JDK zu testen, sondern auch in einem (moderneren) Browser zu testen. Zuerst laden Sie das Tool, das als ZIP-Datei bereitgestellt wird, von den Sun-Seiten. Es gibt dort verschiedene Möglichkeiten, von wo und wie Sie das Tool laden können. Am besten ist natürlich ein direkter FTP-Download. Danach entpacken Sie einfach die ZIP-Datei in leeres Verzeichnis auf Ihrem Rechner. Sie erhalten dort zwei Verzeichnisse. Im Verzeichnis classes befinden sich dann die eigentliche Java-Programmdatei HTMLConverter.class, die Sie mit dem Java-Interpreter direkt starten können (java HTMLConverter) sowie eine Batchdatei mit Namen HTMLConverter.bat, die diesen Vorgang ein wenig vereinfacht. Wenn Sie das Tool gestartet haben, können Sie HTML-Dateien konvertieren und dabei diverse Konfigurationen vornehmen.
96
Java 2 Kompendium
Installation des JDK
Kapitel 3 Abbildung 3.6: Die Downloadseite des HTML-Converters
Abbildung 3.7: Die Downloadseite des HTML-Converters 1.3
Java 2 Kompendium
97
Kapitel 3
Das JDK
Abbildung 3.8: Das Unterverzeichnis classes
Abbildung 3.9: Konvertierung von einer HTML-Seite mit dem <APPLET>-Tag
Spielen wir die Situation mit einem vollständigen Applet durch. Der nachfolgende HTML-Code bindet ein Swing-Applet mittels des <APPLET>-Tags in eine Webseite ein. Listing 3.1: Einbindung von einem SwingApplet mit dem <APPLET>-Tag
98
<TITLE>DemoApplet – Einbindung mit Applet-Tag
Java 2 Kompendium
Installation des JDK <APPLET CODEBASE = "." CODE = "DemoApplet.class" NAME = "TestApplet" WIDTH = 400 HEIGHT = 300 HSPACE = 0 VSPACE = 0 ALIGN
Kapitel 3
= middle>
Im Appletviewer des JDK wird das Applet auch einwandfrei funktionieren. Abbildung 3.10: Klick auf die eine Schaltfläche im Demo-Applet
Abbildung 3.11: Klick auf die andere Schaltfläche im Demo-Applet
Java 2 Kompendium
99
Kapitel 3
Das JDK Schauen wir uns die Webseite nun in halbwegs modernen Browsern an. Der Netscape Navigator 4.7 meldet einen Fehler in der Statuszeile und zeigt nichts an.
Abbildung 3.12: Netscape meldet Probleme im Demo-Applet.
Der Internet Explorer 5 meldet ebenso, dass er eine Klasse nicht finden kann und zeigt auch nichts an. Abbildung 3.13: Der Explorer übt sich in Ignoranz.
100
Java 2 Kompendium
Installation des JDK
Kapitel 3
Wenden wir das Tool nun auf die HTML-Datei an. Das kommt dabei heraus: <TITLE>DemoApplet – Einbindung mit Applet-Tag <EMBED type="application/x-java-applet;version=1.3" CODE = "DemoApplet.class" CODEBASE = "." NAME = "TestApplet" WIDTH = 400 HEIGHT = 300 ALIGN = middle VSPACE = 0 HSPACE = 0 scriptable=false pluginspage="http://java.sun.com/products/plugin/1.3/plugininstall.html"> -->
Listing 3.2: Die konvertierte Webseite
Mit dieser Webseite läuft dann das Applet in den besagten Browsern einwandfrei. Der Appletviewer wird das Applet jedoch zweimal öffnen. Bei der Auswahl der zu konvertierenden Dateien ist zu beachten, dass beim Durchsuchen der Festplatte das Verzeichnis mit den zu konvertierenden Dateien nicht per Mausklick geöffnet werden darf. Das ist etwas ungewöhnlich.
Java 2 Kompendium
101
Kapitel 3
Das JDK Ausführlichere Details und laufend aktuelle Informationen zu den gesamten Prozessen finden Sie auf der Sun-Webseite http://java.sun.com/products/ jdk. Wir werden im Laufe des Buchs noch darauf zurückkommen.
3.3
Die JDK-Dokumentation
Für das JDK und die Java-Plattform wird von Sun eine umfangreiche (wenngleich oft recht verzweigte und daher unübersichtliche) Dokumentation zur Verfügung gestellt. Die Java-Dokumentation beinhaltet eine vollständige Beschreibung aller Pakete, Klassen, Methoden usw. sowie der JDKTools. Das JDK-Installationsfile alleine enthält diese Dokumentation jedoch nicht. Sie müssen sie (und sollten sie auf jeden Fall) separat von den SunServern laden (ca. 21,2 MByte für die Zip-Datei unter Windows). Dazu gibt es auf den Downloadseiten des JDK Hyperlinks, die zu der Downloadseite für die Dokumentationen der einzelnen JDKs führen. Sie finden dort diverse Formate der Dokumentation für die unterschiedlichen Plattformen. Über die Auswahl der jeweiligen Version und der Zielplattform landen Sie auf der konkreten Downloadseite. Abbildung 3.14: Die Online-Dokumentation zu Java und dem JDK
Zum Entpacken benötigen Sie ca. 110 MByte freien Platz auf dem Ziellaufwerk. Kaum zu glauben, wie groß eine Dokumentation werden kann. Aber die Dokumentation ist für eine effektive Arbeit mit Java unumgänglich! Und wenn man sich daran gewöhnt hat, ein vorzügliches Hilfsmittel. Sie sehen – es gibt mittlerweile ziemlich viel zu Java und dem JDK zu sagen und kein Buch zu Java kann das noch leisten, denn Java und die Dokumentation werden in Details permanent aktualisiert. Zudem ist es fraglich, ob die gleichen 102
Java 2 Kompendium
Fehlervorbeugung und Fehlerbehebung beim JDK
Kapitel 3
Informationen wie in der Online-Dokumentation in einem Buch aufbereitet werden sollten. Die Verknüpfung per Hyperlinks macht die Verwendung der Online-Dokumentation zum Nachschlagen von Details ideal. Bücher zu Java bieten nur dann einen Mehrwert, wenn sie mit übergeordneten Konzepten und Beispielen arbeiten und für die vollständigen Details auf die Online-Dokumentation verweisen. Wir wollen es so halten.
3.4
Fehlervorbeugung und Fehlerbehebung beim JDK
Die Installationsroutine des JDK legt wie gesagt eine Verzeichnisstruktur an, die Sie unter günstigen Umständen in die Lage versetzt, direkt die Installation zu testen und loszulegen. Die Tools des JDK lassen sich einfach auf Befehlszeilenebene aufrufen – etwa indem Sie unter Windows eine DOS-Box öffnen und dort die Programme aufrufen. Davor ist es jedoch sinnvoll, eine Anpassung der Java-Umgebung vorzunehmen. Unterlassen Sie dies, werden Sie unter Umständen immer wieder durch überflüssige Fehlersituationen genervt. Dabei kann eine Reihe von einfachen, vorab ausgeführten Schritten diese potenziellen Fehlerquellen erst gar nicht entstehen lassen. Einfach installieren und loslegen ist also bei der Arbeit mit dem JDK und Java nicht immer zu empfehlen. Vorher sollten einige Einstellungen überprüft und ggf. gesetzt sowie andere potenzielle Fehlerquellen vorab analysiert werden. Sie sparen sich später viel Zeit und Ärger. Zwischen den Tools des JDK 1.1.x (bzw. den Betaversion des JDK 1.2) auf der einen und den Tools der Nachfolgeversionen auf der anderen Seite haben sich einige schwerwiegende Veränderungen bezüglich ihres Aufrufs und den Voraussetzungen für eine korrekte Verwendung ergeben. Es gilt zwar prinzipiell, dass die Aufrufparameter bei Tools weitgehend unverändert blieben, wenn sie noch die gleiche Funktion wie bei dem zugehörigen Tool der Vorgängerversion haben. Außerdem sollten neue JDKs soweit wie möglich abwärtskompatibel sein. Einige wichtige Details sind jedoch verändert.
3.4.1
Pfad-Angaben
Da Sie in der Regel die JDK-Programme auf Befehlszeilenebene ausführen werden, ist es im Allgemeinen sinnvoll, die in der JDK-Umgebung verfügbaren Werkzeuge von allen Verzeichnissen auf Ihrem System aus zugänglich zu machen. Dies realisiert ein Eintrag in den Suchpfad des Computersystems. Für Windows-Anwender wird dies am sinnvollsten erreicht, indem man das Verzeichnis, das die Werkzeuge enthält, in die Pfadangaben (Set path) einträgt. Die Pfadangabe sollte ungefähr so aussehen: SET PATH= C:\;D:\;C:\JDK1.3\BIN;C:\WINDOWS;C:\WINDOWS\COMMAND
Java 2 Kompendium
103
Kapitel 3
Das JDK In unserem Beispiel ist C:\JDK1.3\BIN das Verzeichnis der JDK-Umgebung. In einer DOS/Windows-Umgebung werden Verzeichnisse mit Backslash getrennt, die einzelnen Einträge im Pfad mit Semikolon. Sie können den Pfad auf Kommandozeilenebene jederzeit überprüfen, indem Sie path ohne weitere Parameter eingeben. Sie können auch unter Windows einfach den aktuellen Pfad mit der folgenden Anweisung erweitern: path=%path%;C:\JDK1.3\BIN
Wenn Sie diese Anweisung mit einem entsprechend konfigurierten DOSFenster für Java koppeln (eine Batch-Datei oder etwas Ähnliches), sparen Sie sich die jeweils notwendige Eingabe bei einem neuen Öffnen der DOSBox. Auch unter Solaris können Sie die Pfadangabe setzen. Unix verwendet den normalen Slash zum Trennen der Verzeichnisebenen. Wenn Sie z.B. eine C-Shell (csh) verwenden, können Sie die Pfadangabe in der Startup-Datei (~/.cshrc) wie folgt setzen (Beispiel mit dem Verzeichnis jdk1.3): set path=($path /usr/local/jdk1.3/bin)
Anschließend laden Sie die Startup-Datei erneut (bzw. neu einloggen) und überprüfen, ob der Pfad richtig gesetzt ist. Wenn Sie später versuchen, innerhalb eines bestimmten Unterverzeichnisses zu kompilieren und die Fehlermeldung »Bad command or filename« (»Ungültiger Befehl oder Dateiname«) unter Windows bzw. »File not found« unter Unix bekommen, liegt das wahrscheinlich daran, dass diese Pfadangabe nicht korrekt ist. Es gibt diverse Gründe, warum man verschiedene Versionen des JDK gleichzeitig auf dem Rechner verwenden möchte. In diesem Fall sollten Sie jedoch unbedingt mit verschiedenen Umgebungen (z.B. DOS-Fenster unter Windows oder Shell-Fenster unter Solaris) arbeiten, die mit unterschiedlichen Pfadangaben konfiguriert sind. Es langt definitiv nicht, sämtliche parallel vorhandenen JDK-Verzeichnisse für die unterschiedlichen JDKVersionen in den Suchpfad aufzunehmen. Der Kommando-Interpreter wird immer zuerst im aktuellen Verzeichnis und dann entsprechend der Reihenfolge der eingetragenen Verzeichnisse nach einem Programm suchen. Er wird immer die erste gefundene Version eines Tools verwenden. Es wird also immer nur die Tool-Version ausgeführt, die im aktuellen Verzeichnis vorhanden ist oder die zuerst in der Pfadangabe aufgelistet wird.
104
Java 2 Kompendium
Fehlervorbeugung und Fehlerbehebung beim JDK
3.4.2
Kapitel 3
CLASSPATH
Die besprochenen Schwierigkeiten mit der CLASSPATH-Umgebungsvariable bei verschiedenen JDK-Versionen sind ein noch entscheidenderes Argument für die Verwendung mehrerer Umgebungen. Bei der Angabe CLASSPATH handelt es sich um eine Pfadangabe, über die Java (genau genommen bestimmte Tools von Java, aber wir wollen der Einfachkeit halber von Java reden) Klassen sucht, die es zur Laufzeit benötigt. Dabei muss ganz massiv zwischen dem JDK ab der Version 1.2 (Final) und seinen Vorgängerversionen (inklusive der meisten Betaversionen des JDK 1.2) unterschieden werden. Mit der Finalversion des JDK 1.2 wurde ein neues Suchpfad-Konzept für Klassen eingeführt. Aber der Reihe nach – schauen wir uns an, wie es davor war: Es gibt den Suchpfad für Java-Klassen in Rahmen des Java-Konzeptes in zwei Varianten. Bei CLASSPATH handelt es sich einmal um eine so genannte Umgebungsvariable. Umgebungsvariablen sind Einstellungen, mit denen Sie Ihr System spezifizieren können. Man kann sie sich als speicherresidente Variablen des Betriebssystems vorstellen, die globale Einstellungen festlegen. Sie werden z.B. unter der Windows-Plattform im Allgemeinen auf Befehlezeilenebene oder in der Autoexec.Bat mit der Anweisung »SET [Umgebungsvariable] = ...« gesetzt. Die globale Pfadangabe setzen Sie in einer Windows-Umgebung also wie folgt: Set CLASSPATH=c:\java\lib\classes.zip;. oder Set CLASSPATH=c:\jdkx.x.x\lib\classes.zip;.
ß ig den x.x.x ist dabei wieder die konkrete Versionsangabe, die defaultmä Namen des JDK-Verzeichnisses festlegt. Classes.zip ist das RUNTIMEModul (die Systemklassen) von Java in den früheren Versionen. Dabei fällt wahrscheinlich auf, dass explizit eine ZIP-Datei angegeben ist. Java ist in der Lage, diese ZIP-Dateien direkt zu nutzen. Der nach dem Semikolon folgende Punkt gehört ebenfalls zur CLASSPATH-Umgebungsvariable und steht für das aktuelle Verzeichnis. Damit werden JDK-Programme noch einmal ausdrücklich angewiesen, das aktuelle Verzeichnis zu durchsuchen. Neben dem globalen CLASSPATH gibt es einen weiteren Suchpfad für die Systemklassen, der als Option -classpath bei den entsprechenden Tools individuell gesetzt werden kann und die globale Angabe überschreibt. In den alten Versionen des JDK wurden alle Java-Klassen mithilfe des Pfades gesucht, der über die Option -classpath bei einem Tool oder der CLASSPATH-Umgebungvariable gesetzt war.
Java 2 Kompendium
105
Kapitel 3
Das JDK Über die Angagen bestimmen Sie in diesen älteren Versionen der JavaUmgebung, von wo aus Java-Klassen importiert werden. Verwenden Sie unter Windows das Semikolon, um die Liste von Verzeichnissen (und ZIPDateien, die Java direkt verwenden kann) voneinander zu trennen. Unix benötigt Doppelpunkte. Um sich das Verfahren klar zu machen, denken Sie einmal daran, wie normal ausführbare Dateien aus der Befehlszeile aufgerufen werden. Wenn ein DOS- oder Unix-Anwender den Namen eines Programms eingibt und auf die Eingabetaste drückt, sucht der Befehls-Interpreter nach einem ausführbaren Programm für den angegebenen Namen, lädt das Programm, wenn er es findet, in den Speicher und beginnt mit der Ausführung. Die Path-Variable bestimmt, wo und in welcher Reihenfolge der Befehlsinterpreter nach dem ausführbaren Programm sucht. Bei dem Suchkonzept für Java-Klassen ist es zwar ähnlich, wobei aber Java-Programme nicht direkt ausgeführt werden, sondern indirekt vom Java-Interpreter. Sie werden dazu vom Interpreter, einem Browser oder einem Hilfsprogramm wie dem Appletviewer (Teil des Java Development Kits) geladen und dort dann ausgeführt. Da diese Dateien also nicht direkt vom Betriebssystem ausgeführt werden können, wird die Path-Variable des Betriebssystems keinen Effekt mehr haben (darüber würde nur der Interpreter gefunden). Aus diesem Grund wird für diese Funktionalität Ersatz benötigt. Wo ein Betriebssystem die Path-Variable verwendet, um ausführbare Dateien zu finden, nimmt Java einen internen Suchpfad, um Klassen zu finden. Java durchsucht die angegebenen Verzeichnisse, um geeignete .class-Dateien zu finden. Wenn Sie verschiedene Versionen des JDK gleichzeitig auf dem Rechner verwenden möchte, sollten Sie wie gesagt mit zwei oder mehr verschiedenen Umgebungen arbeiten. Ganz wichtig ist dann jedoch, dass bei älteren JDKVersionen auch die CLASSPATH-Angaben unterschiedlich konfiguriert sind. Dazu sollten Sie in jeder DOS-Box bzw. jedem Shell-Fenster die CLASSPATHAngaben explizit setzen. Am besten löschen Sie mit set CLASSPATH= (Windows) bzw. % unsetenv CLASSPATH (Solaris) zuerst eine evtl. vorhandene Umgebungsvariable und setzen sie dann auf das aktuelle JDK-Verzeichnis. Man kann zwar die CLASSPATH-Angabe über getrennte Einträge auf verschiedene Verzeichnisse erweitern. Davon ist aber dringend abzuraten. Aus zwei Gründen: zum einen wird es aus ähnlichen Gründen wie bei der PathAngabe nicht einwandfrei funktionieren, zum anderen sollte aus Sicherheitsgründen die CLASSPATH-Angabe nicht unnötig erweitert werden. Eine Klasse, die in einem mit der CLASSPATH-Angabe spezifizierten Verzeichnis steht, wird beim Laden vom Classloader nicht mehr auf Viren und Fehler geprüft. Deshalb sollten dort ausschließlich absolut vertrauenswürdige Klassen stehen. Nochmals zu Verdeutlichung: Die bisherigen Ausführungen zum CLASSPATH betreffen die JDK-Version 1.1.x und die meisten 1.2-Betaversionen, haben also die grundsätzliche Vorgehensweise und die Hintergründe der früheren JDKs behandelt. Ein wesentliches Problem bei diesen Versionen des CLASS-
106
Java 2 Kompendium
Fehlervorbeugung und Fehlerbehebung beim JDK
Kapitel 3
PATH war die Tatsache, dass es zu Konflikten zwischen der dauerhaft gesetzten Angabe und der -classpath-Option einzelner Tools kommen konnte
(Versionskonflikte der Laufzeitumgebung usw.). Sun empfiehlt prinzipiell für neue JDKs, die globale Angabe überhaupt nicht mehr zu setzen und die individuelle Variante zu verwenden, sofern Klassen nicht gefunden werden. Diese Aussage muss aber sogar noch verschärft werden (trotz anders lautender Beteuerungen von Sun). In neuen Versionen des JDK kann die CLASSPATH-Umgebungsvariable eine Menge Ärger bereiten. Sie sollten unbedingt darauf verzichten und bei scheinbar unerklärlichen Fehlern beim Finden von Klassen die Umgebungsvariablen überprüfen. Setzen Sie die Umgebungsvariable explizit auf leer (Set CLASSPATH=). Java geht ab dem JDK 1.2 (Final) beim Finden von Klassen prinzipiell einen neuen Weg. Leider dokumentiert Sun dies nicht so deutlich und leicht verständlich, wie es wünschenswert wäre. Das kurz nach der Freigabe des JDK1.2-Finals vor Hilferufen überquellende Usenet verdeutlichte dies recht drastisch. Die meisten Hilferufe in allen Sprachen waren der Art »Ich habe gerade das JDK 1.2 geladen und installiert und nichts geht mehr« oder »Ich habe gerade das JDK 1.2 installiert und finde die Datei classes.zip nicht. Ich verwende aber das Entwicklungstool xyz, das diese Datei benötigt«. Eine Suche nach anderen Schlagworten rund um die Laufzeitumgebung von Java führte zu zahlreichen weiteren (oft ziemlich verzweifelten) JDK-1.2Anwendern. Aber es ist alles halb so schlimm – nur komplett anders als in den früheren JDK-Versionen. Die meisten Probleme waren ziemlich überflüssig und wären bei einer besseren Bekanntmachung durch Sun nie aufgetreten. Zwar hat Sun ziemlich brutal Dinge im JDK verändert, aber die Probleme beruhten auf der unverständlichen Dokumentation dieser Veränderungen nach außen. Probleme hatten vor allem die JDK-Anwender, die bereits mit einem älteren JDK arbeiteten. Diese suchten analog den bisherigen JDKs die Datei classes.zip und fanden sie nicht mehr. Worauf sollte also der CLASSPATH gesetzt werden? Die Antwort auf alle Fragen1 ist so einfach, dass Sun es wohl nicht für nötig erachtet hat, dieses richtig deutlich zu machen – das JDK ab der Version 1.2 (Final) benötigt die Datei classes.zip nicht mehr und der CLASSPATH muss (und darf – beachten Sie den Hinweis) gar nicht mehr gesetzt werden. Nicht mehr und nicht weniger.
1
natürlich 42, aber darum geht es hier nicht ;-)
Java 2 Kompendium
107
Kapitel 3
Das JDK Die Veränderungen fanden genau genommen in der Beta-4-Version des JDK 1.2 statt. Dies dürfte auch einer der Hauptgründe für die allgemeine Verwirrung um den CLASSPATH und die Datei classes.zip sein. Zum Zeitpunkt des Erscheinens der letzten Betaversion wartete die ganze Welt bereits auf das Finalrelease. Immerhin war es bereits mehr als ein halbes Jahr überfällig. Die letzte Betaversion wurde deshalb nicht so stark beachtet und die massiven Veränderungen fielen nur wenigen Anwendern auf. In der Finalversion wurden diese Beta-4-Veränderungen dann nur noch sehr mager deutlich gemacht. Dass die CLASSPATH-Angabe nicht gesetzt wird (bzw. werden darf), bedeutet nicht, dass die Tools des JDK die Systemklassen nicht mehr benötigen. Die Systemklassen (in der Datei rt.jar) finden sie nur nach einer erfolgreich durchgeführten Installation des JDK automatisch, wenn sie im lib-Verzeichnis von jre (die Laufzeitumgebung) vorhanden sind. Dabei ist es belanglos, ob es sich um das jre-Verzeichnis innerhalb des JDK-Verzeichnisses handelt oder das eigenständige jre-Verzeichnis einer Installation durch andere Programme. Ab dem JDK 1.2 gibt es nun ein Konzept mit drei Suchpfaden, die zum Auffinden von Klassen verwendet werden2. Die Suche erfolgt streng hierarchisch nach folgendem Ablauf: 1.
Die erste Stelle, an der Java nach Klassen sucht, ist der bootstrap Classpath – der Standardpfad zu den Systemklassen, der bereits nach der erfolgreichen Installation des JDK festliegt. Das aktuelle Verzeichnis ist immer darin enthalten. Der Wert dieser Pfadangabe kann über System.getProperty("sun.boot.class.path") ermittelt werden. Diese Pfadangabe sollte beim Aufruf eines Tools normalerweise nicht verändert werden. Die Option -classpath überschreibt diesen Pfad nicht mehr (wie etwa im alten Konzept), sondern gibt nur an, wo die anwenderdefinierten Klassen zusätzlich zu suchen sind. Zum Überschreiben des bootstrap Classpath (was so gut wie nie notwendig sein sollte) gibt es die neu eingeführte Aufrufoption -Xbootclasspath/-bootclasspath.
2.
Der zweite Suchpfad sind die optionalen Java-Erweiterungsverzeichnisse. Die Liste dieser Verzeichnisse kann über System.getProperty("java.ext.dirs") ermittelt werden.
3.
Die dritte und letzte Stelle, wo Java nach Klassen sucht, ist der »Applikations-Classpath« (also der von der Applikation individuell durch eine Option gesetzte Suchpfad, der auf anwenderdefinierte Klassen verweist). Der Wert von dieser Pfadangabe kann über System.getPro-
2
108
Damit soll diversen Problemen begegnet werden, die beim bisherigen Konzept auftauchten.
Java 2 Kompendium
Fehlervorbeugung und Fehlerbehebung beim JDK
Kapitel 3
perty("java.class.path") ermittelt werden. Falls die Option bei einem Tool-Aufruf nicht gesetzt wird, werden Sie für diesen Wert einen Punkt erhalten.
Wenn Sie sich bereits mit Java und den Tools ein wenig auskennen, können Sie das nachfolgende Testprogramm ausprobieren. Wenn Sie den JavaQuelltext selbst eingeben wollen, starten Sie bitte einen beliebigen ASCIIEditor und geben Folgendes ein (Name der Datei: Pfade.java): class Pfade { public static void main(String argv[]){ System.out.println("Der bootstrap Classpath: " + System.getProperty("sun.boot.class.path")); System.out.println("Die optionalen Java-Erweiterungsverzeichnisse: " + System.getProperty("java.ext.dirs")); System.out.println("Der Applikations-Classpath: " + System.getProperty("java.class.path")); } }
Listing 3.3: Pfade
Über den Aufruf javac Pfade.java können Sie den Compiler anweisen, die Datei zu übersetzen. Anschließend rufen Sie das Programm über java Pfade auf. Sie finden den Quelltext samt bereits übersetztem Programm auch auf der CD in dem Begleitmaterial zu diesem Kapitel. Abbildung 3.15: Pfadeinstellungen
3.4.3
Verwendung von mehreren JDK-Versionen unter Windows
Wenn Sie unter Windows verschiedene Versionen des JDK gleichzeitig auf dem Rechner verwenden möchten und deshalb unterschiedlich konfigurierte DOS-Boxen benötigen, sind zwei (oder entsprechend mehr) kleine Batchdateien vielleicht sehr hilfreich. Tragen Sie in der Autoexec.Bat keine um das Verzeichnis der JDK-Tools erweiterte Pfadangabe und keine CLASSPATH-Umgebungsvariable ein (dies ist Java 2 Kompendium
109
Kapitel 3
Das JDK sowieso nur noch nötig, falls Sie mit einem älteren JDK arbeiten) ein. Statt dessen erstellen Sie entsprechend der Zahl Ihrer gewünschten JDK-Versionen die folgenden Batchdateien: Für JDK-Versionen vor 1.2: PATH=%path%;[Verzeichnis der JDK-Tools]; SET CLASSPATH=[Verzeichnis der Systemdateien]\classes.zip;.
Für JDK-Versionen ab 1.2: PATH=%path%;[Verzeichnis der JDK-Tools]; SET CLASSPATH=
Speichern Sie die Dateien in Ihrem BATCH-Verzeichnis (wenn Sie ein solches haben) oder in einem Verzeichnis in dem Suchpfad des Kommando-Interpreters Ihres Betriebssystems. Ihr Pfad kann nicht beliebig lang werden. Sonst bekommen Sie irgendwann die Fehlermeldung »Kein Platz im Umgebungsbereich«. Arbeiten Sie mit nicht zu langen Pfadangaben (bzw. setzten Sie Ihren Pfad aus mehreren einzelnen Teilstücken, die in verschiedenen Variablen gespeichert werden, zusammen) oder konfigurieren Sie Ihren Rechner mittels der Umgebungsparameter so, dass er einen grö ß eren Umgebungsbereich nutzen kann. Dazu muss jedoch im Rahmen eines Java-Buchs auf entsprechende Literatur zum Betriebssystem verwiesen werden. Wenn Sie nun eine DOS-Box für die Arbeit mit dem JDK öffnen, rufen Sie einfach zuerst die passende Batchdatei auf und die Pfad- und Umgebungsangaben sind korrekt gesetzt. Noch komfortabler unter Windows ist die Erstellung eines eigenen Programmsymbols für die jeweilige JDK-DOS-Box im Arbeitsplatz oder Windows-Startmenü mit der direkten Übergabe der passenden Batchdatei als Programmaufruf-Parameter. Die DOS-Boxen werden in Windows über so genannten PIF-Dateien (Program Interfaces) realisiert. Erstellen Sie zuerst für jede JDK-DOS-Box im Windows-Startmenü einen eigenen Eintrag oder erstellen Sie im Arbeitsplatz bzw. Explorer ein Icon für einen Programmaufruf. Am einfachsten geht das, wenn Sie die Orginal-DOS-Eingabeaufforderung duplizieren und nur mit neuen Namen versehen. Sie können folgendermaßen vorgehen:
110
1.
Öffnen Sie zuerst den Arbeitsplatz.
2.
Wechseln Sie in das gewünschte Verzeichnis.
Java 2 Kompendium
Fehlervorbeugung und Fehlerbehebung beim JDK
Kapitel 3
3. Erstellen Sie dort eine Verknüpfung zum DOS-Prompt. Dazu suchen Sie sich ein bestehendes Symbol für das DOS-Prompt und klicken beispielsweise mit der rechten Maustaste darauf. Im Kontextmenü finden Sie dann einen Eintrag zur Erstellung einer Verknüpfung. 4. Benennen Sie die Verknüpfung um (z.B. JDK 1.0 oder JDK 1.3). 5. Wiederholen Sie den Vorgang für alle JDK-Versionen, die Sie verwenden wollen. 6. Nun müssen die PIF-Dateien entsprechend angepasst werden. Die Bearbeitung von solchen PIF-Dateien erfolgt in Windows-Versionen vor Windows 95 bzw. NT 4 in dem so genannten PIF-Editor. Das Eigenschaftenfenster ersetzt ab Windows 95 und Windows NT ab der Version 4.0 den PIF-Editor. Der PIF-Editor soll noch kurz am Ende des Abschnitts erklärt werden, wir setzen den Vorgang mit dem Eigenschaftenfenster fort. Klicken Sie mit der rechten Maustaste im Arbeitsplatz auf das Symbol für das Programm. 7. Klicken Sie im Menü DATEI oder im Kontextmenü auf EIGENSCHAFTEN. 8. Wählen Sie dort das Registerblatt PROGRAMM. 9. Tragen Sie die gewünschte Programmbezeichnung ein. 10. Legen Sie bei Bedarf ein Anfangsverzeichnis fest. 11. Jetzt kommt das Wichtigste: Im Textfeld STAPELVERARBEITUNGSDATEI muss die passende Batchdatei (am besten mit vollständiger Pfadangabe) als Programmaufruf-Parameter eingetragen werden. 12. Wenn Sie wollen, können Sie mit der Schaltfäche ANDERES SYMBOL noch ein schöneres Icon wählen. 13. Sie können festlegen, ob die JDK-BOX in einem Fenster oder als Vollbild gestartet wird, indem Sie die Eigenschaften für Ausführen in der Registerkarte BILDSCHIRM ändern. Vollbild ist in der Regel zu empfehlen. 14. Wiederholen Sie den Vorgang für alle JDK-Versionen, die Sie verwenden wollen. Die angegebenen Einstellungen werden mit der Batchdatei immer dann verwendet, wenn Sie das Programm durch Doppelklicken auf das zugehörige Symbol starten. Es sollten alle Pfad- und Set-Angaben nun für jede JDKVersion passen. In Windows werden Programme meist mit dem Startmenü gestartet. Deshalb wollen wir nun noch die JDK-Boxen dort eintragen: 1.
Klicken Sie mit der rechten Maustaste auf eine freie Stelle der Taskleiste.
Java 2 Kompendium
111
Kapitel 3
Das JDK 2.
Wählen Sie dort Eigenschaften aus.
3.
Wählen Sie das Registerblatt Programme im Menü »Start«.
4.
Wählen Sie die Schaltfäche Hinzufügen.
5.
Geben Sie die Befehlszeile für die DOS-Eingabeaufforderung ein oder verwenden Sie die Durchsuchen-Schaltfäche. Auf jeden Fall sollte eine PIF-Datei für die jeweilige Version des JDK dort verwendet werden.
6.
Im nächsten Schritt legen Sie fest, wo genau das Programmsymbol im Startmenü positioniert werden soll.
7.
Im letzten Schritt muss noch die Bezeichnung für die JDK-Box gewählt werden.
Den PIF-Editor unter Windows NT vor der Version 4.0 rufen Sie in der Programmgruppe Hauptgruppe oder mit dem Befehl PIFEDIT auf. Laden Sie dort die Datei DOSPRMPT.PIF als Schablone. Verfahren Sie dann analog wie oben beschrieben. Statt im Textfeld Stapelverarbeitungsdatei tragen Sie die passende Batchdatei (am besten mit vollständiger Pfadangabe) als die Batchdateien im Textfeld Programmparameter ein. Es funktioniert nicht, wenn Sie eine DOS-Box öffnen, dort eine der Batchdateien aufrufen und mit der einen JDK-Version arbeiten und anschließend dort eine der anderen Batchdateien aufrufen, um in der gleichen DOS-Box mit einer anderen JDK-Version zu arbeiten. Der Grund ist der Pfad, der dann nur um das andere JDK-Verzeichnis erweitert wird. Sie haben dann oben beschriebene Probleme mit dem Suchpfad. Sie müssen explizit eine neue DOS-Box öffnen.
3.4.4
»Class not found« und andere Fehlermeldungen
Häufig auftretende Fehlermeldungen beim Arbeiten mit dem JDK – hauptsächlich dem Java-Interpreter oder einem Browser – sind »Class not found«, »Unable to initialize threads« oder »Can’t find class ...«. Dies kann leider diverse Ursachen haben. Dabei ist die einfachste Lösung, dass Sie beim Aufruf des Java-Interpreters einen Schreibfehler gemacht haben oder die Groß- und Kleinschreibung beim Namen der Klasse nicht genau eingehalten haben. Java unterscheidet strikt zwischen groß und klein geschriebenen Namen. Ein fehlender Eintrag der JDK-Tools in den Suchpfad kann ebenso für diese Meldungen verantwortlich sein. Ein weiterer einfacher Fehler ist, dass beim Aufruf des Java-Interpreters die Erweiterung .class mit eingegeben wurde. Es darf aber nur der Klassen-
112
Java 2 Kompendium
Fehlervorbeugung und Fehlerbehebung beim JDK
Kapitel 3
namen spezifiziert werden und nicht die Klassenerweiterung. Dazu mehr bei der Besprechung der einzelnen JDK-Werkzeuge. Ein anderer Grund betrifft die Systemklassen. Stellen Sie sicher, dass sich Ihre Systemklassen auch in dem Verzeichnis befinden, in dem Sie sie installiert haben. Leider müssen diese unliebsamen Fehlermeldungen bei nicht richtig eingerichteten Entwicklungsplattformen unter Umständen noch anderen potenziellen Fehlerquellen zugeschrieben werden. Es gibt viel heimtückischere Fehlerkonstellationen, die eigentlich nichts direkt mit dem JDK zu tun haben. Besonders, wenn man mit Windows 95/98 und einigen » ä lteren« 16-BitProgrammen arbeitet (was heute zwar selten vorkommen sollte, aber nicht auszuschließen ist). Es gibt einige Arbeitsschritte, die bei solchen Mischkonstellationen .class-Dateien oder andere Objekte so beeinflussen, dass sie nicht mehr korrekt verwendet werden können. Zwei potenzielle Fehlersituationen folgen, aber das gilt in demselben Maße für analoge Situationen. Wenn man Dateien mit schnellen und einfachen DOS-(16-Bit-) Programmen kopiert, wird die 16-Bit-Software die Dateien zwar korrekt kopieren, dabei jedoch eventuell auftretende lange Dateinamen (unter anderem die Endung .class) verstümmeln (auf die Kennung .cla, und das langt weder einem Browser noch dem Java-Interpreter). Außerdem sind lange Namen vor dem Punkt auf maximal 8 Zeichen verkürzt, was jedoch nicht so schwerwiegend sein muss (dies hat beispielsweise keine Auswirkung, wenn der Name sowieso kürzer war). Deshalb ist es notwendig, Dateien mit langen Dateinamen unbedingt mit 32-Bit-Software zu kopieren. Dieses Problem entsteht übrigens in gleicher Weise, wenn man mit 16-Bit-Komprimierungsprogrammen oder anderen datenverarbeitenden 16-Bit-Programmen arbeitet. Eine weitere Fehlerquelle hat mit dem eben beschriebenen Problem viel gemeinsam, obwohl nicht mit 16-Bit-Software kopiert wird. Sie ist daher noch heimtückischer. Wenn auf einem PC mit DOS oder Windows 3.x neuere Windows-Versionen installiert werden, wird bei der Installation eine Hardware-Erkennung durchgeführt. Dieser Mechanismus arbeitet (vor allem unter Windows 95) nur mäß ig stabil, sodass ein CD-Laufwerk oft nicht korrekt identifiziert wird. Dennoch wird es unter Umständen anzusprechen sein, denn beim Start von Windows 95 werden die eventuell vorhandene alte AUTOEXEC.BAT und die CONFIG.SYS abgearbeitet und alte 16-BitTreiber für das CD-Laufwerk eingerichtet. In diesem Fall kann man relativ problemlos auf eine CD zugreifen. Wenn man wie üblich auf CDs arbeitet und höchstens ein Programm mit einem maximal 8 Zeichen langen Namen (normalerweise auf CDs ein Setup-Programm) startet, werden kaum Probleme auftreten.
Java 2 Kompendium
113
Kapitel 3
Das JDK Anders sieht es aus, wenn man zum Beispiel von einer CD Dateien kopiert. Dann werden die Dateinamen durch die 16-Bit-Treiber wie oben verstümmelt. Sogar, wenn man mit den Windows 95-eigenen Tools wie dem Windows Explorer oder dem Windows-Arbeitsplatz arbeitet. Diese Tools interpretieren durch die falsche Hardware-Erkennung des CD-Laufwerks alle Objekte auf einer CD nur mit den DOS-Namenskonventionen. Das führt beispielsweise dazu, dass ein Doppelklick auf eine auf der CD befindliche HTML-Datei den verknüpften Browser korrekt startet, die HTML-Datei wahrscheinlich sauber lädt, aber dann alle über lange Dateinamen angesprochene Objekte (Java-Applets, jedoch auch zum Beispiel Grafiken mit langen Namen) nicht finden kann. Erkennen kann man diese Situation relativ einfach, da lange Dateinamen in Anzeigefenstern in der typischen 8-Bit-Schreibweise mit dem ~-Zeichen auftreten. Leider hat man oft eine Anzeigeform gewählt, die dazu führt, dass man sich bei Auftreten des Zeichens nichts denkt und vor lauter Wald die Bäume nicht sieht.
Abbildung 3.16: Die Schlange bei den Dateinamen macht das Problem sogar im Windows Explorer deutlich.
Bei Vorliegen dieser Fehlerkonstellation muss das CD-Laufwerk neu unter Windows angemeldet werden. Dazu ist es am besten, wenn beim Starten von Windows die Abarbeitung von der alten AUTOEXEC.BAT und der CONFIG.SYS mit der F8-Taste unterbunden wird, dann aus dem Bootmenü die Einzelbestätigung ausgewählt und bei der Frage nach Ausführen der AUTOEXEC.BAT und CONFIG.SYS verneint wird. Wundern Sie sich nicht, wenn Ihr CD-Laufwerk anschließend nicht mehr erkannt wird, denn in der beschriebenen Fehlersituation war die Erkennung ja nur durch alte DOS-Treiber 114
Java 2 Kompendium
Fehlervorbeugung und Fehlerbehebung beim JDK
Kapitel 3
gewährleistet. Führen Sie die Hardware-Erkennung von Windows manuell durch. Danach ist das Problem (hoffentlich) beseitigt. Die Meldungen »Applet can't start« oder »Applet not initializied« gehören gleichfalls in diese Reihe von Meldungen, die oft auf eine Mischkonstellation bei der Software zurückzuführen sind. Ein weiterer Grund für Fehler beim Starten von Applets und für Fehler des Java-Interpreters kann sein, dass das Applet/die Java-Anwendung in einem falschen Verzeichnis gesucht wird. Im Fall von Applets und HTML-Quelltext ist die Situation beispielsweise die folgende: Es wird im <APPLET>-Tag mit CODEBASE=[Verzeichnis] auf ein konkretes Verzeichnis verwiesen (absolut oder meist relativ), wo sich das Applet befinden muss. Falls die CODEBASE=[Verzeichnis]-Angabe im <APPLET>-Tag der HTML-Datei fehlt (Regelfall), wird davon ausgegangen, dass sich das Applet im selben Verzeichnis wie die HTML-Datei befindet. Falls dies nicht der Fall ist, kommt eine Fehlermeldung. Die Fehlermeldung »net.socketException: errno = 10047« oder »Unsupported version of Windows Socket API« kann auftauchen, wenn Sie die falschen TCP/IP-Treiber verwenden. Die Meldung »System Error during Decompression« kann angezeigt werden, wenn nicht genug Platz auf der Festplatte mit Ihrem TEMP-Verzeichnis vorhanden ist. Die Meldung »This program cannot be run in DOS mode« erscheint, wenn die DOS-Shell falsch konfiguriert ist. Wenn der Appletviewer keine Applets lädt, müssen unter Umständen einige Umgebungsvariablen gesetzt werden. Etwa so: set HOMEDRIVE=c: set HOMEPATH=\
oder set HOME=c:\
und anschließendem Neustart des Appletviewers. Falls das nicht hilft, versuchen Sie über java -verbose sun.applet.AppletViewer herauszufinden, welche Klassen von wo geladen werden. Anhand der ausgegebenen Liste können Sie überprüfen, ob alle Klassen vorhanden sind. Damit kann auch die allgemeine Funktion des Appletviewers überprüft werden.
Java 2 Kompendium
115
Kapitel 3
Das JDK
3.4.5
Die Java-Umgebungsvariablen
Java besitzt einige Umgebungsvariablen, die in früheren Versionen des JDK gesetzt werden mussten (was immer noch von Interesse ist, wenn man verschiedene Versionen des JDK führen muss). Die meisten Umgebungsvariablen werden nicht mehr verwendet. Hauptsächlich der HotJava-Browser in der alten Version benötigt sie. Seit der parallel zum JDK 1.1.1 oder höher vertriebenen Version des HotJava ist es nicht mehr notwendig, die BrowserUmgebungsvariablen zu setzen. Die CLASSPATH- und die JAVA_HOME-Umgebungvariable allerdings haben nichts damit zu tun und sind oft bei fehlerhafter Zuweisung Quelle diverser Fehlermeldungen. Unter Umständen können Sie die folgende Auflistung von Umgebungsvariablen setzen und einige Probleme bei alten Versionen beheben. Schaden kann ein Setzen der Umgebungsvariablen selten. WWW_HOME: Setzt eine Standard-URL für die Start-Homepage des HotJava-
Browsers. HOTJAVA_HOME: Einstellung des Verzeichnisses, in dem HotJava nach den Dateien sucht, die notwendig sind, um den Browser korrekt ablaufen zu lassen. HOTJAVA_READ_PATH: Diese Umgebungsvariable legt für HotJava das Verzeichnis fest, in dem Applets auf Dateien einen Zugang mit Leserechten haben. Dies kann als Sicherheitsvorkehrung für Applets, die möglicherweise nicht autorisierte Informationen lesen könnten, verwendet werden. HOTJAVA_WRITE_PATH: Das Analogon zur HOTJAVA_READ_PATH-Umgebungsvariable für den Fall von Schreibvorgängen. CLASSPATH: Der Suchpfad für Klassen (wir sind darauf bereits eingegangen). JAVA_HOME: Normalerweise muss das Verzeichnis des JDK nicht explizit in
dieser Umgebungsvariable gespeichert werden. Falls Sie allerdings die Fehlermeldung »Error Message: Could not read properties file« erhalten, kann es in einigen Versionen des JDK daran liegen, dass diese Umgebungsvariable nicht gesetzt ist. In diesem Fall können Sie testweise JAVA_HOME auf das JDKVerzeichnis setzen. Auch die Meldung »Error message: Invalid JAVA_HOME« deutet auf einen Fehler in der Umgebungsvariable JAVA_HOME hin. Sie ist dann zwar gesetzt, jedoch auf das falsche Verzeichnis.
3.4.6
Unbekannte Fehler
Natürlich gibt es in dem JDK Fehler und Probleme, die man noch nicht erkannt bzw. beseitigt hatte, als die jeweilige Version der Software auf den Markt kam. Es gibt deshalb seit der ersten Version des JDK immer eine 116
Java 2 Kompendium
Die wichtigsten JDK-Tools
Kapitel 3
aktuelle Liste der wichtigen neu erkannten und der für das nächste Update bereinigten Fehler. Unter http://java.sun.com/products/jdk/ finden Sie aktuelle Fehlermeldungen. Besser ist jedoch, wenn Sie als registriertes Mitglied an die Bug-Database der Developer-Connection (unter http://developer.java.sun.com/developer/) kommen.
3.5
Die wichtigsten JDK-Tools
Das JDK besteht aus einer ganzen Reihe von Tools. Die wichtigsten Tools waren schon Bestandteil der 1.x-Versionen, viele kamen jedoch erst in der 1.1-Version dazu. Natürlich brachten Folgeversionen weitere Neuerungen (insbesondere wurden Tools der Version 1.1 wieder beseitigt, weil sie nicht so funktioniert hatten wie geplant oder weil sie nicht mehr benötigt wurden). Der Java-Interpreter und der Java-Compiler sind ja schon mehrfach aufgetaucht. Auch der Begriff Appletviewer ist schon gefallen. Es gibt aber noch weitere Tools, die sich im JDK-Unterverzeichnis \bin befinden sollten. An dieser Stelle wollen wir die Basis-Tools samt der wichtigsten Optionen besprechen. Im Anhang gehen wir dann noch intensiver auf die JDK-Programme ein. Zu den Basis-Programmen des JDK 1.3 (also denjenigen, die Sie zum Erstellen von Java-Applets und -Applikationen brauchen) zählen die folgenden: Der Appletviewer, um Java-Applets stand-alone zu betrachten Der Java-Compiler Javac Der Java-Interpreter Java und sein nahezu identisches Schwesterprogramm Javaw Diese Programme werden den Schwerpunkt der nachfolgenden detaillierteren Beschreibung der JDK-Tools bilden. Sie sind für die meisten Entwickler von zentraler Bedeutung. Neben den Basistools beinhaltet das JDK eine Vielzahl an weiteren Programmen, die die zusätzlichen Funktionalitäten von Java abdecken. Diese Programme werden wir im Anhang besprechen.
3.5.1
Ein paar allgemeine Hinweise zu den JDK-Programmen
Bei der Arbeit mit den JDK-Programmen gibt es ein paar Punkte zu beachten. Teilweise sind sie nur von allgemeinem Interesse, einige Details sollte man jedoch kennen. Und zu guter Letzt können Sie sich bei der Arbeit mit den JDK-Programmen mit ein paar Tricks viele monotone Arbeitsvorgänge ersparen.
Java 2 Kompendium
117
Kapitel 3
Das JDK Wenn man ein Programm des JDK ohne irgendwelche Parameter aufruft, bekommt man manchmal die notwendigen Angaben für die korrekte Syntax in Kurzform aufgelistet. Die Betonung liegt bedauerlicherweise auf »manchmal«. Die JDK-Programme erweisen sich in der Handhabung leider als nicht vollständig aufeinander abgestimmt. Ein Aufruf ohne Parameter schadet zwar nie, aber das Resultat ist nicht immer befriedigend. Der Interpreter beispielsweise erzeugt eine recht ausführliche Hilfe auf dem Bildschirm, der Compiler zumindest noch eine Kurzhilfe, während andere Programme in einigen Versionen des JDK mit Fehlermeldungen reagieren. Auch die manchmal existente Option -Help funktioniert in einigen JDK-Versionen beim Schwesterprogramm unter Umständen nicht. Die Option -version, die mal funktioniert, mal nicht, zählt zu den weiteren Kinderkrankheiten von einigen Versionen des JDK. Die unterschiedliche Handhabung bei der Angabe von Dateierweiterungen gehört ebenfalls zu dieser inkonsequenten Logik. Andererseits darf man bei einem kostenlosen Entwicklungswerkzeug dieser Mächtigkeit in Details keine Perfektion erwarten. Hauptsache, man kann Java nutzen. Für die eigentlichen Programmaufrufe ist eine Arbeit auf Befehlszeilenebene auf jeden Fall zu empfehlen (so lange man ohne IDE arbeitet). Zwar kann man aus einer grafischen Oberfläche wie Windows Befehle mit Optionen und Parametern eingeben. Beispielsweise mit dem AUSFÜHREN-Befehl im Windows-Startmenü. Anzuraten ist eine solche Vorgehensweise jedoch nicht, da eventuelle Rückmeldungen des Systems schlecht oder gar nicht auszuwerten sind. Meist ist das Fenster schon wieder geschlossen, bevor man die Rückmeldung gelesen hat. Ein permanent offenes Befehlszeilenfenster ist auf jeden Fall besser. Ein – wahrscheinlich ziemlich trivialer – Hinweis muss dabei jedoch unter Windows unbedingt beachtet werden: Sie dürfen wegen der langen Dateinamen auf keinen Fall mit einer alten 8-BitDOS-Version arbeiten, sondern nur mit der Windows-Eingabeaufforderung bzw. der DOS-Version für Windows 95/98. Migrationen Grundsätzlich muss man sich Gedanken machen, wenn man eine Migration von einem JDK auf eine Nachfolgeversion vollziehen will. Dabei kann es einmal vorkommen, dass bisher verwendete Programme in der neuen Version nicht mehr vorzufinden sind. So lagen einige der Programme des JDK 1.1 jeweils in zwei Versionen vor. Es handelte sich jedes Mal um eine Standardvariante und eine mit _g erweiterte, nicht optimierte Spezialversion, die hauptsächlich für das Debugging eingesetzt werden konnte (die Syntax war immer identisch mit der Standardversion). Im JDK 1.2 wurden sie weggelassen. Wenn so etwas vorkommt, werden die Standardprogramme meist um die Funktionalität der weggelassenen Programme erweitert oder die Funktionalität macht keinen Sinn mehr.
118
Java 2 Kompendium
Die wichtigsten JDK-Tools
Kapitel 3
Recht analog verhält es sich mit Optionen. Ab dem JDK 1.2 verstehen einige Tool so genannte Non-Standard-Options. Neben dem Satz von Standardoptionen gibt es nun die Möglichkeiten, einen Satz von weitergehenden Kommandozeilenoptionen zu verwenden. Diese Non-Standard-Options beginnen bis auf wenige, explizit gekennzeichnete Ausnahmen mit einem -X, etwa -Xdebug oder -Xverify. Wichtigster Unterschied zwischen den Standardoptionen und den Nicht-Standardoptionen ist, dass die Unterstützung für die Standardoptionen im jeweiligen JDK und allen zukünftigen Versionen der JVM durch Sun garantiert wird. Eine Unterstützung für die Nicht-Standardoptionen wird jedoch ausdrücklich für zukünftige Versionen der JVM nicht garantiert. Beim Wechsel auf das JDK 1.3 wurden wieder diverse Optionen weggelassen, verändert oder nicht mehr dokumentiert. Dafür gibt es dann aber einige neue Tools, deren Zweck die Simulation der alten Tools ist. Auf den Webseiten von Sun finden Sie einen Abschnitt mit den häufig zu den JDK-Programmen und Java gestellten Fragen (FAQ). Schauen Sie sich einfach mal die Seite http://java.sun.com/products/jdk/faq.html an. DOSKEY Bei der Arbeit auf Befehlszeilenebene kann man sich viel Arbeit und Zeit sparen, indem man einen Tastaturpuffer für die letzten Eingaben verwendet. Unter NT und Windows 2000 steht ein solcher Puffer immer zur Verfügung, nicht aber unter Windows 95 oder 98. DOSKEY ist ein solcher Tastaturpuffer, der seit DOS-Urzeiten vorhanden ist und Befehlseingaben bearbeitet, Befehle erneut aufruft und Makros erstellt. Für die Verwendung von DOSKEY gilt folgende Syntax: DOSKEY [/Optionen] [Makroname=[Text]]
Die Optionen können nach Wahl frei kombiniert werden und die Reihenfolge ist ebenfalls beliebig. Optionen
Beschreibung
/BUFSIZE:Größ e
Definiert die Grö ß e des Befehlsspeichers (Standardgrö ß e ist 512).
/ECHO:on|off
Aktiviert/deaktiviert das Echo von Makroerweiterungen (Standardeinstellung ist on).
/FILE:Datei
Datei mit einer Makroliste.
/HISTORY
Zeigt alle gespeicherten Befehle an.
Java 2 Kompendium
Tabelle 3.2: Die Optionen von DOSKEY
119
Kapitel 3 Tabelle 3.2: Die Optionen von DOSKEY (Forts.)
Das JDK
Optionen
Beschreibung
/INSERT
Neu eingegebener Text wird in den vorhandenen eingefügt.
/KEYSIZE:Größ e
Definiert die Grö ß e des Tastaturspeichers (Standardgrö ß e ist 15).
/LINE:Größ e
Definiert die maximale Grö ß e des Zeilenspeichers (Standardgrö ß e ist 128).
/MACROS
Zeigt alle DOSKEY-Makros an.
/OVERSTRIKE
Neu eingegebener Text überschreibt vorhandenen (Standard).
/REINSTALL
Installiert eine neue Kopie von DOSKEY.
[Makroname]
Name für ein zu erstellendes Makro.
[Text]
Befehle, die durch das Makro auszuführen sind.
Die Bedienung von DOSKEY erfolgt im Wesentlichen mit den Pfeiltasten, ESC und den Funktionstasten. Hier folgen die vollständigen Tastenkombinationen: Tabelle 3.3: Die Tastenkombinationen von DOSKEY
120
Tastenkombination
Beschreibung
NACH-OBEN
Ruft den vorherigen Befehl ab.
NACH-UNTEN
Ruft den nächsten Befehl (wenn vorhanden) ab.
ESC
Löscht den aktuellen Befehl.
F7
Zeigt die gespeicherten Befehle an.
ALT+F7
Löscht die gespeicherten Befehle.
[Zeichen]F8
Sucht nach einem Befehl, der mit [Zeichen] beginnt.
F9
Wählt einen Befehl anhand seiner Nummer aus.
ALT+F10
Löscht die Makrodefinitionen.
Java 2 Kompendium
Die wichtigsten JDK-Tools
Kapitel 3
In der Makrodefinition von DOSKEY gibt es einige besondere Zeichenfolgen: Zeichenfolge
Beschreibung
$T
Befehlstrennzeichen. Ermöglicht die Verwendung von mehreren Befehlen in einem Makro.
$1-$9
Ersetzbare Parameter. Sie entsprechen ungefähr den Parametern %1 – %9 bei Stapelverarbeitungsdateien.
$*
Symbol für Elemente, die in der Befehlszeile dem Makronamen folgen.
3.5.2
Tabelle 3.4: Die Makrodefinitionen von DOSKEY
Der Appletviewer
Kommen wir zum ersten JDK-Tool. Der Appletviewer ermöglicht es, ohne die Hinzuziehung eines Java-fähigen Browsers ein Applet während der Laufzeit zu betrachten. Er benötigt dazu nur eine rudimentäre HTMLDatei, die eigentlich ausschließlich ein Tag mit Angabe des anzuschauenden Applets sowie eventuell benötigten Parametern enthalten muss. Er lädt alle Applets innerhalb der Webseite und führt sie – sofern es mehrere korrespondierende Applets gibt – jeweils in einem separaten Fenster aus. Wenn eine HTML-Datei kein Tag mit Angabe eines Applets enthält, bewirkt der Aufruf des Appletviewers nichts. In den neuen Varianten versteht der Appletviewer sowohl das ursprünglich ausschließlich zu verwendende <APPLET>-Tag als auch die Tags und <EMBED> zum Einbinden. Der Appletviewer war ursprünglich das einzige Tool der JDK-Sammlung, das eine grafische Benutzerschnittstelle (GUI) besitzt. Im JDK 1.2 ist noch ein neues Sicherheitsprogramm mit GUI hinzugekommen, aber darüber hinaus finden Sie keine weiteren Programme mit GUI. Der Appletviewer hat nur wenige Aufrufoptionen. Es gibt nur die folgende einfache Syntax: Appletviewer [Optionen] [URL der HTML-Datei] [URL der HTML-Datei] wird in der Regel einfach die HTML-Datei ohne irgendwelche Pfadangaben (wenn man in dem entsprechenden Verzeichnis steht) oder mit einfachen Pfadangaben auf dem lokalen Rechner (absolut oder relativ) sein. Die allgemeine Formulierung soll jedoch darauf hinweisen, dass dies natürlich nicht zwingend ist und der Appletviewer ebenso in der Lage ist, bei einer Online-Verbindung eine HTML-Datei samt Applet
Java 2 Kompendium
121
Kapitel 3
Das JDK von einem beliebigen Server zu laden. Beachten Sie, dass die HTML-Datei mit der Endung einzugeben ist. Im Fehlerfall (auch bei falschen Optionen) erhalten Sie die Meldung »Make sure that [Name der HTML-Datei] is a file and is rendable« oder etwas Ähnliches. Ab der Version 1.2 des JDK gibt es eine Neuerung. Sie müssen beim ersten Start des Appletviewers die Lizensbedingungen von Sun akzeptieren. Folgende Optionen für den Appletviewer gibt es:
Tabelle 3.5: Die Optionen des Appletviewers
Optionen
Beschreibung
-debug
Diese Option gibt man an, wenn man den Appletviewer innerhalb des Java-Debuggers laufen lassen möchte. Als direkten Aufruf erzeugt der Appletviewer nur eine kurze Ausgabe auf Befehlszeilenebene.
-encoding [Verschlüssel_name]
Spezifiziert den Verschlüsselungsnamen der HTML-Datei, der bei der Konvertierung verwendet wird. Die Option ist erst seit der Version 1.1.x sinnvoll, denn erst dort wurde die Verschlüsselungsfähigkeit in verschiedene Zeichen in Java integriert. Dieser Verschlüssel_name-String muss als korrektes Argument der Klasse CharacterEncoding definiert sein.
-J Javaoption
Gibt den String Javaoption als ein einzelnes Argument an den Java-Interpreter weiter, der wiederum den Compiler startet. Das Argument darf keine Leerräume enthalten. Mehrere Argumente müssen jeweils mit dem Präfix -J beginnen. Dieses Präfix trennt die Argumente. Die Option ist erst seit der Version 1.1.x vorhanden.
Abbildung 3.17: Der Appletviewer
122
Java 2 Kompendium
Die wichtigsten JDK-Tools
Kapitel 3
Das Menü des Appletviewers Beim Menü des Appletviewers handelt es sich um ein einfaches GUI-Menü. Sämtliche Einträge verbergen sich hinter dem Hauptmenü APPLET. Von der ersten Version des Appletviewers bis zu den aktuellen Versionen sind einige Erweiterungen dazu gekommen. RESTART startet ein Applet mit den aktuellen Einstellungen neu. Eventuelle Veränderungen der zugehörigen Klassendatei (*.class) werden nicht berücksichtigt. RELOAD lädt das Applet erneut. Bei diesem Vorgang kommen im Gegensatz zum Restart die Veränderungen in der Klassendatei zum Tragen. CLONE dupliziert das aktuelle Applet und ein weiterer Appletviewer (also ein neues Fenster) mit den gleichen Einstellungen wird gestartet. PRINT... erzeugt einen Standarddialog zum Drucken des Applets. Der Eintrag ist nur in neueren Versionen des Appletviewers vorhanden und gibt Hintergrundinformationen des Applets aus. STOP ist nur in neueren Versionen des Appletviewers vorhanden und stoppt das Applet. Wichtig ist, dass dies nicht Beenden bedeutet, sondern das Applet nur angehalten wird. Mehr dazu im Abschnitt über Applets. Der Menüeintrag ist nur dann aktivierbar, wenn das Applet läuft. START ist nur in neueren Versionen des Appletviewers vorhanden und startet ein gestopptes Applet erneut. Wichtig ist, dass dies nur für per Stop angehaltene Applets funktioniert. Mehr dazu bei dem Abschnitt über Applets. Der Menüeintrag ist nur dann aktivierbar, wenn das Applet per STOP angehalten wurde. SAVE... erzeugt einen Standarddialog zum Speichern des Applets. Dabei wird eine Datei mit der Defaultendung .SER (das kommt von Serializible) erzeugt, die diverse Hintergrundinformationen (etwa Felder einer Komponente) des Applets speichert. Der Eintrag ist nur in neueren Versionen des Appletviewers vorhanden. Der Befehl TAG zeigt in einem eigenen Fenster sowohl das HTML-Tag zum Einbinden des Applets als auch die zugehörigen Parameter für das Applet an, also einen Ausschnitt aus der aufrufenden HTML-Datei. Innerhalb von Java kann man eine Standardmethode für Informationen über das Applet (public String getAppletInfo()) verwenden. Diese enthält beispielsweise Angaben über den Namen des Applets und den Autor. Der Menüeintrag INFO zeigt diese Angaben in einem eigenen Fenster an. Falls die Informationen in dem Applet-Programm gesetzt wurden, werden sie dort aufgelistet, ansonsten werden in dem InfoFenster nur »no applet info« und »no parameter info« angezeigt.
Java 2 Kompendium
123
Kapitel 3
Das JDK PROPERTIES zeigt in einem neuen Fenster die Sicherheitseigenschaften des Appletviewers an. Wie bereits erklärt, ist der Appletviewer in der Lage, HTML-Dateien und Applets aus einer Netzwerkumgebung zu laden. In diesem Menü ist er entsprechend zu konfigurieren. Die Angaben betreffen in der Version 1.1 des JDK sowie den meisten Betaversionen des JDK 1.2 einen Firewall-Proxy oder einen HTTP-Proxy. Ab der Finalversion des JDK 1.2 können Sie nur noch einen HTTP-Proxyserver konfigurieren. Sie können jeweils einen Proxyserver und den ProxyPort in den dafür vorgesehen Feldern eintragen. In dem Feld für den Netzwerkzugang können Sie den Netzwerktyp auswählen, auf den ein Applet im Appletviewer zugreifen darf. Sie können in den 1.1/1.2-Betaversionen wählen zwischen keinem Netzwerkzugang (None), Applet Host – also dem Host, von dem das Applet stammt – (Standardfall) und uneingeschränktem Netzwerkzugang (Unrestricted). Neuere JDK-Versionen lassen nur noch die Auswahl Restricted und Unrestricted zu. Anhand der Box für den Klassenzugang können Sie also für Ihren Appletviewer beschränkten oder uneingeschränkten Zugang zu anderen Klassen einstellen. Wenn Sie hier Eintragungen vornehmen, werden diese in einer Properties-Datei gespeichert, auf die gleich noch eingegangen wird. CHARACTER ENCODING gibt den Verschlüsselungscode für die Zeichen an, die in dem Applet verwendet werden. Wenn dieser Befehl aktiviert wird, sieht man am unteren Rand die verwendete ISO-Norm der Zeichen. 8859_1 ISO Latin-1 ist üblich im deutschsprachigen Raum. Dieser Befehl ist nur in neueren Versionen des Appletviewers vorhanden, denn in JDK-Version 1.0.x war diese unterschiedliche Verschlüsselung noch nicht vorhanden. CLOSE schließt ein Appletfenster. QUIT schließt wie üblich das Programm und beendet damit zugleich das Applet. Interne Arbeitsweise des Appletviewers Wenn der Appletviewer zum ersten Mal gestartet wird, generiert er – falls nicht vorhanden – unter Windows im JDK bis Version 1.2 die Datei \.hotjava\properties bzw. unter Unix die Datei ~/.hotjava/properties. Im JDK 1.3 wurde die Datei sowohl in .appletviewer umbenannt als auch auf das Unterverzeichnis .hotjava verzichtet. Sie befindet sich jetzt im Verzeichnis C:\Windows. Diese Datei liest das Programm bei jedem Start. Dort befinden sich die wichtigsten Sicherheitseinstellungen für das Laden fremder Applets. Dies betrifft unter anderem Schreib- und Leserechte, jedoch auch Einschränkungen der Verbindungsaufnahme von Applets. Da diese Sicherheitseinstellungen des Appletviewers gleichfalls für die Sicherheitseinstellungen eines
124
Java 2 Kompendium
Die wichtigsten JDK-Tools
Kapitel 3
Browsers von Bedeutung sind, ist eine etwas genauere Beschäftigung damit sicher ganz interessant. Zwar greifen wir damit dem Abschnitt über das Java-Sicherheitskonzept ein wenig vor, andererseits wird durch die praktische Anwendung im Appletviewer das Verständnis für diese Vorgänge leichter. Die Datei könnte etwa so aussehen: #AppletViewer #Sun Feb 28 19:09:42 GMT+01:00 2001 package.restrict.access.sun=false package.restrict.access.netscape=false appletviewer.version=1.2
Oder so: #User-specific properties for AppletViewer #Mon Jan 29 12:26:16 GMT+00:00 2001 http.proxyPort=80 package.restrict.access.sun=false http.proxyHost=
Bei der Generierung der Properties-Datei (erster Start des Appletviewers) werden Defaulteinstellungen für den Appletviewer in die Datei geschrieben, die so lange gelten, bis Sie diese verändern. Genaugenommen werden Sie innerhalb der Datei außer einer Datumsangabe und einer Versionsnummer des Appletviewers vorerst nicht viel finden. Sofern Sie jedoch individuelle Einstellungen für den Appletviewer vornehmen (Menüpunkt PROPERTIES), wird die Datei entsprechend gefüllt. Soweit zu den Sicherheitseinstellungen des Appletviewers. Die konkreten Einstellungen werden von einer abstrakten Java-Klasse, die als Hintergrundprozess immer mitläuft, wenn der Appletviewer gestartet ist, überwacht. Sie heißt SecurityManager und ist schon beim Start eines Browsers automatisch aktiv. Viele Browser haben ähnliche Sicherheitseinstellungsmöglichkeiten wie der Appletviewer. In manchen Bereichen sind Browser sogar noch restriktiver, in anderen dafür freier. Mehr zur Thematik Sicherheit folgt in einem eigenen Abschnitt.
3.5.3
Der Java-Compiler Javac
Der Java-Compiler kompiliert die als Parameter angegebene(n) Datei(en) mit der Dateierweiterung .java in den Java-Bytecode mit der Erweiterung .class. Der Namensstamm der Datei wird für die Klassendatei (nicht den Dateinamen) übernommen. Es können sowohl Applets als auch Anwendungen kompiliert werden.
Java 2 Kompendium
125
Kapitel 3
Das JDK Java ist keine kompilierte Programmiersprache wie C oder PASCAL. Der Quellcode wird also nicht in Maschinencode kompiliert, der spezielle Prozessorbefehle für die Zielplattform enthält. Java ist jedoch auch keine vollständig interpretierte Sprache wie Basic oder Lisp. Der Java-Quellcode wird also schon in gewisser Weise übersetzt, bevor er von einem Interpreter ausgeführt wird. Java ist statt dessen kompiliert und interpretiert und versucht damit, das Beste aus beiden Welten zu vereinen. Der Java-Compiler übersetzt den JavaQuellcode in einen Zwischencode namens Bytecode. Dieser Bytecode kann nicht direkt auf jeder Hardwareplattform ausgeführt werden. Der Code wird vielmehr vom Java-Interpreter interpretiert, der dabei eigenständig oder als Teil eines Browsers arbeiten kann. Java-Programme benötigen also immer einen Container. Es können im Prinzip beliebig viele Dateien als Parameter für die Übersetzung angegeben werden, die jedoch alle mit der Erweiterung .java enden müssen. Javac produziert für jede Datei eine Bytecode-Datei mit gleichem Namen wie die darin enthaltenen Klassen und der Erweiterung .class. Es allerdings ist zu beachten, dass Javac nur eine public-Klasse pro Quelldatei erlaubt. Ohne entsprechende Option erzeugt der Compiler die .class-Datei(en) in demselben Verzeichnis, in dem sich auch die Quelldateien befinden. Falls innerhalb einer Quelldatei auf eine Klasse verwiesen wird, die nicht in der Kommandozeile mit angegeben wurde, so durchsucht der Compiler alle Verzeichnisse oder die Systemklassen mithilfe seines Suchkonzeptes. Individuell können Sie den Parameter -classpath angegeben, um weitere Verzeichnisse zu spezifizieren. Javac-Syntax: javac [Optionen] [Dateiname] [@files]
Beachten Sie, dass der Dateiname zwingend mit der Erweiterung .java eingegeben werden muss. Bei neueren Versionen des Compilers kann über das Zeichen @ eine Datei angegeben werden, die selbst in jeder Zeile den Namen einer .java-Datei enthält. Damit kann verhindert werden, dass die maximale Länge der Kommandozeile überschritten wird. Im JDK 1.3 gibt es übrigens noch das Tool oldjavac, das für einige ältere Optionen eingesetzt werden kann.
126
Java 2 Kompendium
Die wichtigsten JDK-Tools
Kapitel 3
Die Optionen für den Compiler werden mit einem Minuszeichen eingeleitet und können beliebig kombiniert und angeordnet werden. Folgende Optionen gibt es: Optionen
Beschreibung
-nowrite
Eine Option, um die Syntax einer Java-Datei zu testen. Der Compiler wird bei gesetzter Option zwar den Code kompilieren, aber keine Datei mit der Erweiterung .class erstellen. Damit wird auch eine eventuell bereits bestehende Datei nicht überschrieben. Diese Option wird in den neuen Versionen des JDK nicht mehr unterstützt. Im JDK 1.2 wurde sie in offiziellen Quellen schon nicht dokumentiert, hat aber noch funktioniert.
-nowarn
Mit dieser Option können Sie Warnmeldungen des Compilers abstellen. Echte Fehlermeldungen werden jedoch weiter ausgegeben.
-verbose
Diese Option weist den Compiler und den Linker an, während des Kompilierungsvorgangs laufend Statusinformationen über die Quelldatei anzuzeigen. Diese Information umfasst alle geladenen Klassen, die nötige Zeit in Millisekunden, um die Klassen zu laden, und auch die Gesamtzeit, die für die Kompilierung des Quellcodes in Millisekunden wahrscheinlich benötigt wird.
-sourcepath sourcepath
Spezifiziert den Pfad zum Sourcecode.
-d [Verzeichnis]
Diese Option weist den Compiler an, das angegebene Verzeichnis als Zielverzeichnis für eine zu erstellende .class-Datei zu verwenden. Das Verzeichnis ist als Relativangabe zu verstehen. Ohne diese Option erzeugt der Compiler die classDatei(en) in demselben Verzeichnis, in dem sich auch die Quelldateien befinden. Alle class-Files werden in diesem Verzeichnis oder in einem darunter liegenden Verzeichnis abgelegt – in Abhängigkeit von dem Paketnamen der jeweiligen Klassen. Falls Verzeichnisstrukturen noch nicht vorhanden sind, legt der Compiler sie an.
Java 2 Kompendium
Tabelle 3.6: Die Optionen des Compilers
127
Kapitel 3 Tabelle 3.6: Die Optionen des Compilers (Forts.)
Das JDK
Optionen
Beschreibung
-classpath [Verzeichnisse]
Diese Angabe teilt dem Compiler mit, in welchen Verzeichnissen nach Klassen zu suchen ist. Die Verzeichnisse werden in der Unix-Syntax durch Doppelpunkte getrennt, Windows benutzt das Semikolon. Gleichfalls ist für Pfadangaben zu beachten, dass die Komponenten eines Pfades unter Unix mittels Slash und unter Windows mittels Backslash voneinander getrennt werden. Die angegebenen Pfade werden in der Reihenfolge ihres Auftretens durchsucht.
-debug
Diese Option lässt den Compiler im DebugModus laufen, geht den Quellcode durch und fügt Compiler-Kommentare ein. Wird ab dem JDK 1.3 nicht mehr vom Standardcompiler, sondern nur noch von oldjavac unterstützt.
-O
Durch diese Option wird die bestmögliche Optimierung der Klassendateien erreicht. Die statischen, finalen und privaten Methoden werden als Inlinemethoden behandelt und beschleunigen somit die Ausführung des generierten Codes, da der gesamte Methodenkörper eingefügt wird, wo auch immer er im Programm aufgerufen wird – anstatt mehrere Aufrufe zu haben, die sich auf eine Methode beziehen. Man sagt dazu ebenfalls, dass der Code zur Laufzeit ohne den zusätzlichen Overhead eines Funktionsaufrufs erzeugt wird. Ein kleiner Nachteil der Inlinekompilierung ist, dass der erzeugte Bytecode leicht grö ß er wird. Zusätzlich werden bei gesetztem Flag keinerlei Informationen für den Debugger generiert, was die Ausführung ebenfalls beschleunigt. Wichtiger Hinweis: Die Option -O hat seit dem JDK 1.2 eine andere Bedeutung als in den Vorgängerversionen und hat eine verschiedene Auswirkung auf den generierten Code. Außerdem schaltet die Option -O nun nicht mehr implizit die Option -depend an. Diese wird im JDK 1.3 nicht mehr unterstützt.
-deprecation
128
Zeigt eine Beschreibung von jedem verwendeten oder überschriebenen Klassenbestandteil oder einer Klasse an, die(r) als deprecated gekennzeichnet ist. Ohne die Option wird nur der Names der Quelldatei angezeigt, die ein solches Element verwendet.
Java 2 Kompendium
Die wichtigsten JDK-Tools
Kapitel 3
Optionen
Beschreibung
-g
Diese Option bereitet den Bytecode für das Debugging vor. Das bedeutet, dass der Compiler Zeilennummern und Informationen über lokale Variablen in dem Bytecode mit angibt. Es gibt die Option auch noch mit zusätzlichen Angaben none oder einer Liste von Schlüsselworten (per Doppelpunkt angefügt).
-encoding [encoding name]
Geben Sie hier den Source-Verschlüsselungsnamen (etwa EUCJIS \ SJIS) an. Wenn diese Option nicht angegeben wird, wird der defaultmä ß ige Converter der jeweiligen Plattform verwendet.
-depend
Bewirkt eine Rekompilierung von Klassendateien, auf die die Quelldateien einen rekursiven Aufruf implementiert haben. Ohne diese Option werden nur die fehlenden oder veralteten Dateien mit direktem Aufruf erneut kompiliert. Diese Option gab es in den 1.0.x-Versionen nicht, und das JDK 1.3 entfernt sie wieder.
-target version
Generiert .class-Dateien, die auf der spezifizierten JVM laufen. Defaulteinstellung ist, dass die .class-Dateien auf allen JVMs laufen sollen. Die Angabe einer niedrigen Version stellt sicher, dass die .class-Dateien sowohl auf JVMs der entsprechenden Version als auch der Folgeversionen laufen. Die Angabe einer höheren Version hingegen legt fest, dass die generierten .class-Dateien nur auf JVMs der höheren Versionen, nicht aber der Vorgängerversionen laufen.
-bootclasspath bootclasspath
Setzen des Suchpfades für die Systemklassen.
-extdirs directories
Setzen von Erweiterungsverzeichnissen. Jedes JAR-Archive in den angegebenen Verzeichnissen wird nach .class-Dateien durchsucht.
-JJavaoption
Die in der Hilfe des 1.3-Compilers undokumentierte Option gibt den String Javaoption als ein einzelnes Argument an den Java-Interpreter weiter, der von javac aufgerufen wird. Das Argument darf keine Leerräume enthalten. Mehrere Argumente müssen jeweils mit dem Präfix -J beginnen. Dieses Präfix trennt die Argumente. Die Option ist erst seit der Version 1.1.x vorhanden. Beispiel: -J-Xms48m setzt den Startupmemory auf 48 Megabytes. Obwohl diese Option nicht mit einem -X beginnt, ist sie keine Standardoption von Javac.
Java 2 Kompendium
Tabelle 3.6: Die Optionen des Compilers (Forts.)
129
Kapitel 3
Das JDK
3.5.4
Der Java-Interpreter
Java ist ein Kommandozeilen-Interpreter zur Ausführung von eigenständi-
gen Java-Anwendungen (keine Applets, dafür ist der Appletviewer zuständig). Jedes Java-Programm wird durch Klassennamen definiert. Dieser Klassenname muss dementsprechend vollständig mit dem Paketnamen der Klasse angegeben werden. Die Syntax für den Interpreter, den es in mehreren Versionen gibt: java [Optionen] [Klassenname] [Argumente] java [Optionen] -jar file.jar [ argument ... ] javaw [Optionen] [Klassenname] [Argumente] javaw [Optionen] -jar file.jar [ argument ... ] oldjava [Optionen] [Klassenname] [Argumente] oldjavaw [Optionen] [Klassenname] [Argumente]
Diese sechs Versionen vom Java-Interpreter müssen ein wenig erklärt werden. Erst einmal gibt es dabei vier verschiedene Versionen des Interpreters: java und javaw sind identisch bis auf eine Ausnahme: javaw erzeugt keine dem Befehlsaufruf folgende Ausgabe in einem Fenster (noconsole window). Die javaw-Variante des Interpreters gibt es nur unter Windows. oldjava und oldjavaw unterscheiden sich genauso wie der normale Interpreter (auch die oldjavaw-Variante des Interpreters gibt es nur unter Windows). Ihre Hauptfunktion ist die Ausführung von Applikationen, die über einen eigenen Security Manager verfügen, der auf dem originalen Sicherheitsmodell von Java 1.0/1.1 basiert. Dieser wird unter der Java-2-Plattform mit dem normalen Interpreter java eine Exception auswerfen und nicht starten. Auch sonstiger alter Java-Code kann unter Umständen damit ausgeführt werden, wenn der normale Interpreter damit nicht zurechtkommt.
Es gibt einige spezifische Unterschiede zwischen java und oldjava. oldjava unterstützt nicht den Extension-Mechanismus. Weiterhin nutzt oldjava den bootstrap-Classloader für alle Klassen, während java diesen nur für Systemklassen nutzt. Unter dem neuen java des JDK 1.2 spezifizieren die Optionen -classpath und -cp nur einen Suchpfad für anwenderdefinierte bzw. Nichtsystem-Klassen. Die Optionen können nicht dafür verwendet werden, solche bootstrap-Klassen zu lokalisieren. oldjava verwendet diese Optionen (wie auch früher java selbst), um alle Klassen zu lokalisieren. Dabei gilt es zu beachten, dass sich java und oldjava nicht in der Verwendung der Umgebungsvariablen CLASSPATH unterscheiden (ein entscheidender Unterschied zwischen dem alten java und oldjava). Bis die Variable durch -classpath oder -cp überschrieben wird, spezifiziert CLASSPATH immer den Ort, wo die anwenderdefinierten Klassen zu finden sind (aber nicht, wo die bootstrap 130
Java 2 Kompendium
Die wichtigsten JDK-Tools
Kapitel 3
Klassen sind). Obwohl oldjava im Wesentlichen zur Unterstützung von älterem Javasource gedacht ist, werden von ihm alle aktuellen Securityfeatures unterstützt. Ansonsten ist bei allen Syntaxangaben zu beachten, dass Optionen für den Interpreter diverse Übergabewerte sind und Klassenname der Name der auszuführenden Klasse. Defaulteinstellung ist, dass das erste Argument, das keine Option ist, von dem Interpreter als Name der Klasse interpretiert wird. Unbedingt zu beachten ist, dass beim Klassenname nicht nur die .classErweiterung nicht eingegeben werden muss, sondern sogar gar nicht darf. Dies ist deshalb eine häufige Fehlerquelle, weil es von der Syntaxlogik dem Compiler widerspricht, wo explizit die Erweiterung einzugeben ist. Wichtig ist, dass die Komponenten von Paket- und Klassennamen durch Punkt und nicht durch Slash oder Backslash getrennt werden. Die optionale Angabe file.jar ist der Name der .jar-Datei, die ausgeführt werden soll. Diese Anweisung kann nur in Verbindung mit der vorangestellten Angabe -jar verwendet werden. Argumente bezeichnen den oder die an die main()-Methode weitergegebene(n) Übergabewert(e). Jede Klasse, die in dem Aufruf durch den Klassenname spezifiziert wird, benötigt eine Methode namens public static void main(String argv[]). Sämtliche Argumente, die hinter dem Parameter Klassenname stehen, werden an die Methode main() in gleicher Reihenfolge übergeben, wenn java aufgerufen wird. Wenn mit main() Threads erzeugt werden, so läuft der Interpreter so lange, bis der letzte Thread beendet wird. Ansonsten endet java nach der vollständigen Abarbeitung von main(). Eventuell benötigte weitere Klassen werden automatisch geladen. Die nachzuladenden Klassen müssen sich allerdings im selben Verzeichnis oder im Zugriffspfad befinden. In ehemaligen Java-Versionen vorhandene Bugs konnten diese Restriktion zwar aushebeln, aber dies soll hier keine Rolle spielen.
Der Java-Interpreter hat bereits einige wichtige Sicherheitsvorkehrungen eingebaut. Diese gehören zum zentralen Sicherheitskonzept der Sprache. So überprüft der Java-Interpreter standardmäß ig jede Klasse während des Ladevorgangs. Die Klassen werden diversen Verifizierungen unterzogen. Darunter fällt auch ein Virentest. Durch einzelne folgende Parameter können die Verifizierungen ausgelöst, aber auch eingeschränkt werden, was die Programmausführung natürlich beschleunigt.
Java 2 Kompendium
131
Kapitel 3
Das JDK Bei den Optionen zeigen sich ganz massive Veränderungen zwischen den Interpreter-Version des JDK 1.1 und 1.2 (Beta) auf der einen Seite sowie Folgeversionen auf der anderen Seite. Die Standardoptionen des Interpreters wurden erheblich reduziert und viele Optionen, die früher dazu zählten, werden entweder nicht mehr unterstützt oder nur noch als Non-StandardOptionen geführt.
Tabelle 3.7: Die Standardoptionen des Interpreters
Optionen
Beschreibung
-classpath [Verzeichnis]
Diese Angabe korrespondiert wie bereits beim Compiler mit der gleichnamigen Umgebungsvariable und teilt dem den Interpreter mit, in welchen Verzeichnissen, JAR-Archiven und ZIP-Archiven nach .class-Dateien zu suchen ist. In Verbindung mit java oder javaw werden nur anwenderdefinierte Klassen spezifiziert, in Verbindung mit oldjava oder oldjavaw alle Klassen. Die Verzeichnisse werden in der Unix-Syntax durch Doppelpunkte getrennt, Windows benutzt das Semikolon. Auch ist für Pfadangaben zu beachten, dass die Komponenten eines Pfades unter Unix mittels Slash und unter Windows mittels Backslash voneinander getrennt werden. Die angegebenen Pfade werden in der Reihenfolge ihres Auftretens durchsucht.
-cp
-help -? -version -showversion
-verbose -v
Wie sehr oft üblich, kann mit diesen gleichwertigen Optionen eine Ausgabe sämtlicher Optionen erzwungen werden. Diese Optionen veranlasen den Interpreter, die Version des JDK anzuzeigen. Sie können diese Option auch ohne .class-Datei verwenden. Unterschied zwischen beiden Varianten ist, dass -version den Programmablauf abbricht, während -showversion das Programm startet. Diese Option weist den Interpreter an, während des Ladevorgangs laufend Statusinformationen über die Klassen anzuzeigen (jedes Mal, wenn eine neue Klasse geladen wird). Es gibt die folgenden Spezialfälle: -verbose:class – Anzeige jeder geladenen Klasse. -verbose:gc – Anzeige jedes Garbage collection-
Events. Diese Option weist den Interpreter an, jedes Mal eine Meldung auf dem Bildschirm auszugeben, wenn es zu einer Speicherbereinigung durch die Garbage Collection kommt. -verbose:jni – Anzeige über die Verwendung von
nativen Methoden und andere JNI-Aktivitäten. 132
Java 2 Kompendium
Die wichtigsten JDK-Tools
Kapitel 3
Optionen
Beschreibung
-[DpropertyName] = [NeuerWert]
Es gibt im Prinzip die Möglichkeit, selbst definierte Systemeigenschaften an ein interpretierendes Java-Programm zu übergeben, indem beliebige Eigenschaften und Werte als Optionen mit einem Minuszeichen und D abgetrennt an den Aufruf angehängt werden. Das Java-Programm muss natürlich diese Parameter verwenden können. propertyName ist der Name der Eigenschaft, deren Wert Sie verändern wollen und NeuerWert ist der geänderte Wert der Eigenschaft.
Tabelle 3.7: Die Standardoptionen des Interpreters (Forts.)
Beispiel: % java -Dawt.button.color=red ...
setzt den Wert der Eigenschaft awt.button.color auf red (rot) – das Prozentzeichen ist UNIX-Syntax. java akzeptiert im Prinzip eine beliebige Anzahl von -D-Optionen in der Befehlszeile. -jar
Führt ein Programm aus, das in ein JAR-Archiv verpackt ist. Das erste nachfolgende Argument ist der Name von einen JAR-Archiv (anstelle eines Klassennames). oldjava und oldjavaw verstehen diese Option nicht.
-X
Anzeige der nicht-standard-Optionen.
Neben den Standardoptionen des Interpreters gibt es zahlreiche Non-Standard-Optionen: Optionen
Beschreibung
-Xbootclasspath:bootclasspath
Spezifiziert einen durch Trennzeichen getrennte Suchpfad von Verzeichnissen, JAR-Archiven und ZIP-Archiven.
-Xnoclassgc
Diese Option (entspricht der in früheren Versionen verwendeten Option -noasyncgc, die nicht mehr unterstützt wird) unterbindet das asynchrone Ausführen der Garbage Collection. Die Folge ist, dass dieser nur dann ausgeführt wird, wenn er explizit im Programm aufgerufen wird (System.gc()) oder wenn der zu Verfügung stehende Speicherplatz zu gering wird. Wenn diese Option nicht gesetzt ist, verfolgt die Laufzeitumgebung alle Referenzen auf ein Objekt in dem Heap nach und gibt automatisch den Speicher frei, der von Objekten belegt wird, die nicht mehr länger referenziert werden. Dies geschieht, sobald die CPU dafür Kapazität frei hat und läuft als permanenter, paralleler Hintergrundthread mit geringer Priorität ab.
Java 2 Kompendium
Tabelle 3.8: Die Nicht-Standardoptionen des Interpreters
133
Kapitel 3 Tabelle 3.8: Die Nicht-Standardoptionen des Interpreters (Forts.)
Das JDK
Optionen
Beschreibung
-Xmx [MaximalMemory]
Mit dieser Option (früher nur -mx) stellt man die maximale Grö ß e des Heap-Speichers ein. MaximalMemory ist der maximale Wert in Bytes, den der Interpreter für dynamisch allokierte Objekte und Arrays nutzen kann. Die Grö ß enangabe kann auch in Kilobyte (k an die Zahl angehängt) oder in Megabyte (m an die Zahl angehängt) erfolgen. Voreinstellung ist jedoch die Einheit Byte. Die minimale Heap-Grö ß e ist ein Kilobyte (-Xmx 1k), die Standardgrö ß e des maximalen Heaps liegt bei 16 Megabyte (-Xmx 16m).
-Xms [Memory]
Diese Option (früher nur -ms) stellt die anfängliche Heap-Grö ß e ein, wenn der Interpreter startet. Memory ist die Angabe in Bytes, die bestimmt, wie viel Speicher der Interpreter allokieren soll. Die Grö ß enangabe kann auch in Kilobyte (k an die Zahl angehängt) oder in Megabyte (m an die Zahl angehängt) erfolgen. Voreinstellung ist jedoch die Einheit Byte. Die minimale Heap-Grö ß e ist ein Kilobyte (-ms 1k), die Standardgrö ß e des anfänglichen Heaps ist 1 Megabyte (-Xms 1m) und wird immer dann genommen, wenn der Parameter nicht angegeben wird. Bei großen Java-Programmen sollte die anfängliche Heap-Grö ß e erweitert werden, um die Performance zu verbessern.
-Xdebug
Diese Option (früher nur -debug) veranlasst den Interpreter ein Passwort zu erzeugen, nachdem er gestartet wurde. Es wird auf dem Bildschirm angezeigt und kann in der Passwortoption (-password) des Debuggers jdb verwendet werden, um sich nachträglich in die Sitzung einzuklinken (Remote-Zugriff).
-Xrunhprof[:help][:= ,...]
Erlaubt die Beobachtung von dem Prozessor, dem Heap oder Monitor.
-Xmixed
Mixedmode-Ausführung.
-Xint
Nur interpretierte Ausführung.
Es gab über die zahlreichen Varianten des JDK diverse Interpreter-Optionen, die mittlerweile nicht mehr dokumentiert werden. Diese werden aber teilweise immer noch unterstützt und sind natürlich dann interessant, wenn Sie mit einem älteren Interpreter arbeiten.
134
Java 2 Kompendium
Die wichtigsten JDK-Tools
Kapitel 3
Die nicht mehr unter dem JDK 1.3 dokumentierten Optionen: Optionen
Beschreibung
-Xrs
Reduziert Systemsignale.
-Xcheck:jni
Zusätzliche Checks für Java Native InterfaceFunktionen.
Optionen
Beschreibung
-verify
Wenn diese Option gesetzt ist, wird der Bytecode-Verifizierer des Java-Interpreters jedes Mal ausgeführt, sobald eine neue Klassen geladen wird. Diese Klasse wird damit explizit überprüft (Defaulteinstellung). Die Option wird an verschiedenen Stellen der JDK-Dokumentation auch als Nicht-Standardoption -Xverify geführt. Da ist die Dokumentation leider nicht einheitlich. Manche Interpreter-Versionen führen beide Varianten ohne Fehlermeldung aus.
-noverify
Diese Option stellt die Verifizierung der Klassen durch den Bytecode-Verifizierer ab.
-verifyremote
Diese Option weist den Interpreter an, Klassen, die über den Classloader geladen werden (und nur diese), mit dem Bytecode-Verifizierer zu überprüfen. Dies sind im Allgemeinen Klassen, die von einem fremden Host über das Netz importiert oder vererbt worden sind.
-ss [StackGröß e]
Dieser Parameter legt den Wert für die StackGrö ß e eines Threads für einen C-Prozess (Native Code) fest. Die Grö ß enangabe kann auch in Kilobyte (k an die Zahl angehängt) oder in Megabyte (m an die Zahl angehängt) erfolgen. Voreinstellung ist jedoch wie bei den anderen Optionen die Einheit Byte. Die Stack-Grö ß e muss mehr als 1 Kilobyte (-ss 1k) betragen. Standardwert ist 128 Kilobyte.
-oss [StackGröß e]
Dieser Parameter legt den Wert für die StackGrö ß e eines Java-Threads fest. Die Grö ß enangabe kann auch in Kilobyte (k an die Zahl angehängt) oder in Megabyte (m an die Zahl angehängt) erfolgen. Voreinstellung ist wie bei den anderen Optionen die Einheit Byte. Die StackGrö ß e muss mehr als 1 Kilobyte (-oss 1k) betragen. Standardwert ist 400 Kilobyte.
Java 2 Kompendium
Tabelle 3.9: Die zusätzlichen Nicht-Standardoptionen des Interpreters 1.2
Tabelle 3.10: Die nicht mehr unter dem JDK 1.2 dokumentierten Optionen
135
Kapitel 3
Das JDK Es gibt auch einige Optionen, die in neuen Versionen des JDK effektiv keinen Sinn haben, da dort die entsprechenden Tools nicht mehr vorhanden sind. In den früheren JDKs sind sie aber von Interesse.
Tabelle 3.11: Optionen des Interpreters vor 1.2
Optionen
Beschreibung
-prof
Anhand dieser Option wird der Interpreter angewiesen, so genannte Profilinformationen in die Datei \java.prof (Defaulteinstellung) auszugeben. Die Option funktioniert nur mit java_g und javaw_g.
-prof:[Datei]
Anhand dieser Option wird der Interpreter angewiesen, so genannte Profilinformation alternativ in eine sellbst definierte Datei auszugeben. Die Option funktioniert nur mit java_g und javaw_g.
-t
Gibt eine Spur der abgearbeiteten Anweisungen aus. Die Option funktioniert nur mit java_g und javaw_g und ist erst in der Version 1.1.x eingeführt worden.
3.6
Zusammenfassung
Wenn Sie in Java programmieren wollen, wird das JDK die Basis sein, auch wenn Sie auf ergänzende Tools umsteigen. Diese nutzen das JDK meist direkt. Das kostenlos von Sun bereitgestellte JDK beinhaltet eine Vielzahl von Tools, von denen der Compiler, der Interpreter und der Appeltviewer die wichtigsten sind. Die zusätzlich von Sun bereitgestellte Online-Dokumentation ist eine nahezu unumgängliche Basis zum Nachschlagen von Details zu Java oder den JDK-Tools.
136
Java 2 Kompendium
4
Unterschiede zwischen JavaApplikationen und -Applets
Nachdem nun die wichtigsten Voraussetzungen (Einiges an Grundlagentheorie und diverse Werkzeuge) besprochen wurden, wollen wir konkret zu einem ersten Einstieg in die Java-Programmierung kommen. Sie sollen ja nicht die Lust verlieren, weil wir einfach nicht zu Java kommen. Ein oft gemachter Fehler bei Java-Laien besteht darin, Java-Applikationen und Java-Applets gleichzusetzen. Um diesem Missverständnis vorzubeugen, soll an dieser Stelle der Unterschied zwischen Java-Applikationen und -Applets besprochen werden. Auf viele Details in der Programmierung wird zwar hier nicht eingegangen, jedoch einige Grundlagen sollen doch diskutiert werden. Ein Hauptgrund für die heutige Beliebtheit von Java beruht sicher auf den Java-Applets, die erst richtig Leben in das WWW gebracht haben. Solche Java-Applets können nur innerhalb eines Webbrowsers oder des Appletviewers ausgeführt werden. Ein solcher Container bildet quasi ein zweites Betriebssystem für Applets. Da beide Programme aber HTML-Seiten anzeigen, muss ein Applet über eine solche HTML-Seite referenziert werden. Eine entsprechende Referenz innerhalb einer HTML-Seite mit einem speziellen Tag – dem <APPLET>-Tag – erledigt die Einbettung in den Browser. Seit der HTML-Version 4.0 kann die Einbettung von Java-Applets in Webseiten ebenso mittels des allgemeineren -Tags erfolgen. Das ursprünglich nur für ActiveX-Controls verwendete -Tag dient seit HTML 4 zum Einbinden von allgemeinen Objekten. Darunter fallen u.a. Bilder, Video- und Tondateien und eben auch spezialisierte Applikationen wie Java-Applets. Damit werden im Prinzip einige bisherige Tags – so auch das <APPLET>-Tag – überflüssig. Statt vielen verschiedenen Tags ist nur noch das -Tag notwendig. Die Browser unterstützen die bisherigen Tags jedoch nach wie vor. Außerdem gibt es nachfolgend noch besprochene Gründe, warum die Verwendung von <APPLET> sinnvoller sein kann. Da Java-Applets innerhalb eines Browsers laufen, haben sie direkten Zugang zu den meisten Fähigkeiten desBrowsers. Dazu zählen u.a. Zugriffe auf Grafiken und Elemente der Benutzeroberfläche, aber auch Netzwerkfähigkeiten.
Java 2 Kompendium
137
Kapitel 4
Unterschiede zwischen Java-Applikationen und -Applets
Abbildung 4.1: Ein Applet innerhalb eines Browsers
Allerdings teilen sie auch die Einschränkungen des Browsers – oder genauer: Sie werden durch den Browser beschränkt. Das beinhaltet beispielsweise die fehlende Möglichkeit, das Dateisystem des Rechners zu lesen und dort Schreibvorgänge durchzuführen. Es sei denn, der Anwender erlaubt es, indem die Sicherheitseinstellungen des Containers entsprechend gelockert werden. Weiter können Applets normalerweise nur zu dem Host Verbindung aufnehmen, von dem sie geladen wurden. Auch hierzu sind in den Einstellungen des Appletviewers bzw. des Browsers entsprechende Veränderungen möglich, die dann eine noch geringere, aber auch weitergehende Kommunikation erlauben. Zwei weitere Einschränkungen von Applets gehen über diese Eigenschaften hinaus. Zum einen können Applets keine auf dem Client-System vorhandenen Programme starten, zum anderen können Sie keine nativen Programme und Bibliotheken der lokalen Plattform laden. Bugs in älteren Java-Versionen, die in diese Richtung Manipulationsmöglichkeiten eröffneten, werden beim Java-Sicherheitskonzept angesprochen. Darüber hinaus müssen JavaApplets noch diverse weitere Sicherheitsregularien einhalten, auf die ebenfalls noch näher eingegangen wird. Applets ist insbesondere die Unterbrechung der Ausführung des Java-Interpreters nicht erlaubt. Sie können also die Methode System.exit() nicht aufrufen.
138
Java 2 Kompendium
Die technischen Unterschiede
Kapitel 4
Dies alles mag erst einmal als Einschränkung und Argumente gegen Applets empfunden werden, aber genau das Gegenteil ist der Fall. Immerhin soll ein Anwender ja via Browser ein Programm auf seinen Rechner lassen, dessen Funktionalität er nicht kennen kann. Wenn man als Anwender sicher sein kann, dass zumindest die verwendete Technologie keinen Schaden anrichten kann, wird das die Akzeptanz erheblich erhöhen. Applets erlauben nur solche Aktionen, die einen Anwender so gut wie nicht schädigen können. Zumindest muss man sich mit Java-Applets erheblich anstrengen, wenn man einen Anwender ärgern will. Mit anderen Technologien geht das viel leichter. Java-Applikationen sind im Gegensatz zu Applets vollständig in Java programmierte und eigenständig lauffähige Programme. Sie benötigen im Kontrast zu den Applets keine Container mehr (beispielsweise einen Browser oder den Appletviewer). Sie laufen direkt in der virtuellen Maschine und haben dementsprechend weitergehende Möglichkeiten auf dem lokalen System. Das ist auch sinnvoll, denn sonst könnten keine konkurrenzfähigen Applikationen in Java entwickelt werden. Anders gesagt – eine Java-Applikation kann all das leisten, was sie auch können würde, wenn sie in einer anderen Programmiersprache erstellt worden wäre. Abbildung 4.2: Das Applet als eigenständige Applikation
4.1
Die technischen Unterschiede
Eine eigenständig lauffähige Java-Applikation benötigt immer eine zentrale Methode, deren Abarbeitung dem gesamten Programmlauf entspricht: die main()-Methode. Genau betrachtet besteht die Ausführung einer Java-Applikation nur aus dem Start, der Durchführung und dem Ende der main()Methode. Sämtliche Aktionen der Java-Applikation werden von da aus gesteuert und aufgerufen. Die genaue Syntax sieht so aus: public static void main (String args[])
Beim Java-Applet ist es etwas anders. Es gibt als wesentlichen Unterschied keine main()-Methode.
Java 2 Kompendium
139
Kapitel 4
Unterschiede zwischen Java-Applikationen und -Applets Ein Applet benötigt zwar keine Methode namens main(), das bedeutet aber nicht, dass dort eine solche Methode verboten ist. Insbesondere solche Applets, die alternativ als eigenständige Applikation lauffähig sein sollen, besitzen eine solche main()-Methode. Beim Start als Applet wird sie nur nicht verwendet. Das Leben eines Applets vollzieht sich in vier Schritten: Das Initialisieren des Applets. Dies erledigt die init()-Methode, deren vollständige Deklaration so aussieht: public void init(). Innerhalb dieser Methode können alle Schritte durchgeführt werden, die vor dem Anzeigen des Applets abgeschlossen sein sollen. Die Methode wird beim Laden des Applets automatisch aufgerufen. Das Starten des Applets. Nach dem Initialisieren wird das Applet gestartet. Um bestimmte Schritte während dieser Phase durchzuführen, kann die start()-Methode verwendet werden (public void start()). Diese Methode wird nach der Initialisierung automatisch aufgerufen, kann aber auch während des Lebens eines Applets mehrfach manuell oder automatisch erneut aufgerufen werden. Das Stoppen des Applets. Stoppen ist das Gegenstück zum Starten des Applets und geht mit diesem Hand in Hand. Nur ein gestartetes Applet kann wieder gestoppt werden. Jedes gestoppte Applet kann wieder ohne Neuinitialisierung gestartet werden (es sei denn, es ist zerstört). Diese Methode wird beispielsweise automatisch aufgerufen, wenn ein Anwender den Anzeigebereich eines Applets in einer Webseite verlässt. Es läuft jedoch – quasi im Leerlauf – weiter und kann reaktiviert werden (etwa automatisch in dem Moment, wo das Applet wieder im Browser angezeigt wird). Um ein Applet zu stoppen oder bestimmte Aktivitäten mit dem Stoppen eines Applets zu koppeln, kann die stop()-Methode verwendet werden (public void stop()). Das Zerstören des Applets. Zerstören bedeutet, dass das Applet eventuell laufende Threads beendet, Objekte freigibt und sonstige Aufräumarbeiten ausführt. Anschließend kann das Applet sein Leben aushauchen, d.h., es wird aus dem Speicher des Rechners entfernt. Wenn der Appletviewer oder der Browser geschlossen wird, wird die Methode automatisch aufgerufen. Das Gleiche passiert, wenn eine neue Webseite geladen wird. Aber auch manuell kann ein Applet zerstört werden. Um bestimmte Aktionen mit der Zerstörung eines Applets zu koppeln, sollten Sie die destroy()-Methode verwenden (public void destroy()). Die allgemeinere finalize()-Methode ist hier nicht anwendbar, da diese eher für ein einzelnes Objekt irgendeines Typs zum Aufräumen verwendet wird und vor allem, weil diese im Gegensatz zu der destroy()Methode nicht immer beim Beenden von einem Browser oder dem Neuladen eines Applets automatisch ausgeführt wird.
140
Java 2 Kompendium
Eine erste Beispielanwendung und ein erstes Applet
Kapitel 4
Wenn Sie sich das Menü des Appletviewers ansehen, werden Sie dort die Befehle Stop und Start wiederfinden.
Abbildung 4.3: Im Menü des Appeltviewers sind die Start- und StopAnweisungen wiederzufinden.
Es ist an der Zeit für Java-Praxis.
4.2
Eine erste Beispielanwendung und ein erstes Applet
Wir wollen an dieser Stelle eine erste Beispielanwendung und ein erstes Applet erstellen. Dabei ignorieren wir bewusst die Situation, dass bisher noch überhaupt kein systematischer Aufbau der Syntax, der Java-Konzepte oder der Befehle erfolgt ist. Auch von grundlegenden Vorgehensweisen bei der Programmierung in Java war noch keine Rede. Um jedoch nach so viel Theorie ein Erfolgserlebnis in der Praxis zu haben, ist es an dieser Stelle sicher sinnvoll, konkrete Beispiele dazwischenzufügen. Natürlich werden die beiden jetzt folgenden Beispiele sehr einfach sein.
4.2.1
Eine erste Applikation
Das klassische »Hello world«-Programm wollen wir als Basis für unser erstes Programm nutzen. Damit bewegen wir uns in bester Tradition fast aller Bücher über Programmiersprachen seit mystischer Basic-Zeit, die dieses Beispiel als Einstieg verwendet haben.
Java 2 Kompendium
141
Kapitel 4
Unterschiede zwischen Java-Applikationen und -Applets Die einzelnen Schritte sollten bei einem ersten Kontakt am besten sklavisch nachvollzogen werden (d.h. mit strenger Beachtung von Namen und Großund Kleinschreibung). Erklärungen der dahinter liegenden Prozesse folgen an späterer Stelle. Hier gilt nur: Hauptsache, »it works«. Da Java innovativ ist, wollen wir in demselben Maße eine innovative Änderung gegenüber dem klassischen »Hello world«-Programm vornehmen. Starten Sie bitte einen beliebigen ASCII-Editor und geben nach folgenden Quelltext ein.
Listing 4.1: Das erste Beispielprogramm
class HelloJava { public static void main (String args[]) { System.out.println("Hello Java!"); }}
Haben Sie die extrem innovative Änderung bemerkt ;-)? So, jetzt haben Sie Ihr erstes Java-Programm geschrieben, aber wie geht es weiter? Speichern ist der nächste notwendige Schritt. Es mag trivial erscheinen, aber die Betonung liegt wirklich auf »notwendig«, was bei integrierten Entwicklungsumgebungen nicht der Fall ist. Dort würde es heißen: »Speichern ist der nächste sinnvolle Schritt«. Da wir unter dem JDK zur Übersetzung des ASCII-Textes jedoch im Folgeschritt ein Programm aufrufen müssen, das eine Datei auf einem (beschreibbaren) Datenträger erwartet, muss unbedingt gespeichert werden, bevor wir mit dem Java-Source etwas anfangen können. Wenn wir davon ausgehen, dass Sie Ihre Pfadangaben entsprechend den Empfehlungen bei der Besprechung des JDK gesetzt haben, können Sie Ihr erstes Programm an einem beliebigen Platz (z.B. im extra erstellten Verzeichnis ErstesProgramm) speichern. Speichern Sie jetzt Ihr Programm in einem Verzeichnis Ihrer Wahl. Speichern Sie den Quelltext unter dem Namen ErstesJavaProgramm ab. War das korrekt so? Eigentlich sollten Sie einen Fehler bereits mit Ihren jetzigen Kenntnissen entdecken. Welche Erweiterung hat jeder Java-Source (nicht der Bytecode)? Wenn Sie sich eine Fehlermeldung bei dem nachfolgenden Aufruf des Compilers sparen wollen, dann speichern Sie das Programm besser mit der Erweiterung .java (Groß- und Kleinschreibung bitte unbedingt beachten), also unter dem Namen ErstesJavaProgramm.java ab.
142
Java 2 Kompendium
Eine erste Beispielanwendung und ein erstes Applet
Kapitel 4
Im nächsten Schritt versuchen wir, den gespeicherten Java-Source zu kompilieren. Öffnen Sie ein Befehlzeilenfenster und wechseln Sie dort in das Verzeichnis, wo der Java-Source abgelegt ist. Dort rufen wir den Java-Compiler auf. Geben Sie Folgendes ein: javac ErstesJavaProgramm
Was passiert? Etwa eine Fehlermeldung? Trotz richtig eingestellter JavaUmgebung? Natürlich, wir haben die Erweiterung vergessen. Also zweiter Versuch mit Erweiterung: javac ErstesJavaProgramm.java
Nun müsste alles glatt gegangen sein. Sollten Sie immer noch eine Fehlermeldung erhalten haben, so warten Sie noch einmal kurz ab. Ansonsten ist es Zeit, das in Bytecode übersetzte Programm auszuführen. Wie geht das? Sie müssen den Java-Interpreter aufrufen und die auszuführende Klasse als Parameter übergeben. Die Klasse bekommt nach der Definition von Java den gleichen Namen wie der Source und die Erweiterung .class. Geben Sie auf Befehlszeilenebene den nachfolgenden Aufruf ein. java ErstesJavaProgramm.class
Was passiert? Etwa schon wieder eine Fehlermeldung? Natürlich, wir haben diesmal die Erweiterung eingegeben und beim Interpreter darf sie nicht eingegeben werden. Also: Zweiter Versuch ohne Erweiterung. Geben Sie auf Befehlszeilenebene den nachfolgenden Aufruf ein. java ErstesJavaProgramm
So, jetzt müsste alles geklappt haben. Oder etwa nicht? Noch eine Fehlermeldung, dass die Klasse nicht gefunden wurde? Geben Sie auf Befehlszeilenebene den nachfolgenden Aufruf ein. java HelloJava
Nanu, jetzt steht Hello Java in der untersten Ausgabezeile oder nicht?! Herzlichen Glückwunsch, Sie haben Ihr erstes Java-Programm erstellt und
Java 2 Kompendium
143
Kapitel 4
Unterschiede zwischen Java-Applikationen und -Applets zum Laufen gebracht. Lassen Sie sich mal den Inhalt Ihres Testverzeichnisses anzeigen (etwa mit dem Befehl DIR direkt in der DOS-Box, dem Arbeitsplatz oder einem anderen Dateimanagement-Programm), dann erkennen Sie wahrscheinlich den Grund, warum es jetzt funktioniert und nicht bei java ErstesJavaProgramm. Es gibt keine Klasse mit dem Namen ErstesJavaProgramm.class, dafür aber eine Klasse mit dem Namen HelloJava.class. Der Compiler verwendet für die Generierung des Klassennamens nicht den Namen der Java-Sourcedatei, sondern den Namen, den Sie als Bezeichner Ihrer Klasse verwendet haben. Wie schon an verschiedenen Stelle erwähnt: Unter Java werden lange Dateinamen verwendet. In einer DOS-Box werden bei Verwendung des DIRBefehls unter Umständen nur die verkürzten Namen dargestellt, zumindest in der ersten Ausgabespalte. Dies ist eine gefährliche Fehlerquelle, wenn Sie da nicht aufpassen. Ich habe Sie mit der Wahl eines abweichenden Namens bewusst aufs Glatteis geführt, damit Ihnen dieser Zusammenhang klar wird. Wenn Sie wollen, können Sie Ihren Java-Source noch mal unter dem Namen Ihrer Klasse (also HelloJava.java) abspeichern und die Schritte noch einmal nachvollziehen. Prinzipiell sollten Java-Source-Dateien unter dem Namen Ihrer publicKlasse (einer gesondert markierten Klasse – Genaueres folgt später) gespeichert werden, um überhaupt keine Missverständnisse aufkommen zu lassen. Zu einer kurzen Erläuterung des Sources soll an dieser Stelle nur Folgendes gesagt werden: 1.
Das gesamte Programm befindet sich innerhalb der Klassendefinition.
2.
Die bei einer eigenständigen Applikation unbedingt notwendige main()Methode enthält nur einen Ausgabenaufruf auf das Standardausgabegerät.
4.2.2
Übergabe von Aufrufargumenten an ein Java-Programm
Natürlich kann man an ein Programm beim Aufruf Parameter übergeben, die das Programm dann verwenden kann. Damit kann man das im Prinzip abgeschlossene Programm beeinflussen. Dies dient etwa zur Ablaufsteuerung, zur Einstellung von Optionen, zur Weitergabe von zu verarbeitenden Werten usw. Argumente an ein Programm werden auf Befehlszeilenebene einfach an den Programmaufruf – mit Leerzeichen abgetrennt – angehängt. Verändern wir doch unser erstes Programm ein wenig, sodass es Argumente auswerten kann.
144
Java 2 Kompendium
Eine erste Beispielanwendung und ein erstes Applet
Kapitel 4
Geben Sie den nachfolgenden Quelltext ein.
class HelloJava2 { public static void main (String args[]) { System.out.println(args[0]); } }
Listing 4.2: Ein Programm, das Übergabeparameter verwendet
Speichern Sie das Programm unter HelloJava2.java. Kompilieren Sie es neu. Geben Sie auf Befehlszeilenebene den nachfolgenden Aufruf ein. javac HelloJava2.java
Geben Sie auf Befehlszeilenebene den nachfolgenden Aufruf zum Start des Programms ein. java HelloJava2 "HelloJava"
Die Ausgabe müsste identisch sein. Beachten Sie, dass das Programm nicht gegen das Fehlen von Übergabewerten geschützt ist. Der in Hochkommata eingeschlossene Übergabewert1 steht über das Zeichenketten-Array args (oder den sonst in der main()-Methode angegebenen Namen) zur Verfügung. Innerhalb der main()-Methode können Übergabeparameter beliebig behandelt werden. Der Index eines Arrays in Java beginnt mit 0. Wir werden später noch einmal auf die Übergabe von Werten an ein JavaProgramm zurückkommen. Insbesondere werden wir darauf eingehen, was man mit den übergebenen Werten alles machen kann und worauf Sie zu achten haben, wenn Sie nicht nur übergebene Zeichen als Text weiter verwenden wollen. Da die Argumentenliste eines Programms immer ein Zeichenketten-Array ist, werden alle Übergabeparameter an ein Java-Programms als Zeichenketten übergeben. Kommen wir nun zur Erstellung eines ersten Applets. 1
Das ist notwendig, da sonst das Leerzeichen vom Interpreter als Trennung von zwei Übergabewerten verstanden würde.
Java 2 Kompendium
145
Kapitel 4
Unterschiede zwischen Java-Applikationen und -Applets
4.2.3
Ein erstes Applet
Möglicherweise wider Ihre Erwartung ist die Erstellung eines einfachen Applets – mit ähnlicher Funktionalität wie das gerade behandelte Programm – komplizierter als die Erstellung der eigenständigen Applikation. Allerdings könnte auf Grund der technischen Unterschiede zwischen Applets und Applikationen schon eine Ahnung aufgekommen sein, dass Applet-Code nicht ganz so einfach sein kann. Eine eigenständig lauffähige Java-Applikation benötigt immer nur eine main()-Methode (siehe Beispiel), während das Java-Applet zwar keine main()-Methode, dafür gleichwohl beivoller Funktionsfähigkeit mindestens vier andere Methoden benötigt – die init()-Methode, die start()-Methode, die stop()-Methode und die destroy()-Methode. Allein daraus dürfte klar werden, dass da eine Menge mehr Source notwendig ist, wenn Sie ein vollständig funktionsfähiges Applet bauen wollen. Lassen Sie uns dennoch ein einfaches Applet erstellen, das genauso wie die eigenständige Applikation aus dem vorigen Beispiel Hello Java ausgibt. Der Quelltext wird trotz der einleitenden Warnung kaum grö ß er als bei der eigenständigen Applikation sein. Dies liegt daran, dass wir diese Methoden nicht direkt notieren müssen. Implizit stecken diese Methoden allerdings dennoch in dem nachfolgenden Beispiel. Es erbt sie über die Syntax extends java.applet.Applet von der Mutter aller Applets (was auch immer das jetzt bedeutet). Dafür müssen wir aber etwas anderes tun. Wir können nicht einfach wie bei einer eigenständigen Applikation einen Ausgabenaufruf auf das Standardausgabegerät nutzen. Ein Applet befindet sich innerhalb eines Containers und muss sich kooperativ zu ihm verhalten. Es muss die Ausgabemöglichkeiten nutzen, die mit dem Container kooperieren, also meistens Fenster im Rahmen einer grafischen Oberfläche. Wir werden das Applet als eine Instanz einer Klasse erstellen, die uns diese Funktionen zur Verfügung stellt. Innerhalb des Fensters wird dann auch nicht mehr geschrieben, sondern eher gemalt, was eine andere Methode zur Ausgabe erzwingt. Außerdem benötigen wir eine HTML-Datei, mit der wir das Applet dann in unseren Container implementieren. Gehen wir das erste Applet-Projekt systematisch an. Als Erstes erstellen wir ein eigenes Verzeichnis für das Projekt (Vorschlag ErstesApplet), in dem sich anschließend die HTML-, die Java- und die Klassendatei befinden sollen.
146
Java 2 Kompendium
Eine erste Beispielanwendung und ein erstes Applet
Kapitel 4
Starten Sie einen ASCII-Editor und geben Sie nachfolgenden Quelltext ein.
import java.awt.Graphics; public class HelloJavaApplet extends java.applet.Applet { public void paint(Graphics g) { g.drawString("Hello Java!", 5, 25); }}
Listing 4.3: Das erste Applet
Dies ist Ihr erstes Java-Applet. Und wie geht es weiter? Wie bei der Applikation mit Speichern als dem nächsten notwendigen Schritt. Speichern Sie Ihren Quelltext in einem Verzeichnis Ihrer Wahl. Speichern Sie den Quelltext unter dem Namen HelloJavaApplet.java
ab (wir müssen alle didaktisch bewusst gemachten Fehler von der Applikation ja nicht wiederholen, oder?!). Im nächsten Schritt werden wir den gespeicherten Java-Source wieder kompilieren. Öffnen Sie wieder ein Befehlzeilenfenster und wechseln Sie dort in das Verzeichnis, wo der Java-Source abgelegt ist.
Rufen Sie den Java-Compiler auf. Geben Sie Folgendes ein: javac HelloJavaApplet.java
Falls Sie keine Tippfehler gemacht haben, sollte die Übersetzung gelungen sein. Der Compiler gibt bei erfolgreicher Übersetzung keine Rückmeldung (nur im Fehlerfall), deshalb sollten Sie zur Sicherheit den Inhalt des Verzeichnisses überprüfen. Es müssen zwei Dateien vorhanden sein (HelloJavaApplet.java und HelloJavaApplet.class). Der Appletviewer (oder ein Java-fähiger Browser) benötigt zum Aufruf des Applets eine HTML-Datei als Gerüst.
Java 2 Kompendium
147
Kapitel 4
Unterschiede zwischen Java-Applikationen und -Applets Wir erstellen nun in einem beliebigen ASCII-Editor unsere HTML-Datei zum Aufruf des Applets. Auch hier verwenden wir nur eine extrem rudimentäre Struktur. Geben Sie Folgendes ein:
Listing 4.4: Die HTML-Datei zum Referenzieren des ersten Applets
<APPLET CODE="HelloJavaApplet.class" WIDTH=150 HEIGHT=25>
Speichern Sie nun Ihre HTML-Datei in dem gleichen Verzeichnis ab, wo sich die .class-Datei befindet. Bei Ihrer Wahl des Namens für Ihre HTML-Datei sind Sie hier vollkommen frei. Allerdings gilt immer: je sprechender, desto besser. Vorschlag: AppletAufruf.html. Schauen Sie sich nun das Applet an. Dazu können wir jeden beliebigen Java-fähigen Browser verwenden. Laden Sie beispielsweise die HTML-Datei per Doppelklick im Windows-Explorer in Ihren Standardbrowser oder öffnen Sie sie als lokale Datei in dem DateiMenü des Browsers. Sie sollten auf jeden Fall etwas Ähnliches sehen wie im nachfolgenden Screenshot. Abbildung 4.4: Das erste Applet im Internet Explorer
Sie können ebenfalls den im JDK integrierten Appletviewer zum Ansehen verwenden. 148
Java 2 Kompendium
Zusammenfassung
Kapitel 4
Schauen Sie sich das Applet im Appletviewer an. Geben Sie bitte zum Aufruf des Appletviewers Folgendes ein: appletviewer HelloJavaApplet
Was erhalten Sie? Natürlich wieder eine Fehlermeldung. Vorsicht Glatteis. Sie müssen die HTML-Datei aufrufen. appletviewer AppletAufruf.html
Das Resultat müsste dann so ähnlich wie im nachfolgenden Screenshot aussehen. Abbildung 4.5: Das erste Applet im Appletviewer
Natürlich können auch Übergabeparameter an Applets weitergegeben werden. Dies ist jedoch nicht so einfach wie bei eigenständigen Java-Applikationen. Wir werden diesen Vorgang deshalb in einem späteren Kapitel – wenn uns bereits mehr Java-Kenntnisse zur Verfügung stehen – besprechen. Dort finden Sie dann auch noch weitere Details zu Applets – vor allem der Einbindung in HTML-Seiten.
4.3
Zusammenfassung
Java-Applikationen und Java-Applets sind zwar eng verwandt, nicht aber gleichzusetzen. Insbesondere muss für Applets erst einmal etwas mehr Aufwand betrieben werden als für eigenständige Applikationen. Dies relativiert sich jedoch, wenn die Anwendungen komplexer werden. Applets können zwar nur innerhalb eines Webbrowsers oder des Appletviewers ausgeführt werden, ihnen steht aber dann die vollständige Funktionalität dieses Containers zur Verfügung. Andererseits werden sie von diesem Container in ihrer Funktionalität beschränkt.
Java 2 Kompendium
149
Kapitel 4
Unterschiede zwischen Java-Applikationen und -Applets Die Einbettung in den Browser-Container erfolgt über eine entsprechende Referenz innerhalb einer HTML-Seite mit einem speziellen Tag – dem <APPLET>-Tag. Alternativ kann beispielsweise das neuere -Tag verwendet werden, das aber alte Browser nicht verstehen und gegen dessen Verwendung auch einige weitere – noch später besprochene – Gründe sprechen. Allerdings gibt es natürlich auch Argumente für dessen Verwendung, die wir ebenso anführen werden. Java-Applikationen sind vollständig in Java programmierte und eigenständig lauffähige Programme, die im Gegensatz zu den Applets keine Container mehr benötigen (von der zwingend notwendigen Existenz der so genannten virtuellen Java-Maschine abgesehen). Die technischen Unterschiede konzentieren sich im Wesentlichen in der Tatsache, dass eine eigenständige Applikation immer eine main()-Methode benötigt, während ein Applet diese nicht verwendet.
150
Java 2 Kompendium
5
Java-Hintergründe
Nachdem wir uns in ein paar ersten Beispielen an Java herangetastet haben, wollen wir nun zu einem etwas abstrakteren Kapitel kommen, das andererseits viel zum Grundverständnis von Java beiträgt. Dabei sind die ersten beiden Abschnitte über die Theorie der Objektorientierung bzw. die spezielle Objektorientierung von Java zwar recht trocken, aber für das Erlernen von Java von fundamentaler Bedeutung. Der dritte Abschnitt über die Plattformunabhängigkeit von Java und den Aufbau der JVM ist dagegen als technische Hintergrundinformation zu verstehen. Für einen ersten Einstieg in die Java-Welt sind diese Informationen nicht unbedingt nötig, Sie können bei Bedarf später darauf zurückkommen. Das soll aber natürlich nicht heißen, dass Sie diesen Abschnitt nicht auch jetzt schon durcharbeiten dürfen. Ich möchte nur vermeiden, dass Sie bereits zu Anfang von zu vielen technischen Details erschlagen werden.
5.1
Was ist OOP?
Ein zentraler Aspekt von Java ist seine Objektorientiertheit (Object Orientation – OO). Deshalb ist eine grundsätzliche Beschäftigung mit diesem Begriff zwingend erforderlich. Nicht zuletzt deshalb, um den Begriff zu entmystifizieren. Außerdem erleichtert ein elementares Verständnis des objektorientierten Konzeptes einen Einstieg in Java erheblich. Zwar kann man Java ebenfalls lernen, ohne sich um das objektorientierte Konzept große Gedanken zu machen. Jedoch werden dann viele wesentliche und unumgängliche Java-Elemente (Klassen, Methoden usw.) quasi vom Himmel fallen, während sie sich aus dem objektorientierten Konzept zwingend ergeben. Dabei gilt es als Erstes festzuhalten, dass nicht die Eigenschaften einer Programmiersprache in der Regel Objektorientiertheit ausmachen, sondern der Denkansatz für die Lösung einer zu programmierenden Aufgabe. Unter dieser abstrakten Aussage können Sie sich vielleicht nicht viel vorstellen, aber ich möchte es so verdeutlichen: Man kann mit jeder Programmiersprache objektorientiert – zumindest im weiteren Sinne – arbeiten, sogar mit solch überholten, prozeduralen Sprachen wie Basic, Cobol oder Fortran. Auch das sehr weit verbreitete Turbo Pascal wurde von seinem Hersteller Java 2 Kompendium
151
Kapitel 5
Java-Hintergründe Borland schon ab der Version 5.5 objektorientiert genannt. Allerdings erleichtern bestimmte Sprachen die objektorientierte Programmierung, andere (wohl auch die oben zitierten) machen es ziemlich schwierig. Weitere Programmiersprachen wiederum nennen sich objektorientiert und lassen den Programmierern so viele (prozedurale) Schlupflöcher, dass das OOKonzept erfahrungsgemäß immer dann ausgehebelt wird, wenn ein nichtobjektorientierter Ansatz auf den ersten Blick sinnvoller und einfacher erscheint. Als Beispiele für solche Sprachen kann man C++ oder Delphi anführen. Die hier nicht zwingende und teilweise recht kompliziert aufgebaute Logik zur Arbeit mit Objekten hat viele Programmierer davon abgehalten, sich ein grundsätzliches Verständnis des objektorientierten Konzepts zu erarbeiten. Und dann gibt es einen Typ von Programmiersprachen, der Programmierern keine andere Wahl als einen objektorientierten Ansatz lässt. Dazu zählen die schon recht alten Sprachen Lisp oder Small Talk. Und eben Java. Der Hauptgrund, dass der Begriff »Objektorientierte Programmierung« (OOP) in der Programmiererwelt für eine große Unruhe und Verwirrung sorgte, ist wohl der, dass Programmierer – nahezu seit es den Beruf gibt – anders denken: prozedural. Aber wir haben immer noch nicht geklärt, was es mit dem Begriff Objektorientierung überhaupt auf sich hat. Im Zentrum der althergebrachten, prozeduralen Programmierung steht die Umsetzung eines Problems in ein Programm durch eine Folge von Anweisungen, die in einer vorher festgelegten Reihenfolge auszuführen sind. Einzelne zusammengehörende Anweisungen werden dabei maximal in so genannte Funktionen oder Prozeduren zusammengefasst. Die Datenstruktur befindet sich in einer von den Anweisungen getrennten Hierarchieebene. Versuchen wir einen Erklärungsansatz über die Entwicklung der EDV. Denn die Geschichte der Programmierung zeigt, dass sich die nicht-objektorientierte Denkweise lange Zeit bewährt hatte und vor allem historische Computerplattformen einfach nicht zu einer anderen Vorgehensweise in der Lage. Und so hatte sich das traditionelle Denkmodell mit der Zeit einfach in den Köpfen der Programmierer festgesetzt. Großer Nachteil dieser nichtobjektorientierten Philosophie ist die mangelnde Wartbarkeit, denn Änderungen in der Datenebene können Auswirkungen auf die unterschiedlichsten Programmsegmente haben. Außerdem entspricht ein solches Denkkonzept der Logik von Maschinen, nicht dem Abbild der realen Natur. Dies war natürlich zu Zeiten der allerersten Computersysteme besonders ausgeprägt. Ein erster Schritt hin zu einer mehr menschlichen Logik war das in den 70er-Jahren entstandene Denkmodell der »strukturierten Programmierung«. Darin wurde versucht, zusammengehörende Befehle als Einheit zu sehen und Programmfunktionen in Unterstrukturen bzw. Unterprogramme (Prozeduren und Funktionen) zusammenzufassen, die bereits über genau
152
Java 2 Kompendium
Die Definition von Objektorientierung
Kapitel 5
festgelegte Schnittstellen zu ihrer Umwelt verfügten. Bei Bedarf konnte man diese Unterstrukturen über ihren Namen aufrufen. Dieser Ansatz stellt zwar eine Verbesserung gegenüber Abläufen dar, die jeden einzelnen Befehl bei Bedarf aufrufen – auch wenn mehrere Programmschritte mehrfach in der gleichen Version benötigt werden. Jedoch ist diese strukturierte Programmierung noch immer nicht die konsequente Umsetzung von menschlicher Denkweise. Insbesondere sind Anweisungen und Daten (Variablen) noch immer getrennt. Hier setzt die Philosophie der Objektorientiertheit als folgerichtige Weiterentwicklung der strukturierten Programmierung an.
5.2
Die Definition von Objektorientierung
Objektorientierte Programmierung lässt sich am treffendsten darüber definieren, dass die Trennung von Datenebene und Anweisungenebene aufgehoben wird. Zusammengehörende Anweisungen und Daten bilden eine zusammengehörende, abgeschlossene und eigenständige Einheit. Man nennt sie – Objekte! Objekte bestehen also im Allgemeinen aus zwei Bestandteilen, den so genannten Objektdaten – das sind die Attribute bzw. Eigenschaften – und aus Objektmethoden. Man kann sagen, dass Attribute die Merkmale sind, durch die sich ein Objekt von einem anderen unterscheidet. Objektmethoden stellen die objektorientierte Ausdrucksweise für die bisherigen Elemente der Anweisungenebene (Funktionen und Prozeduren) dar. Abbildung 5.1: Schema eines Objekts
5.2.1
Objektmethoden
Objektmethoden (oder kurz Methoden genannt) sollen in unserer Vorstellung erst einmal irgendwelche Algorithmen (d.h. Berechnungsformeln) sein, mit denen die – im Prinzip abgeschlossenen und eigenständigen – Objekte miteinander kommunizieren und/oder ihre Objektdaten manipulieren können.
Java 2 Kompendium
153
Kapitel 5
Java-Hintergründe Als eine sinnvolle Definition von Methode kann im Allgemeinen die folgende Aussage gelten: Methoden realisieren die Funktionalität der Objekte, ihre Implementierung erfolgt in den Klassen. Das heißt, Methoden sind die programmtechnische Umsetzung der Objektfunktionalitäten. Wesentlich an der objektorientierten Programmierung ist, dass die Methoden und die Daten (Attribute) gemeinsam einem Objekt zugeordnet sind. Nur über dieses Objekt kommt man an Methoden und die Daten des Objekts heran. Es gibt keine freien Eigenschaften und Funktionalitäten. Dies schließt bei strenger Objektorientierung als wichtige Konsequenz beispielsweise eine Existenz von globalen Variablen aus. Die Zuordnung bedeutet weiterhin (ebenfalls sehr wichtig für das grundlegende Konzept von Java), dass es Methoden ohne zugehörige Objekte nicht geben darf. Obwohl wir nun etwas vorgreifen müssen, soll eine wesentliche – und die einzige – Ausnahme erwähnt werden. Diese Ausnahme scheinen diejenigen Methoden darzustellen, die außerhalb der konkreten Objekte, jedoch innerhalb der Klassen liegen – die so genannten Klassenmethoden. In die gleiche Kerbe schlägt die Existenz von Klassenvariablen, die eine Art von globalen Variablen darstellen. Diese scheinbaren Ausnahmen passen aber dennoch in das objektorientierte Konzept und widerlegen nicht die oben getroffenen Aussagen, sofern man das so genannte Metaklassen-Konzept berücksichtigt, das etwas weiter unten noch erläutert wird. Ein kleines Beispiel soll die Kopplung von Methoden und Eigenschaften an ein Objekt deutlich machen. Wenn man prozedural einen Bauernhof abbilden wollte, könnte man beispielsweise einen Hahn, ein Schwein und eine Kuh programmieren. Zusätzlich erstellt man Funktionen oder Prozeduren, die das Krähen, das Grunzen und das Muhen realisieren. Da diese jedoch nicht an das jeweils sinnvolle Objekt gekoppelt sind, könnte eine Kuh plötzlich krähen, ein Schwein muhen und ein Hahn grunzen. Im objektorientierten Ansatz ist so etwas nicht möglich, denn die Realisierung der Objekte Hahn, Kuh und Schwein beinhaltet bereits deren Funktionalitäten in Form von Methoden, die auch nur über das jeweilige Objekt anzusprechen sind. Auf der anderen Seite ist ein Objekt nach außen nur durch seine Methoden und Attribute definiert, es ist gekapselt, versteckt seine innere Struktur vollständig vor andern Objekten. Man nennt dies Information Hiding oder Datenkapselung. Der ganz entscheidende Vorteil von diesem Verfahren ist, dass ein Objekt sich im Inneren, d.h. bezüglich seiner Objektdaten und seiner inneren Attribute, vollständig verändern kann. Solange es sich nur nach außen unverändert zeigt, wird das veränderte Objekt problemlos in ein System integriert, wo es in seiner alten Form funktioniert hatte. Ob nun – um auf unseren Bauernhof zurückzukommen – die Methode »Krähen« über die Wiedergabe einer lokalen MP3-Datei oder einer MP3-Datei aus einem (hinreichend
154
Java 2 Kompendium
Die Definition von Objektorientierung
Kapitel 5
schnellen) Netzwerk realisiert wird, ändert nichts an der Funktionalität des Objekts. Ein Objekt ist also eine Art »Black Box«. Diese gesamte objektorientierte Philosophie entspricht viel mehr der realen Natur als der prozedurale Denkansatz, der von der Struktur des Computers definiert wird. Ein Objekt ist im Sinne der objektorientierten Philosophie eine Abstraktion eines in sich geschlossenen Elements der realen Welt. Dabei spricht man von Abstraktion, weil zur Lösung eines Problems normalerweise weder sämtliche Aspekte eines realen Elements benötigt werden, noch überhaupt darstellbar sind. Irgendwo muss immer abstrahiert werden – und wenn es erst auf der Ebene der Atome ist, jedoch dann wird es philosophisch. Ein Mensch bedient sich eines Objekts, um eine Aufgabe zu erledigen. Man weiß in der Regel nicht genau, wie das Objekt im Inneren funktioniert, aber man kann es bedienen (weiß also um die Methoden, um es verwenden zu können) und weiß um die Eigenschaften des Objekts (seine Attribute). Die Reihe von Beispielen kann man beliebig lang ausdehnen, wir wollen es beim Auto, der Waschmaschine oder der Kaffeemaschine (es geht ja in dem Buch um Java) belassen. Im Detail sind bei der Erklärung der Objektorientierung jetzt noch einige Festlegungen notwendig.
5.2.2
Who's calling?
Besonders wichtig ist der Begriff der Botschaften. Damit Objekte aktiv werden können, tauschen sie so genannte Botschaften (oder Nachrichten bzw. Messages) aus, die ausschließlich für die Kommunikation von Objekten verwendet werden. Andere Kommunikationswege – etwa die in anderen Programmiersprachen oft genutzten globalen Variablen – gibt es nicht (dies wären ja Attribute, die außerhalb von Objekten existieren würden und das ist explizit nicht erlaubt). Das sendende Objekt schickt dem Zielobjekt eine Aufforderung, eine bestimmte Methode auszuführen. Das Zielobjekt versteht (hoffentlich) diese Aufforderung und reagiert mit der zugehörigen Methode. Dieser Vorgang wird von einigen OO-Gurus als eine Art Bitte bezeichnet, mit der Objekte andere Objekte höflich zur Ausführung diverser Wünsche veranlassen. Die genaue formale Schreibweise solcher Botschaften in OO-Programmiersprachen ist natürlich im Detail verschieden, jedoch meistens wird das Schema Empfänger
Java 2 Kompendium
Methodenname
Argument
155
Kapitel 5
Java-Hintergründe verwendet. Punkt und Klammer trennen dabei meist die drei Bestandteile der Botschaft (die so genannte Punkt-Notation). Eine Botschaft sieht also meist so aus: Empfänger.Methodenname(Argument)
Dies kann aber von Programmiersprache zu Programmiersprache differieren. Das Argument stellt in dem Botschafts-Ausdruck einen Übergabeparameter für die Methode dar. Eine ähnliche Form wird auch für die Verwendung von Objektattributen gewählt. In der Regel sieht das dann so aus: Empfänger.Attributname
Ein fundamentaler Unterschied zwischen der prozeduralen und der objektorientierten Denkweise kann so umschrieben werden: Prozedural bedeutet typengestützt, objektorientiert heißt kommunikationsgestützt. Konkret drückt dies aus, dass eine Prozedur oder Funktion im herkömmlichen Sinn nur Variablen fest vorgegebener Datentypen verwenden kann. Falls eine bestimmte Operation für eine Menge von verschiedenen Datentypen benötigt wird (ein gutes Beispiel ist die Multiplikation), muss für jeden möglichen Typ eine Prozedur geschrieben werden, zumeist noch mit verschiedenen Namen. Die Folge ist in der Regel Fallunterscheidung nach dem Datentyp. Ein neuer Datentyp zieht eine weitere Prozedur/Funktion und – noch schlimmer – an diversen Stellen im Programm Änderungen nach sich. Um das Beispiel der Multiplikation zu nehmen, kann man die mathematischen Datentypen »Reelle Zahlen« und »Komplexe Zahlen« heranziehen und die zugehörigen – mathematisch abweichenden – Multiplikationsvorschriften in zwei Prozeduren abbilden. Die Prozedur für die Multiplikation der reellen Zahlen sollte in etwa so aussehen (das Listing ist nur als Schema zu verstehen): Listing 5.1: Schema einer Multiplikation reeller Zahlen
procedure multiplikation(double a,double b) { double ergebnis; ergebnis= a* b; return (ergebnis); }
Für komplexe Zahlen muss eine vollständig andere Prozedur definiert werden, etwa folgende (dabei seien ergebnis_real und ergebnis_imagiär global definierte Variablen):
156
Java 2 Kompendium
Klassen und Instanzen procedure multi_komplex(double realteil_1, double realteil_2, double imaginaer_teil_1, double imaginaer_teil_2) { ergebnis_real = (realteil_1* realteil_2) – (imaginaer_teil_1* imaginaer_teil_2); ergebnis_imaginaer = (realteil_1* imaginaer_teil_2) + (realteil_2 * imaginaer_teil_1); }
Kapitel 5 Listing 5.2: Schema einer Multiplikation komplexer Zahlen
Man sieht, dass sowohl die Zahl der Übergabeparameter abweicht als auch der eigentliche Berechungsalgorithmus. Zwei – in der Regel unterschiedlich benannte – Prozeduren sind die Folge. In der objektorientierten Sichtweise hingegen steht das Objekt im Mittelpunkt. Die Operation ist in der Klasse implementiert, zu der das Objekt gehört. Die Ausführung der Multiplikation übernehmen die Objektmethoden, der Anwender muss sich darum nicht kümmern. Soll nun eine bestehende Operation (in unserem Beispiel sei das die Multiplikation der reellen Zahlen) um eine neue Funktionalität erweitert werden (Berechnungsvorschrift für komplexe Zahlen), so werden die Veränderungen in der Klasse vorgenommen und die zugehörigen Methoden dort geschrieben. Die neue Form der Multiplikation wird einfach als Erweiterung innerhalb der Klasse hinzugefügt. Nach außen erscheint das Objekt wie schon erwähnt unverändert und lässt sich wie gehabt unter einem Namen ansprechen. Weitergehende Änderungen im Programm sind nicht notwendig.
5.3
Klassen und Instanzen
Der Begriff der Klasse ist von elementarer Wichtigkeit, wenn man in Java oder einer anderen OO-Sprache programmieren möchte. In der OOP werden ähnliche Objekte zu Gruppierungen zusammengefasst, was eine leichtere Klassifizierung der Objekte ermöglicht. Die Eigenschaften der Objekte werden also in den Gruppierungen gesammelt und für eine spätere Erzeugung von realen Objekten verwendet. Diese Beschreibungen oder Baupläne für konkrete Objekte nennt man Klassen, die Objekte selbst sind im OOSprachgebrauch Instanzen dieser Klassen. Oft werden Klassen mit Schablonen verglichen. Man könnte sich Klassen auch als Backformen vorstellen, mit denen Plätzchen (Instanzen) aus einem (Computer-)Teig gestochen werden. Zentrale Bedeutung hat dabei die hierarchische Struktur der Gruppierungen von allgemein bis fein (zumindest bei der Einfachvererbung, auf deren genaue Bedeutung wir noch zu sprechen kommen).
Java 2 Kompendium
157
Kapitel 5
Java-Hintergründe
Abbildung 5.2: Klassen-InstanzenBeziehungen
Beispiel: Ein Objekt Saxophon als konkrete Instanz gehört zu der Klasse der Holzblasinstrumente1. Diese Holzblasinstrumente wiederum gehören zu einer höheren Klasse, den Musikinstrumenten, und diese sind allgemein der Klasse der »Musik erzeugende Dinge« zugehörig. Abbildung 5.3: HierarchieBeziehungen
1
158
Um Lesermails vorzubeugen – das ist in der Tat so: Saxophone zählen zur Familie der Klarinetten. Sie sind zwar aus Metall, besitzen aber ein Holzblättchen zur Tonerzeugung und fallen deshalb unter die Klasse der Holzblasinstrumente.
Java 2 Kompendium
Klassen und Instanzen
Kapitel 5
Gemeinsame Erscheinungsbilder sollten also in der objektorientierten Philosophie in einer möglichst hohen Klasse zusammengefasst werden. Erst wenn Unterscheidungen möglich bzw. notwendig sind, die nicht für alle Mitglieder einer Klasse gelten, werden Untergruppierungen, also untergeordnete Klassen, gebildet. Jede (gewöhnliche) Klasse kann eine Vielzahl von Unterklassen und konkreten Instanzen (Objekten) haben. Abbildung 5.4: Eine Klassenhierarchie
5.3.1
Superklasse und Subklasse
Damit wir jetzt schon in der späteren Java-Sprache sprechen (außerdem ist es gültiger OO-Dialekt), führen wir für eine übergeordnete Klasse den Begriff Superklasse, eine untergeordnete Klasse den Begriff Subklasse ein. Die ineinander geschachtelten Klasse bilden einen so genannten Klassenbaum. Dieser kann im Prinzip beliebig tief werden. Eben so tief, wie es notwendig ist, um eine Problemstellung detailliert zu beschreiben. Jede Subklasse erbt alle Eigenschaften und Methoden ihrer Superklasse. Sie beinhaltet also immer mindestens die gleichen Eigenschaften und Methoden wie die Superklasse. Daher sollte dort sinnvollerweise mindestens eine Eigenschaft oder Methode hinzugefügt werden, die die Superklasse nicht beinhaltet (sonst sind Sub- und Superklasse ja identisch). Mit dieser Erklärung haben wir zum ersten Mal den Begriff der Vererbung herangezogen, der in der OOP von fundamentaler Bedeutung ist. Gleich mehr zur Vererbung, doch vorher klären wir noch zwei Begriffe aus dem Klassenbereich.
Java 2 Kompendium
159
Kapitel 5
Java-Hintergründe
5.3.2
Metaklassen
In Java sind alle Klassen Ableitungen einer einzigen obersten Klasse – der Klasse Object. Andererseits soll Java ein konsequent realisiertes objektorientiertes System sein. In einem solchen System darf es nur Objekte geben, daher müssen selbst Klassen ebenfalls Objekte sein. Das Problem ist jetzt, dass damit auch die oberste Klasse selbst die Instanz einer Klasse sein muss. Jedes Objekt ist nach Definition die Instanz einer Klasse, also muss gleichfalls jede Klasse – sogar die oberste Klasse – Instanz einer anderen Klasse sein. Eigentlich ist dies für die oberste Klasse ein Widerspruch. Die Frage ähnelt ein wenig der Problematik, was sich außerhalb des Universums befindet2. Im Grunde befindet sich keine Klasse mehr außerhalb dieses Objektuniversums. Was also tun, um in dem Modell konsistent zu bleiben? Man definiert zur Einhaltung des streng objektorientierten Konzeptes deshalb so genannte Metaklassen. Die einzigen Objekte von Metaklassen sind Klassen, und sie vererben die Klassenmethoden und Klassenvariablen. Diese werden nicht an das Objekt selbst, sondern an die Objektklasse vererbt (Methoden zum Erzeugen von Objekten oder zur Initialisierung von Klassenvariablen). Neben der Konsistenz des Konzepts ist ein weiterer Vorteil des Metaklassenkonzepts, dass die Klassenmethoden in den Klassen überladen werden können. Gibt es für alle Klassen nur eine einzige Metaklasse, dann gibt es für alle Klassen dieselben Klassenmethoden. Dieses Metaklassenkonzept ist recht ungewöhnlich. Viele andere objektorientierte Sprachen verzichten darauf. C++ verfügt beispielsweise über keine Klassenmethoden und unterstützt das Metaklassenkonzept nicht. An ihre Stelle treten Systemfunktionen, wie etwa ein Operator mit Namen new, um die Instanz einer Klasse zu erzeugen. Diesen new-Operator gibt es in Java ebenfalls. Sogar mit der gleichen Aufgabe. Er ist nur bedeutend schlüssiger in das logische Konzept integriert.
5.3.3
Abstrakte Klassen
Als letzten Klassentyp besprechen wir an dieser Stelle die abstrakten Klassen. Unter einer abstrakten Klasse versteht man eine Klasse, von der nie eine direkte Instanz benötigt wird und auch keine Instanz direkt erstellt werden kann. Eine solche abstrakte Klasse dient zu einem oder mehreren allgemeinen Verweis(en). Signifikante Eigenschaft ist, dass abstrakte Klassen keine Implementierung einer Methode enthalten dürfen und damit auch nicht instanzierbar sind. Java charakterisiert abstrakte Klassen mit dem Schlüsselwort abstract.
2
160
Oder, was zuerst da war: die Henne oder das Ei?
Java 2 Kompendium
Vererbung
Kapitel 5
Abstrakte Klassen werden im Allgemeinen zur Strukturierung eines Klassenbaums verwendet. Eine weitere Aufgabe von ihnen ist die Vereinbarung von Methodenunterschriften, auch wenn die Methoden selbst erst zu einem späteren Zeitpunkt implementiert werden. Die Namen der Methoden und deren Parameter sind dann trotzdem in den Unterklassen schon bekannt. Abstrakte Klassen dienen außerdem dazu, zwei oder mehrere Klassen zusammenzufassen, die zwar einige Gemeinsamkeiten besitzen, aber nicht unabhängig voneinander herzuleiten sind und wo es ist nicht offensichtlich ist, welche die Superklasse der anderen ist. In einer abstrakten Oberklasse können die Gemeinsamkeiten zusammengefasst werden.
5.4
Vererbung
Die Beziehung der ursprünglichen Klasse, der Superklasse, zur abgeleiteten, der Subklasse, ist immer streng hierarchisch und heißt Vererbung. Abgeleitete Klassen übernehmen die Eigenschaften und Methoden aller übergeordneter Klassen, wobei Übernehmen nicht bedeutet, dass eine Subklasse die Befehle und Eigenschaften der Superklasse in ihre eigene Deklaration kopiert. Statt dessen gibt es nur eine formale Verknüpfung zwischen den Klassen (eine Art von Zeiger). Mit anderen Worten: Die abgeleitete Klasse verwendet bei Bedarf die Methoden oder Eigenschaften der Superklasse. Den Mechanismus kann man sich analog dem Verwenden von Bibliotheken und dort implementierten Funktionalitäten vorstellen. Die Methoden- bzw. Eigenschaftenauswahl in einer Klassenhierarchie muss natürlich geregelt sein. Sie erfolgt nach einer einfachen Regel. Ist der Nachrichtenselektor (der Methodenname einer Botschaft) in der Objektklasse des Empfängers nicht vorhanden, so wird die gewünschte Methode oder Eigenschaft in der nächst höheren Superklasse des Nachrichtenselektors gesucht. Ist sie dort nicht vorhanden, erfolgt die Suche in der nächst höheren Klasse, bis die oberste Superklasse der Klassenbaums erreicht ist (bei Java die Klasse Object). Die Ausführung der Methode bzw. der Zugriff auf die Eigenschaft erfolgt also in der ersten Klasse, in der sie gefunden wird (von der aktuellen Klasse in der Hierarchie aufwärts gesehen). Gibt es im Klassenbaum keine Methode bzw. Eigenschaft des spezifizierten Namens, so kommt es zu einer Fehlermeldung. Klassen auf derselben Ebene oder in anderen Zweigen werden nicht durchsucht (siehe Abbildung 5.5). Subklassen werden ihre Erbschaft in der Regeln nicht unverändert lassen. Sie können mit ihren ererbten Eigenschaften und Methoden Einiges anstellen, wie beispielsweise: Attribute hinzufügen neue Methoden spezifizieren
Java 2 Kompendium
161
Kapitel 5
Java-Hintergründe vorhandene Methoden überladen geerbte Methoden ergänzen
Abbildung 5.5: Vererbung über mehrere Ebenen
5.4.1
Mehrfachvererbung
Der Begriff Mehrfachvererbung gehört zu einer Betrachtung der OOP einfach dazu, obwohl Java explizit auf Mehrfachvererbung verzichtet. Aus gutem Grund, wie man bei solchen Sprachen sieht, die Mehrfachvererbung realisiert haben (etwa C++). Bei der oben beschriebenen Vererbung gilt für die Klassenhierarchie in einer baumartigen Struktur die Voraussetzung, dass eine Subklasse immer nur genau eine Superklasse hat. Man nennt eine solche Struktur Einfachvererbung (Single Inheritance). Einige objektorientierte Programmiersprachen (beispielsweise C++) bieten jedoch die Möglichkeit, eine Klasse mit mehreren (bzw. beliebig vielen) Superklassen durch die Vererbung zu verknüpfen. Dies nennt man Mehrfachvererbung (Multiple Inheritance). Objekte der Subklasse erben Eigenschaften aus verschiedenen Superklassen. Es gibt unbestritten einige gute Gründe für die Mehrfachvererbung. Der entscheidende Vorteil der mehrfachen Vererbung liegt in der Möglichkeit, die Probleme der realen Welt einfacher beschreiben zu können, denn auch dort hat ein Objekt Eigenschaften und Fähigkeiten aus verschiedenen übergeordneten logischen Bereichen.
162
Java 2 Kompendium
Vererbung
Kapitel 5 Abbildung 5.6: Mehrfachvererbung
Ein Saxophon gehört nicht nur zu der Klasse der Holzblasinstrumente und diese wiederum zur Klasse der »Musik erzeugende Dinge«. Ein Saxophon kann man ebenso zur Superklasse der »Nervenden Krachmacher« – für Nachbarn :-) – und zusätzlich in gleicher Weise zur Superklasse der »Stress erzeugenden Ereignisse« – ebenfalls für Nachbarn und vor allem für Saxophonlehrer bei entsprechend begabten Schülern ;-) – zählen. Es erbt seine Eigenschaften aus den diversen Superklassen. Damit lässt sich das Beziehungsgeflecht des realen Objekts durch die Sammlung der Superklassen (relativ) vollständig beschreiben. Ein weiterer Vorteil ist, dass man leicht Dinge ergänzen kann, die man bei der ersten Realisierung einer Klasse vergessen hat. Wenn bestimmte Eigenschaften und Methoden in einer Subklasse vergessen wurden, nimmt man einfach eine weitere Superklasse hinzu, die die fehlenden Elemente vererben kann. Diese Vorteile einer relativ vollständigen und einfachen Abbildung der Natur stehen aber in keinem Verhältnis zu den damit eingekauften Nachteilen. Die schlimmsten Nachteile sind sicher die kaum nachvollziehbaren Beziehungsgeflechte in komplexeren Programmen. C++-Programmierer (vor allem diejenigen, die ein Programm übernehmen mussten) wissen davon ein Lied zu singen. Wartbarkeit wird bei exzessivem Einsatz der Mehrfachvererbung zum Fremdwort. Java arbeitet deshalb ohne Mehrfachvererbung. Dafür bietet Java einen ähnlich leistungsfähigen Mechanismus, der dennoch die Wartbarkeit erhält – das Konzept der Schnittstellen. Diese gehören aber weniger in die Abhandlung über die allgemeinene Begriff der OOP, sondern werden später an geeigneten Stellen ausführlich diskutiert.
Java 2 Kompendium
163
Kapitel 5
Java-Hintergründe
5.5
Überschreiben
Eine weitere fundamentale Möglichkeit der OOP ist das Überschreiben von bereits im Klassenbaum vorhandenen Methoden, um damit eine Spezialisierung von Objekten zu erreichen. Überschreiben (Overriding) bedeutet, dass bei Namensgleichheit von Methoden in Superklasse und abgeleiteter Klasse die Methoden der abgeleiteten Klasse die der Superklasse überdecken. Überschreiben heißt im Englischen eigentlich Overwriting. Overriding ist jedoch kein Schreibfehler, sondern es bedeutet im Grunde Überdefinieren, wird jedoch im Deutschen zum besseren (?) Verständnis als Überschreiben übersetzt. Aus der Regel für die Methodenauswahl in einer Klassenhierarchie (ist der Nachrichtenselektor in der Objektklasse des Empfängers nicht vorhanden, so wird die gewünschte Methode in der nächst höheren Superklasse des Nachrichtenselektor gesucht usw., also von unten nach oben) folgt ein solches Überschreiben-Konzept im Prinzip zwingend, denn eine Methode wird auf der Ebene ausgeführt, wo sie zuerst gefunden wird.
5.6
Polymorphismus
Wir haben bereits gesehen, dass Operationen in der OOP denselben Namen haben können, sogar, wenn sie auf dasselbe Objekte angewandt werden können, aber auch, wenn sie zu verschiedenen Objekte gehören. Dies hätte in der prozeduralen Welt mehrere unterschiedliche (auch namentlich) Operationen (Funktionen oder Prozeduren) zur Folge. Das Beispiel der Multiplikation machte es deutlich. Dabei ist es in der OOP nicht unbedingt notwendig, dass die verschiedenen Objekte, auf die die Operation angewandt wird, zur selben Klasse gehören. Auch auf Objekte, die zu unterschiedlichen Klassen gehören, lässt sich dieselbe Operation definieren. Immer wenn ein und dieselbe Operation sich verschieden auswirken kann und die konkrete Erzeugungsklasse irrelevant ist, wird dies Polymorphismus genannt. Wichtig ist, dass es dabei vollkommen unerheblich ist, ob diese Objekte durch Vererbung in Beziehung zueinander stehen oder nicht. Java ist polymorph.
164
Java 2 Kompendium
Binden
5.7
Kapitel 5
Binden
Es ist bereits angesprochen worden, dass Objekte gegenseitig per Botschaften in Kontakt treten. Die gerade angesprochenen Möglichkeiten des Polymorphismus und der Vererbung generieren aber ein gewisses Problem. Wie soll eine Nachricht die physikalische Adresse eines Objekts im Speicher finden? Durch Polymorphismus und Vererbung ist der Methodennamen (oft Selektor genannt) ja meist nur eine Verknüpfung zur physikalischen Implementierung (dem Programmcode) der Methode und nicht die Adresse des eigentlichen Speicherbereichs. Damit eine Nachricht die Ausführung einer Methode bewirken kann, muss allerdings irgendwann einmal (vor der Ausführung der Methode zur Laufzeit) eine Zuordnung zwischen dem Selektor und dem tatsächlichen Programmcode der Methode stattfinden. Diesen Vorgang der Zuordnung nennt man Binden oder Linken. Dabei unterscheidet man in der OOP zwei Formen des Bindens, die von dem Bindezeitpunkt abhängig sind: das frühe Binden und das späte Binden.
5.7.1
Frühes Binden
Frühes Binden (Early Binding oder oft statisches Binden genannt) bedeutet, dass ein Compiler schon zum Zeitpunkt der Übersetzung des Programms die tatsächliche physikalische Adresse der Methode dem Methodenaufruf zuordnet. Grundsätzlicher Vorteil ist, dass schon zur Zeit der Kompilierung fehlerhafte Angaben vom Compiler gefunden werden können. Außerdem sind solche früh gelinkten Programme schnell, da die physikalische Zieladresse eines Methodenaufrufs zur Programmlaufzeit schon festliegt und nicht immer wieder neu berechnet werden muss. Grö ß ter Nachteil des frühen Bindens ist die mangelnde Flexibilität bei interaktiven Aktionen, also wenn durch Aktionen – etwa durch einen Anwender – neue Objekte in einem Programm erzeugt und verwaltet werden müssen. Das klingt vielleicht abstrakt, ist jedoch in vielen Programmen notwendig. Denken Sie beispielsweise an Grafikprogramme, wo durch die diversen Zeichenoperationen permanent neue Instanzen von Objekten erzeugt werden können. Ein objektorientiertes Grafikprogramm kann unter anderem aus einer Anzahl von Klassen in einem Grafiksystem bestehen: Linie, Kreis, leeres Rechteck, gefülltes Rechteck usw. Jede dieser Klassen beinhaltet nun beispielsweise eine Methode zur Ausgabe der jeweiligen Figur auf dem Bildschirm. Gemeinsamkeiten dieser Zeichnen-Methoden sind sinnvollerweise in einer Superklasse definiert. Die konkreten Figuren befinden sich in Subklassen und erben die gemeinsamen Merkmale. Für die Verwaltung aller verwendeten Grafikobjekte werden oft so genannte Listen verwendet. Diese Listen könnten nun so aufgebaut sein, dass dabei Elemente einer Liste Verweise aufeinander enthalten. Die Struk-
Java 2 Kompendium
165
Kapitel 5
Java-Hintergründe tur ähnelt einer Kette. Jedes Element hat zusätzlich einen Verweis auf die konkrete Instanz eines Objekts. In einem Grafikprogramm erstellt der Benutzer nun interaktiv am Bildschirm seine Figuren. Beim Zeichnen eines neuen Objekts durch einen Anwender wird das Listenelement adressiert, eine Verknüpfung mit der Liste hergestellt und die Datenadresse der Instanz eingetragen. Das heißt, der Typ des Listenelements ist ein Verweis auf die Superklasse. Zur Laufzeit wird hier jedoch eine Referenz auf die Subklasse – das konkrete Zeichenobjekt – vermerkt. Zum Zeitpunkt der Kompilierung kann der konkrete Listenplatz von einem Objekt (etwa einem gefüllten Reckeck) und seinen Methoden nicht bekannt sein, da es ja noch nicht existiert. Also muss beim frühen Linken eine andere, umständliche Variante der Objektverwaltung verwendet werden.
5.7.2
Spätes Binden
Wenn das Linken nun später erfolgen würde, wäre das System bedeutend flexibler. Man nennt diesen Vorgang dann spätes Binden (Late Binding oder dynamisches Binden genannt). Der Begriff ist bereits bei den Eigenschaften von Java aufgetaucht, denn Java verwendet diesen Mechanismus. Hier wird erst zur Laufzeit eines Programms die tatsächliche Verknüpfung zwischen dem Selektor und dem Code hergestellt. Die richtige Verbindung übernimmt das Laufzeitsystem der Programmiersprache. Ein solches System ist viel leichter erweiterbar. Es muss nur bei einer Interaktion eine weitere Subklasse von der grafischen Superklasse und die zugehörige ZeichnenMethode definiert werden. Die Implementierung ändert sich nicht, da erst zur Laufzeit die Verbindung erfolgt. Damit nimmt man allerdings eine schlechtere Performance in Kauf. Außerdem steigt bei ungesicherten Entwicklungsumgebungen mit spätem Binden die Gefahr von Fehlern, da fehlende oder falsche Methodenaufrufe erst zur Laufzeit des Programms bemerkt werden. Für Java besteht allerdings keine Gefahr, denn dort wird explizit mit diversen Sicherheitsmechanismen beim Kompilieren und Linken dieses Problem beseitigt.
5.8
Die Grundprinzipien der objektorientierten Programmierung
Aus den bisherigen Ausführungen können wir jetzt die Grundprinzipien der OOP herleiten. Objekte heben die Trennung von Daten und Anweisungen auf. Objekte tauschen Nachrichten aus und reagieren darauf. Andere Kommunikationswege gibt es nicht.
166
Java 2 Kompendium
Objektorientierte Analyse und objektorientiertes Design
Kapitel 5
Subklassen erben Fähigkeiten und Eigenschaften der zugehörigen Superklasse. Subklassen können geerbte Fähigkeiten und Eigenschaften erweitern und verändern. Objekte erhalten ihre Fähigkeiten und Eigenschaften als Instanz einer konkreten Klasse. Wenn Objekte zu verschiedenen Klassen gehören, werden sie auf die gleiche Nachricht unterschiedlich reagieren (Polymorphismus).
5.9
Objektorientierte Analyse und objektorientiertes Design
Im Rahmen der objektorientierten Philosophie tauchen immer wieder zwei weitere Begriffe auf, die eng daran gekoppelt sind und zur Vorbereitung der OOP dienen – die objektorientierte Analyse (OOA) und das objektorientierte Design (OOD). Zwar sprengt eine ausführliche Darstellung dieser beiden vorbereitenden Techniken den Rahmen des Buchs, der Versuch einer kurzen Beschreibung ist der Vollständigkeit halber aber sicher sinnvoll.
5.9.1
Die objektorientierte Analyse
Unter einer Analyse versteht man eine gründliche Untersuchung eines Problems, bevor man versucht, das Problem zu lösen. Vereinfacht gesagt: Nachdenken, bevor man vollendete Tatsachen schafft, die ein Problem nicht optimal (im günstigsten Fall) oder gar nicht lösen. Die OOA ist nun eine – vielfach als sehr abgehoben und theoretisch bezeichnete – Technik, mit der eine solche Problemanalyse in der objektorientierten Welt in ein strukturiertes Konzept gefasst werden soll. Sie soll nur ganz kurz angerissen werden. Die OOA umfasst fünf Grundvorgänge: Die Suche und Festlegung von möglichst optimalen Klassen und Objekten zur Beschreibung des Problems Die Identifikation von relevanten Strukturen in der Problemstellung Die Identifikation von relevanten Subjekten in der Problemstellung Die Identifikation und Definition von Methoden Die Identifikation und Definition von Diensten
Java 2 Kompendium
167
Kapitel 5
Java-Hintergründe Es gibt sogar ein aus vier Ebenen bestehendes, sehr theoretisches Schichtenmodell für die OOA, das sich aus den genannten Grundvorgängen ableitet.
Tabelle 5.1: Das OOASchichtenmodell
Das OOA-Schichtenmodell 1
Klassen- und Objektschicht
2
Strukturschicht
3
Attributschicht
4
Serviceschicht
Die OOA steht in der Theorie der Softwareentwicklung immer am Anfang.
5.9.2
Das objektorientierte Design
Das OOD ist der mittlere Zyklus der Softwareentwicklung und wird nach der OOA durchgeführt. In der OOA wird das Problem analysiert und so aufbereitet, dass es nun im OOD für bestimmte Hard- und Softwareplattformen umgesetzt werden kann. Im OOD gibt es vier Grundvorgänge: Design einer Anwendungsgebiets-Komponente Design einer Benutzeroberflächen-Komponente Design einer Verarbeitungs-Komponente Design einer Datenmanagement-Komponente Unter der Berufssparte der OO-Designer werden wahrscheinlich die wenigsten Java-Freunde anzutreffen sein. Java ist durch die Plattformneutralität ein potenter Jobkiller für die Tätigkeit dieser hochspezialisierten OO-Designer. Oder unter Kostenaspekten positiv ausgedrückt: Java reduziert den Aufwand und damit die Kosten für den Mittelbau in der Softwareerstellung erheblich. Statt für diverse Plattformen zu designen, muss unter Java jeder OOD-Vorgang nur einmal durchgeführt werden. Wie dem auch sei, am Ende dieser beiden Prozesse steht dann die OOP.
168
Java 2 Kompendium
Die Objektorientierung von Java
5.10
Kapitel 5
Die Objektorientierung von Java
Java ist eine rein objektorientierte Sprache. Sie ist sogar eine äußerst strenge objektorientierte Sprache. Hier sollen kurz, d.h. ohne allzu ausführliche Diskussion der konkreten Java-Syntax, die wesentlichen Java-Konzepte erläutert werden.
5.10.1
Java-Klassen
Jedes Java-Programm besteht aus einer Sammlung von Klassen. Der gesamte Code, der bei Java verwendet wird, wird in Klassen eingeteilt. Jede Klasse, abstrakt oder nicht, definiert das Verhalten eines Objekts durch verschiedene Methoden. Verhalten und Eigenschaften können von der einen Klasse zur nächsten weitervererbt werden. Alle Klassen in Java haben eine gemeinsame Oberklasse, die Klasse Object. Diese wiederum verfügt nur über eine Metaklasse, aber damit bleibt das objektorientierte Konzept voll konsistent. Die Einteilung des Codes in Klassen bedarf einer näheren Erläuterung. Um Java möglichst einfach zu halten, gibt es eine Ausnahme, die jedoch geschickt in das Konzept eingepasst wurde. Boolesche Operatoren, Zahlen und andere einfache Typen sind in Java erst einmal keine Objekte. Aber Java hat für alle einfachen Typen so genannte Wrapper-Objekte implementiert. Ein Wrapper-Objekt ist eine spezielle Klasse, die eine Objektschnittstelle für die in Java vorhandenen primitiven Typen darstellt. Diese Wrapper-Objekte erlauben es, dass alle einfachen Typen wie Klassen verwendet werden können.
5.10.2
Polymorphismus und Binden
Java unterstützt die OO-Grundprinzipien Polymorphismus und das Konzept des Late Binding. Gerade das Late Binding trägt zur Sicherheit und Stabilität von Java erheblich bei.
5.10.3
Schnittstellen und Pakete statt Mehrfachvererbung
Obwohl Java streng objektorientiert ist, heißt das nicht, dass in Java alles, was in der OO-Theorie erlaubt ist, tatsächlich realisiert wurde. So unterstützt Java keine Mehrfachvererbung. Das erscheint zunächst als eine große Einschränkung, macht Java-Programme allerdings stabil und leicht wartbar. Der Verzicht auf Mehrfachvererbung erzwingt eine gründlichere Vorbereitung, bevor man losprogrammiert (oder feiner ausgedrückt – eine saubere objektorientierte Analyse). Hier bietet sich dann auch ein neues Beschäftigungsfeld für einige der OO-Designer, die Java um ihren Job gebracht hat. Es ist kaum zu zählen, wie viele Programme nur deshalb so schlecht wartbar Java 2 Kompendium
169
Kapitel 5
Java-Hintergründe und instabil sind, weil man sich am Anfang zu wenig Gedanken gemacht hat und bei fehlenden Funktionalitäten zu stricken angefangen hat. Unter Basic gab es dazu den berüchtigten GOTO-Befehl, andere Sprachen ließen die Implementierung fehlender Daten an beliebigen Stellen zu und bei C++ konnte mehr schlecht als recht einfach noch eine Superklasse hinzugefügt und dort die fehlenden Funktionalitäten untergebracht werden. Statt der Mehrfachvererbung gibt es unter Java einen anderen Mechanismus, der fast genauso flexibel, jedoch nicht so gefährlich ist. Es wird ein Schnittstellenkonzept verfolgt. Klassen können nicht nur von einer Superklasse erben, sondern auch eine beliebige Anzahl an Schnittstellen implementieren. Java-Schnittstellen sind wie die IDL-(Interface Description Language)Schnittstellen – ein Schnittstellenstandard zum Informationsaustauch verschiedener Programmiersprachen – aufgebaut. Eine Schnittstelle ist in der Java-Sprache eine Sammlung von Methodennamen ohne konkrete Definition. Obwohl eine einzelne Java-Klasse nur genau eine Superklasse haben kann (und genau eine haben muss!), können in einer Klasse mehrere Schnittstellen implementiert werden.
5.10.4
Überladen, Überschreiben und Überschatten
Bei diesen drei Begriffen handelt es sich um Grundfunktionalitäten der OOP, die für das Verständnis von Java absolut grundlegend sind. ÜBERLADEN von Methoden bedeutet, dass in einer Klasse mehrere Methoden mit identischem Namen definiert werden, die sich nur durch verschiedene Parameterlisten unterscheiden. Welche Methode dann vom Programm bei Aufruf angesprochen wird, hängt von der dort verwendeten Anzahl und dem Typ der Parameter ab. Java erlaubt zwar ein solches Überladen von Methoden, jedoch kein Überladen von Operatoren. Die Theorie der Objektorientierung erlaubt ein Überladen von Operatoren im Prinzip analog, jedoch unterstützt Java diesen Mechanismus nicht. Obwohl wir später noch auf das Überladen von Methoden zurückkommen, soll das nachfolgende kleine Programmbeispiel zwei innerhalb einer Klasse definierte Methoden mit gleichem Namen zeigen. Beide unterscheiden sich nur durch die Anzahl der Parameter. Listing 5.3: Überladen von Methoden
170
public class MeineKlasse() { public int meinemethode(int arg1) { int berechnung; berechnung = arg1 + 1; return berechung; } public int meinemethode(int arg1; int arg2) {
Java 2 Kompendium
Die Objektorientierung von Java
Kapitel 5
int berechnung; berechnung = arg1 + arg2; return berechung; } }
Überladen kann sich auch über Superklassen erstrecken. Wenn sich die verschiedenen Methoden mit gleichem Namen und unterschiedlichen Parameterlisten in verschiedenen, über Vererbung verbundenen Klassen befinden, funktioniert die Geschichte ebenso. Dies liegt im Wesentlichen daran, dass der Aufruf einer Methode in der Subklasse mit der Parameterliste der Methode aus der Superklasse dort keinen Erfolg hat und die Methode dann in der nächst höheren Ebene (der Superklasse) gesucht wird. Methoden, die mit dem Schlüsselwort static deklariert werden (Klassenmethoden), können nicht überladen werden. Der Mechanismus des Überladens von Methoden sollte nicht mit dem bereits beschriebenen ÜBERSCHREIBEN (Overriding) verwechselt werden, obwohl der Vorgang sehr ähnlich ist. Auch Überschreiben ist in Java möglich und erluabt eine Spezialisierung von Objekten. Es bedeutet ebenfalls, dass Methoden einer Subklasse die Methoden der Elternklasse komplett überschreiben. Der Unterschied zu Überladen ist mehr formeller als inhaltlicher Natur. Eine Methode zu überschreiben bedeutet, dass die Methode in der Subklasse den identischen Deklarationskopf (also neben der Namensgleichheit auch vollkommen identische Argumente) wie die Methoden der Superklasse erhält (Überschreiben funktioniert also nur zwischen einer Super- und einer Subklasse), während beim Überladen der Methoden zwar die Namen in Super- und Subklasse, aber nicht die Argumente identisch sind. Auch darf beim Überschreiben der Rückgabewert einer Methode nicht geändert werden. Das nachfolgende kleine Beispiel soll den Vorgang skizzieren: public class Superklasse() { public int supermethode(int Superarg1) { int berechnung; berechnung = Superarg1 + 1; return berechnung; } } public class Subklasse() extends Superklasse { public int supermethode(int Superarg1) { int berechnung; berechnung = Superarg1 + 2; return berechnung; } }
Java 2 Kompendium
Listing 5.4: Überschreiben von Methoden
171
Kapitel 5
Java-Hintergründe Die verdeckten Methoden einer Superklasse sind übrigens trotzdem immer noch zu verwenden. In Java macht dies das Schlüsselwort super möglich, also z.B. mit super.supermethode(3);. Die letzte der drei Überlagerungstechniken in Java ist das ÜBERSCHATTEN. Überschattet werden Variablen. Wenn eine Variable in einer Superklasse mit einem bestimmten Typ deklariert wird, so kann in der Subklasse durchaus eine Variable gleichen Namens (mit einem identischen oder auch abweichenden Typ) deklariert werden, die dann dort die Variable der Superklasse überlagert. Das nachfolgende Beispiel skizziert das Verfahren: class Superklasse() { int berechnung; } class Subklasse extends Superklasse { double berechnung; }
Der Zugriff auf die Variable der Superklasse kann unter anderem wieder mit dem Schlüsselwort super erreicht werden.
5.10.5
Globale Vereinbarungen
Als letzte gravierende (positive) Einschränkung verfügt Java nicht über die Möglichkeit, globale Konstanten, Variablen oder Funktionen zu definieren, was jedoch bei strenger Auslegung der OO-Theorie zwingend ist. Bezüglich der Konstanten gilt die Aussage aber nicht ganz so streng, wie sie im ersten Moment erscheint. Über Schnittstellen kann man Konstanten so festlegen, dass sie insofern als global verfügbar gelten, als dass jede Klasse diese Schnittstelle implementiert.
5.11
Zusammenfassung
Java ist explizit objektorientiert, ohne jedoch sämtliche Möglichkeiten des objektorientierten Konzeptes zu realisieren (etwa Verzicht auf Mehrfachvererbung und Überladen von Operatoren). Dieses Fehlen von einzelnen Bestandteilen steht jedoch in keinerlei Widerspruch zu den objektorientierten Paradigmen.
172
Java 2 Kompendium
Plattformunabhängigkeit von Java und die JVM
5.12
Kapitel 5
Plattformunabhängigkeit von Java und die JVM
Java ist sowohl eine Programmiersprache als auch Bestandteil eines modernen EDV-Systems, dessen wichtigster Bestandteil ein neues, vollkommen plattformunabhängiges Betriebssystem für ein nahezu unbeschränktes Einsatzfeld ist. Statt plattformunabhängig wird gerne der Begriff architekturneutral genommen, was jedoch dasselbe bedeutet. Eine erheblich grö ß ere Fehlertoleranz, eine leichtere Bedienbarkeit und eine bedeutend bessere Stabilität als bei bisherigen Betriebssystemen sind Charakteristika der JavaUmgebung. Java-Applikationen können auf Rechnern unterschiedlichster Konfiguration laufen, sogar auf sämtlichen elektrischen Geräten, die irgendwelche Daten verarbeiten sollen. Denken Sie nur an Videorecorder, die bereits seit geraumer Zeit (mehr schlecht als recht) zu programmieren sind. Java erlaubt es, die Zahl und Funktionalität der Geräte auszudehnen. Vorstellbar sind Kaffeemaschinen, die von unterwegs aus dem Auto heraus per Internet gestartet werden, sodass der Kaffee in dem Moment fertig ist, wenn man zur Tür hereinkommt. Es gibt die verschiedensten Anwendungsmöglichkeiten für Java. Der Zukunftsmarkt ist auf Grund der Plattformunabhängigkeit gigantisch. Wie realisiert nun Java diese Plattformunabhängigkeit? Java ist sowohl auf der so genannten Quellebene, als auch der Binärebene plattformunabhängig. Beschäftigen wir uns zunächst mit der binären Plattformunabhängigkeit.
5.12.1
Die binäre Plattformunabhängigkeit von Java
Bevor eine Java-Anwendung oder ein Java-Applet ausgeführt werden kann, muss der Java-Quellcode in so genannten Bytecode kompiliert werden. Dies erledigt der Java-Compiler, wie wir bereits mehrfach gesehen und angewendet haben. Der daraus resultierende Bytecode ist binär, aber immer noch architekturunabhängig. Der Preis dafür ist, dass dieser Bytecode nicht vollständig und noch nicht lauffähig ist. Bytecode kann man sich als eine Reihe von binären Anweisungen vorstellen, die zwar wie Maschinencode aussieht, jedoch im Gegensatz dazu nicht spezifisch an den Befehlssatz eines bestimmten Prozessors gebunden ist. Diese konkreten Anweisungen fehlen noch. Das daraus resultierende Problem ist dann natürlich, dass Java-Bytecode keine expliziten Prozessorbefehle enthalten kann. Java-Bytecode wird deshalb gelegentlich als ein architekturneutrales Object-Codeformat bezeichnet. Schauen wir uns den Fall an, wenn beim Kompilieren von Quellcode bereits auf einem Prozessor lauffähiger Code entsteht. Beim Kompilieren eines in einer Sprache wie PASCAL oder C/C++ geschriebenen Quelltextes entsteht
Java 2 Kompendium
173
Kapitel 5
Java-Hintergründe ein solcher maschinenabhängiger Code, dessen Anweisungen vom jeweiligen Zielprozessor direkt interpretiert werden können. Den Unterschied zu Java-Bytecode kann man sich über die Mengenlehre verdeutlichen. Lauffähiger Maschinencode ist eine nicht deckungsgleiche Obermenge von Bytecode. Der noch fehlende Teil muss bei Bytecode also noch irgendwie hinzugefügt werden. Dies übernimmt die virtuelle Maschine. Da der Java-Bytecode wie gesagt noch nicht direkt den Befehlssatz eines Prozessors steuern kann, benötigt er einen prozessorabhängigen Container, eine Java-Laufzeitumgebung. Aus diesem Grund verfügt Java immer über einen Java-Interpreter. Der Bytecode ist innerhalb dieser Java-Laufzeitumgebung lauffähig und wird von dieser interpretiert. Erst hier werden die plattformabhängigen Befehle hinzugebunden. Die jeweilige Laufzeitumgebung ist plattformspezifisch und kennt den Befehlssatz des jeweiligen Prozessors, also arbeitet das endgültige Produkt auf dieser spezifischen Plattform. Java-fähige Browser sind beispielsweise solche plattformspezifischen Java-Laufzeitumgebungen, die erst die Verwendung von Java-Applets auf den unterschiedlichsten Plattformen des WWW ermöglichen.
5.12.2
Die JVM-Architektur
Die Interpretation des Java-Bytecodes basiert, wie bereits angedeutet, auf der Definition einer so genannten virtuellen Maschine (Java Virtual Machine, abgekürzt JVM), einem virtuellen Computer, der nur im Speicher eines Rechners zur Laufzeit resistent ist und der vom Bytecode gesteuert wird. Man nennt einen solchen Prozess oft eine Emulation. Die JVM wird gerne als Herz von Java gesehen und muss auf jedem Rechner vorhanden sein, der Java-Anwendungen ausführen möchte. Die virtuelle Maschine stellt eine Abstraktionsschicht zwischen dem kompilierten Programm, der zugrunde liegenden Hardwareplattform und dem Betriebssystem dar und realisiert die gerade beschriebene Umsetzung des Bytecodes in ausführbare Prozessorbefehle. Die virtuelle Maschine kümmert sich anderseits auch um grundlegende Java-Operationen wie die Objekterstellung und die Müllbeseitigung (Garbage Collection, sprich die Speicherfreigabe mit einer Papierkorbfunktion). Wir beziehen uns hier im Wesentlichen auf die JVM von Sun bzw. JavaSoft. Es gibt aber noch andere JVMs von weiteren Herstellern, die nicht unbedingt voll kompatibel sein müssen und sich vom Aufbau her unterscheiden können. Die wichtigsten Punkte werden jedoch übereinstimmen. Die JVM ist sehr kompakt und verbraucht wenig RAM-Speicherplatz. Sie soll ja in beliebige elektronische Geräte passen. Konkret läuft der Prozess 174
Java 2 Kompendium
Plattformunabhängigkeit von Java und die JVM
Kapitel 5
vom Java-Sourcecode zum lauffähigen und architekturneutralen Java-Programm wie folgt ab: 1.
Eine Java-Sourcedatei wird erstellt und in der Regel unter dem Namen ihrer öffentlichen Klasse mit der Erweiterung .java gespeichert.
2.
Der Java-Compiler liest die Dateien mit der Erweiterung .java ein und konvertiert den Java-Sourcecode in Bytecode. Die resultierende Bytecode-Datei bekommt den gleichen Namensstamm, jedoch die Erweiterung .class.
3.
Die JVM liest den Bytecode-Datenstrom aus der .class-Datei als Folge von Anweisungen (der so genannte Bytecode-Strom). Dieser Strom von Anweisungen hat immer die gleiche Struktur. Jede Anweisung beginnt mit einem opcode (Operationscode). Dieser ist ein Bit lang und ein spezifischer und wieder erkennbarer Befehl. Auf Grund der Länge kann er nur null (keine weiteren Operanden) oder ungleich null (mehrere Operanden, mit denen der opcode vervollständigt werden muss, folgen) sein. Der opcode instruiert die virtuelle Maschine, was genau zu tun ist. Wenn die JVM mehr als nur den opcode für die Ausführung einer Aktion benötigt, ist dieser wie gesagt ungleich null und es folgt dem opcode ein oder mehrere Operand(en).
Die JVM besteht aus vier Teilen: 1.
Stack
2.
Register
3.
Garbage Collection Heap
4.
Methodenbereich
Gelegentlich wird die JVM auch in fünf Basisteile untergliedert: 1.
Bytecode-Anweisungen
2.
Stack
3.
Register
4.
Heap
5.
Methodenbereich
Manche Quellen nehmen also die Bytecode-Anweisungen direkt in die Gliederung mit auf, was jedoch keinen wesentlichen Unterschied ausmacht. Schauen wir uns die Details genauer an. Zuerst soll der Java-Stack betrachtet werden. Die virtuelle Maschine basiert im Wesentlichen auf diesen Stacks. Unter einem Stack versteht man einen Befehlsstapel. Der Rahmen
Java 2 Kompendium
175
Kapitel 5
Java-Hintergründe eines Java-Stacks ist mit dem Stack in herkömmlichen Programmiersprachen durchaus vergleichbar. Er enthält den Zustand eines Methodenaufrufs und den Zustand von verschachtelten Methodenaufrufen. Da die JVM primär auf Stacks basiert, werden die Parameter in der virtuellen Maschine dort gespeichert. Das Weitergeben und Empfangen von Argumenten läuft in der JVM immer über den Stack. Ein Stack in Java dient also der Bereitstellung von Parametern für Bytecodes und Methoden zum Aufnehmen der Ereignisse. Die Grö ß e einer Adresse in der JVM beträgt immer 4 Byte, also 32 Bit. Deshalb können bis zu 4 Gigabyte Speicher adressiert werden (2 hoch 32, also 4.294.967.296 Bit). Die oben genannten Komponenten der JVM (der Stack, der Garbage Collection Heap und der Methodenbereich) befinden sich innerhalb dieser 4 Gigabyte. Die Java-Methoden sind auf 32 Kilobyte als Grö ß e für jede einzelne Methode beschränkt. Alle Prozessoren benötigen für ihre Funktionalität so genannte Register. Register beinhalten einen Zustand eines Computers, beeinflussen den Betrieb und werden nach jeder Ausführung von Befehlen aktualisiert. Die virtuelle Maschine von Java verwaltet den System-Stack mit den folgenden Registern: pc (Program Counter): Ein Programmzähler, der verfolgt, wo genau das Programm sich in der Ausführung befindet, d.h. welcher Bytecode gerade ausgeführt wird. Weiter enthält der Programmzähler die Adresse des Bytecodes, der als nächstes ausgeführt werden soll. Zusätzlich wird das pc-Register dafür verwendet, wenn Ausnahmen und catch-Klauseln abgearbeitet werden. optop: Ein Zeiger oder Pointer, der auf die Spitze des Operanden-Stack zeigt. Er dient im Wesentlichen zur Auswertung arithmetischer Ausdrücke. frame: Ein Pointer, der auf die aktuelle Ausführungsumgebung der gerade ausgeführten Methode zeigt. Dieser Pointer enthält einen Aktivierungsdatensatz für den Aufruf dieser Methode und diverse Debugging-Informationen. vars: Ein weiterer Pointer, der auf die erste lokale Variable der aktuell ausgeführten Methode zeigt. Weitere Register verwendet Java nicht. Die JVM gebraucht dementsprechend nur vier Register mit der Länge eines Bytes, simuliert also einen Prozessor mit einem 32-Bit-Register. Aus diesem Grund benötigen die primitiven Datentypen double und long durch ihre Datenbreite von 64 Bit jeweils zwei Positionen auf dem Operanden-Stack (jeweils 32 Bit groß) zur Darstellung.
176
Java 2 Kompendium
Plattformunabhängigkeit von Java und die JVM
Kapitel 5
Von dem Java-Programm wird der Bytecode an die JVM weitergegeben und erzeugt einen Stack-Frame für jede Methode. Jeder Frame enthält drei Arten von Informationen – die lokalen Variablen für den Methodenaufruf, die Ausführungsumgebung und den Operanden. Diese jeweiligen Datenmengen können unter Umständen auch leer sein. Die Grö ß e der ersten beiden Elemente steht zu Beginn eines Methodenaufrufs fest, während die Grö ß e des Operanden bei der Ausführung des Bytecodes der Methode variieren kann. Die lokalen Variablen: Sie werden in einem Array von 32-Bit-Variablen gespeichert, auf die von dem vars-Register gezeigt wird (im Word-Offset). Die Ausführungsumgebung: In der Ausführungsumgebung (Execution Environment) eines Stacks wird die Methode ausgeführt. Das frameRegister zeigt auf die Ausführungsumgebung. In der Ausführungsumgebung ist ein Pointer auf den vorherigen Stack, ein Pointer auf die lokale Variable des aktuellen Methodenaufrufs und je ein Pointer auf das momentane obere und untere Ende des Stacks im Speicher enthalten. Diese Informationen können neben einigen weiteren Hinweisen gut zum Debugging genutzt werden. Besonders für das dynamische Linken ist die Ausführungsumgebung wichtig, denn erst durch die Referenzen auf die Symboltabellen des Interpreters für die aktuelle Methode und die aktuelle Klasse wird dieses erst ermöglicht. Der Operanden-Stack: Er arbeitet nach dem FIFO-(First-in, First-out)Prinzip und ist 32 Bit groß. Verwendet wird er zum Speichern der Parameter und Rückgabewerte der meisten Bytecode-Anweisungen und er enthält noch weitere Argumente, die für den opcode notwendig sind. Jeder primitive Java-Datentyp hat eindeutige Anweisungen, wie er sich beim Herausziehen, Verwenden und Zurückschieben der Operanden des jeweiligen Typs zu verhalten hat. Die Typen in einem Stack und deren Anweisungen müssen kompatibel sein, was unter Java natürlich sicher gestellt ist. Die Spitze des Operanden-Stack wird von dem optopRegister indexiert und ist in der Regel mit der Spitze des gesamten JavaStacks identisch. Der Garbage Collection Heap oder auch nur Heap (Haufen) ist derjenige Teil des Hauptspeichers, dem neu erstellte Klasseninstanzen (Objekte) zugewiesen werden. Jedesmal wenn ein neues Objekt erstellt wird, kommt dieser Speicher aus dem Heap. In Java hat der Heap meist eine feste, voreingestellte Grö ß e, sobald das Java-Laufzeitsystem gestartet wird. Bei Computersystemen, wo die Technik des virtuellen Speichers (also Auslagerung von Hauptspeicher auf die Festplatte bei Bedarf) unterstützt wird (etwa Windows), kann die Grö ß e des Heap entsprechend ausgedehnt werden. Die Freigabe des Heap, wenn ein Objekt nicht mehr benötigt wird, übernimmt ein automatischer Prozess, der Garbage Collection (automatische Speicherbereinigung) genannt wird.
Java 2 Kompendium
177
Kapitel 5
Java-Hintergründe Diese Speicherbereinigung mit der Garbage Collection erleichtert die Arbeit mit Objekten gegenüber vielen anderen objektorientierten Sprache erheblich. Da in Java Objekte einer automatischen Müllbereinigung unterliegen, braucht sich ein Programmierer normalerweise nicht darum zu kümmern und den Speicher nicht mehr – wie etwa unter C/C++ oder Delphi – manuell freigeben. Eine manuelle Speicherfreigabe ist unter Java sogar gar nicht vorgesehen, Sie können höchstens den Garbage-Collection-Prozess direkt aufrufen. Jedoch ist dies in den meisten Fällen nicht notwendig und auch nicht zu empfehlen. Die Laufzeitumgebung verfolgt alle Referenzen auf ein Objekt in dem Heap und gibt automatisch den Speicher frei, der von Objekten belegt wird, die nicht mehr länger referenziert werden, sobald die CPU dafür Kapazität frei hat. Auf Java-Objekte wird zur Laufzeit nur indirekt über so genannte Handles – eine Art Pointer auf den Heap – zugegriffen. Deshalb können Bereinigungsprozesse parallel ablaufen. Diese laufen als eigener Thread ab und können nach eigenem Gutdünken (der JVM) Objekte löschen oder verschieben. Speicherbereinigungen laufen also in der Regel als ein permanenter Hintergrundthread ab. Die JVM verfügt neben den bereits diskutierten Speicherbereichen über zwei weitere Speicherbereiche, die als Methodenbereich von Java bezeichnet werden: Der eigentliche Methodenbereich Der Constant Pool (Konstantenpool) Wie bei konventionell kompilierten Programmen speichert der eigentliche Methodenbereich bei Java die Java-Bytecodes. Zusätzlich werden dort die zum dynamischen Verknüpfen benötigten Symboltabellen und andere Informationen (etwa Debug-Informationen) gespeichert. Der Constant Pool existiert in Java als ein an jede Klasse angehängter Heap. Diese normalerweise vom Java-Compiler erzeugten Konstanten codieren alle Namen (von Methoden, Variablen usw.), die von einer Methode der jeweiligen Klasse verwendet werden. Die Grö ß e des Constant Pool differiert je nach Anzahl der zu kodierenden Namen für jede Klasse. Die Klasse »weiß « um die Menge der Konstanten und spezifiziert mit einem Symbol, wo in der Klassenbeschreibung das Konstanten-Array beginnt. Die Konstanten werden mit speziell codierten Bytes typisiert und haben innerhalb der .class-Datei ein genau definiertes Format. Es gibt in Java keine Begrenzung, ab wo und bis wohin diese beiden Speicherbereiche existieren müssen. Damit wird die JVM portabler und sicherer.
178
Java 2 Kompendium
Plattformunabhängigkeit von Java und die JVM
5.12.3
Kapitel 5
Die Datentypen der JVM
Java-Datentypen unterscheiden sich in einigen Details von gewohnten Datentypen aus vielen anderen Programmiersprachen. Im Wesentlichen unterscheiden sie sich in der Länge (besonders auffällig ist der char-Typ, der nicht wie sonst meist üblich aus einem Byte besteht), aber auch in ein paar weiteren Einzelheiten. Die JVM verarbeitet im Detail die folgenden Typen primitiver Daten: Typ
Länge
Kurzbeschreibung
byte
8 Bit
Kleinster Wertebereich mit Vorzeichen. Wird zum Darstellen von Ganzzahlwerten von (- 2 hoch 7 = -128) bis (+ 2 hoch 7 – 1 = 127) verwendet.
short
16 Bit
Wertebereich mit Vorzeichen. Kurze Darstellung von Ganzzahlwerten von (- 2 hoch 15 = – 32768) bis (+ 2 hoch 15 – 1 = 32767).
int
32 Bit
Standardwertebereich mit Vorzeichen zur Darstellung von Ganzzahlwerten. Bereich von (- 2 hoch 31 = – 2147483648) bis (+ 2 hoch 31 – 1 = 2147483647).
long
64 Bit
Größter Wertebereich mit Vorzeichen zur Darstellung von Ganzzahlwerten. Bereich von (- 2 hoch 63 = – 9,223372036855e+18) bis (+ 2 hoch 63 – 1 = 9,223372036855e+18 – 1).
float
32 Bit
Kürzester Wertebereich mit Vorzeichen zur Darstellung von Gleitkommazahlwerten. Es existiert ein Literal zur Darstellung von plus/minus unendlich, sowie der Wert NaN (Not a Number) zur Darstellung von nicht definierten Ergebnissen.
double
64 Bit
Größter Wertebereich mit Vorzeichen zur Darstellung von Gleitkommazahlwerten. Es existiert wie beim Typ float ein Literal zur Darstellung von plus/minus Unendlich, sowie der Wert NaN (Not a Number) zur Darstellung von nicht definierten Ergebnissen.
char
16 Bit
Vorzeichenlose Darstellung eines Zeichens des UnicodeZeichensatzes.
boolean
1 Bit
Kann nur die Werte true (wahr) oder false (falsch) annehmen.
Tabelle 5.2: Primitive Datentypen der JVM von Sun
Falls Sie bereits Kenntnisse in anderen Programmiersprachen haben, fällt Ihnen vielleicht auf, dass in der Liste der primitiven Datentypen keine Arrays vorhanden sind. Dies liegt daran, dass Arrays in Java als Objekte gesehen werden und keine eigene Darstellung besitzen. Dies ist übrigens ein nicht zu unterschätzender Sicherheitsaspekt von Java.
Java 2 Kompendium
179
Kapitel 5
Java-Hintergründe Es gibt – wie schon angedeutet – virtuelle Maschinen, die nicht von Sun stammen (etwa von Microsoft). Einige dieser anderen virtuellen Maschinen besitzen noch zwei weitere Datentypen:
Tabelle 5.3: Optionale primitive Datentypen einiger JVM
Typ
Länge
Kurzbeschreibung
object
32 Bit
Referenz auf eine Java-Instanz.
returnAddress
32 Bit
Wert mit Anweisungen für die Befehle jsr/ret/jsr_w/ret_w.
5.12.4
Die Java-Plattformunabhängigkeit auf Quellebene
Plattformunabhängigkeit auf Quellebene bedeutet, dass die primitiven Datentypen einer Programmiersprache konsistente Grö ß en auf allen Entwicklungsplattformen haben. Wenn ein primitiver Datentyp wie beispielsweise ein Integer-Wert unter der einen Plattform die Grö ß e von einem Byte hätte, unter einer anderen Plattform die Grö ß e von zwei Byte, wäre die Plattformunabhängigkeit auf Quellebene nicht mehr gegeben. Bei fast allen anderen Programmiersprachen gibt es diese Probleme. Java hingegen enthält umfangreiche Klassenbibliotheken, um Standards für Datentypen festzulegen und damit das Schreiben von Code für verschiedene Plattformen überflüssig zu machen. In Java wird die Grö ß e jedes einfachen Datentyps in den umfangreichen Klassenbibliotheken genau spezifiziert. Genauso wichtig ist jedoch auch die Arithmetik, d.h. wie sich diese einfachen Datentypen gegenüber Berechnungsvorschriften verhalten. Auch hier legt Java in den Klassenbibliotheken genaue Vorschriften fest. Fast alle wichtigen Prozessoren unterstützen diese Java-Spezifikation und außerdem enthalten die Java-Bibliotheken portierbare Schnittstellen für die wichtigsten Plattformen in der Computerwelt. Damit wird – bis auf ganz wenige Ausnahmen – eine nahezu perfekte Plattformunabhängigkeit auf Quellebene gewährleistet.
5.13
Zusammenfassung
In diesem Kapitel haben wir für das Verständnis von Java unabdingbare Hintergründe besprochen, insbesondere das Konzept der objektorientierten Programmierung. Objektorientierung hebt die Trennung von Daten und Anweisungen auf. Dabei tauschen Objekte Nachrichten aus und reagieren darauf. Klassen und daraus erzeugte Objekte erben Fähigkeiten und Eigenschaften der zugehörigen Superklasse, und Subklassen können geerbte Fähigkeiten und Eigenschaften erweitern und verändern. Dabei erhalten die Objekte ihre Fähigkeiten und Eigenschaften durch Zugehörigkeit zu der
180
Java 2 Kompendium
Zusammenfassung
Kapitel 5
Klasse, aus der sie als Instanz erstellt werden. Wenn Objekte zu verschiedenen Klassen gehören, werden sie auf die gleiche Nachricht unterschiedlich reagieren (Polymorphismus). Grundsätzlich ist Java eine äußerst strenge objektorientierte Sprache, schränkt aber das denkbare Maximum in den Bereichen ein, wo es sinnvoll ist.
Java 2 Kompendium
181
Java – die Hauptbestandteile der Sprache
6
Wir haben nun viele Vorbereitungen getroffen und wollen zu den wichtigsten Bestandteilen von Java selbst kommen. Dabei sollen in diesem umfangreichen Kapitel – es wird unser dickster Brocken in dem Buch – die folgenden Themenschwerpunkte behandelt werden: Token Typen Ausdrücke Anweisungen Klassen Schnittstellen Pakete Dieses Kapitel wird nicht nur umfangreich, sondern leider auch recht theoretisch. Dies lässt sich nicht ganz vermeiden. Da müssen Sie durch. Dies ist aber sicher nicht Java-spezifisch, sondern trifft auf jede Programmiersprache zu. Damit das Kapitel aber nicht ausschließlich Theorie beinhaltet, werden wir einige Beispiele angehen. Diese Beispiele verwenden am Anfang gelegentlich Java-Techniken, die Ihnen unter Umständen noch nicht vertraut sind oder bis zu der jeweiligen Stelle noch nicht explizit eingeführt wurden. Dies betrifft beispielsweise Schleifen, die eine Wiederholung von Programmschritten erlauben. Wir werden etwa die for-Schleife an mehreren Stellen benutzen. Es ist bei diesen Beispielen jedoch nicht unbedingt erforderlich, dass Sie die Syntax zu diesem Zeitpunkt schon vollständig verstehen. Die Verwendung der etwas weitergehenden Java-Techniken dient nur dazu, die Beispiele interessanter zu gestalten und das eigentliche Ziel des Beispiels in einen passenden Kontext zu setzen.
6.1
Token
Token bedeutet übersetzt Zeichen oder Merkmal. Wenn ein Compiler eine lesbare Datei in Maschinenanweisungen übersetzt, muss er zunächst herausfinden, welche Token oder Symbole im Code dargestellt sind. Ein Token kann man als Sinnzusammenhang verstehen. So ist etwa in der menschliJava 2 Kompendium
183
Kapitel 6
Java – die Hauptbestandteile der Sprache chen Sprache ein Wort nicht nur die Summe seiner Buchstaben oder Zeichen, sondern besitzt einen konkreten Sinnzusammenhang, den das interpretierende System (der menschliche Geist) mit einer bestimmten Bedeutung assoziiert. Allerdings muss das interpretierende System auch die Sprache verstehen, sonst bleibt ein Token einfach nur die Summe seiner Buchstaben oder Zeichen. Beispiel: Jeder gute Hesse wird aus der Summe der Zeichen B,e,m,b,e,l sofort den Sinn erfassen und mit dem Token Bembel einen Krug für Apfelwein (und vielleicht laue Sommernächte in einer Äpplerkneipe und den nachfolgenden Kater am nächsten Morgen) assoziieren, während die Summe der Zeichen B,e,m,b,e,l für die meisten Norddeutschen wahrscheinlich einfach nur eine bedeutungslose Aneinanderreihung von Zeichen bleibt. Wenn von dem Java-Compiler der Quellcode kompiliert werden soll, muss er ihn dabei in einzelne kleine Bestandteile (Token) zerlegen. Quelltext muss sich dabei in logisch sinnvolle Einheiten zerlegen und in gültige Arten von Token einordnen lassen. Die Sprachelemente werden auf ihre Richtigkeit geprüft. Außerdem werden Leerzeichen und Kommentare aus dem Text entfernt. Dieser Teil der Übersetzung eines Quelltextes zum Bytecode wird von dem so genannten Parser übernommen. An der Stelle des Parsers greift auch die erste Kontrolleinheit des Sicherheits- und Stabilitätskonzepts von Java. Wenn in einem Quelltext einem Token Ganzzahl (ein Variablenbezeichner) der Datentyp short zugeordnet ist (eine 16-Bit-Zahl), dann erkennt der Compiler den Token jedes Mal, wenn es in diesem Zusammenhang benutzt wird, und benutzt die spezifisch zugeordneten 16 Bits des Speichers. Alle Operationen mit Ganzzahl werden mit dem spezifischen Wert, der in dieser 16-Bit-Adresse enthalten ist, durchgeführt. Also nicht mit den Buchstaben des Tokens selbst, sondern mit dem, was der Compiler mit dem Token »assoziiert«. Es gibt in Java fünf Arten von Token:
184
1.
Bezeichner oder Identifier
2.
Schlüsselworte
3.
Literale
4.
Operatoren
5.
Trennzeichen
Java 2 Kompendium
Token
Kapitel 6
Diese Einteilung in fünf Tokenarten gibt es übrigens für die meisten anderen Computersprachen analog. Kommentare oder Leerraum (Leerzeichen, Tabulatoren und Zeilenvorschübe) sind in der Aufzählung nicht enthalten, aber sie existieren natürlich ebenfalls, werden sozusagen als selbstverständlich vorausgesetzt. Technisch gesehen sind sie sogar eigentlich keine Token (wie man beispielsweise daran erkennen kann, dass sie vom Compiler entfernt werden).
6.1.1
Der Unicode-Zeichensatz
Java benutzt auf Quelltextebene keinen 8-Bit-ASCII-Code, sondern den 16-Bit-Unicode-Zeichensatz. Damit können zusätzlichen Zeichen kodiert werden, die nicht im lateinischen/englischen Alphabet enthalten sind. Zeichenketten nehmen zwar doppelt so viel Platz ein, jedoch wird die Internationalisierung leichter. Es gibt dort sogar ein Zeichen für den Euro1. Die Unicode-Spezifikation ist ein zweibändiger Listensatz mit zig Tausenden von Zeichen. Sie werden sicher einsehen, dass ein Auflisten der Zeichen zwar das Buch füllen, Ihnen jedoch nicht viel nützen würde. Da jedoch die ersten 256 Zeichen dem normalen ASCII-Zeichensatz entsprechen (Byte 1 ist auf 0 gesetzt), brauchen Sie sowieso normalerweise darauf kaum Rücksicht zu nehmen. Sie können einfach wie bisher die Zahlen und Buchstaben für Variablen-, Methoden- oder Klassennamen verwenden. Eine ASCIICodierung wird einfach durch eine kanonische Übersetzung (d.h. die Reihenfolge und Anordnung der ASCII-Codierung ist auch in der neuen Codierung als Block wiederzufinden) mit Voranstellen der Zeichenfolge \u00 und folgender Hexadezimalzahl in das dazu passende Unicode-Zeichen übersetzt. Dies definiert in Java eine Escape-Sequenz, mit der alle Unicode-Zeichen verschlüsselt werden können. Sobald die Unicode-Sequenz beendet ist, werden die folgenden Zeichen nahtlos angefügt. Durch die mögliche Unicode-Escape-Darstellung von Zeichen im Quelltext ist es in Java im Gegensatz zu anderen Programmiersprachen erlaubt, Umlaute und andere Sonderzeichen in Bezeichnern zu verwenden. Dabei kann die Angabe dieser Sonderzeichen (und natürlich auch gewöhnlicher Zeichen) sowohl direkt als auch über Angabe der Escape-Sequenz erfolgen. Alle Literale (d.h. alle vorkommenden Zeichen wie Buchstaben, Zahlen, Sonderzeichen usw.) in Java bestehen aus Unicode. Das JDK-Tool native2unicode übersetzt bei Bedarf 8-Bit-Native-Code in Unicode. Der Java-Compiler erwartet auf jeden Fall Unicode, jedoch müssen Sie sich bei der Arbeit mit einem gewöhnlichen ASCII-Editor darum meistens nicht kümmern. Vor der Kompilierung wird der Quelltext vom Compiler als Ers1
Bemerkenswert, weil ihn doch niemand außer Politikern will ;-).
Java 2 Kompendium
185
Kapitel 6
Java – die Hauptbestandteile der Sprache tes automatisch in eine Folge von Unicode-Zeichen transformiert. Erst nach der Transformation erfolgt dann die eigentliche Kompilierung. Zwei Bezeichner gelten in Java dann und nur dann als identisch, wenn ihre Unicode-Darstellung übereinstimmend ist. Dies ist auch der Grund, warum in Java unbedingt zwischen Groß- und Kleinschreibung zu unterscheiden ist. Die beiden folgenden Bezeichner sind also identisch: float Übung; float \u00DCbung;
Wenn Sie nun der vollständige Unicode-Zeichensatz doch interessiert, so nutzen wir Java und schreiben ein kleines Programm, das diesen – zumindest teilweise – ausgibt. Auch hier werden wir noch nicht zu detailliert auf die Syntax eingehen, aber doch schon ein wenig erläutern, was in dem Programm passiert. Wir verwenden hier zum ersten Mal eine Schleife. Für Sie sollte an der Stelle nur wichtig sein, dass sie die Anweisungen in dem zugeordneten Block so oft wiederholt, wie es in der Schleife angegeben ist. Geben Sie den nachfolgenden Quelltext ein.
Listing 6.1: Ausgabe von Unicodezeichen
/* Beispielprogramm zur Bildschirmausgabe vom ASCII- bzw. Unicode-Zeichensatz */ class Unicode { public static void main (String args[]) { int i; for(i=0; i < 1500;i++) System.out.print((char)i); } }
Speichern und kompilieren Sie das Programm.
Starten Sie das Programm. Wenn Sie das Programm eingeben, speichern (unter dem Namen Unicode.java), kompilieren und dann mittels des java-Interpreters ausführen, bekommen Sie auf dem Standardausgabegerät (meist der Bildschirm) die bekannten Zeichen des ASCII-Codes und dann einen Teilbereich des Unicode-Zeichensatzes ausgegeben (viele, viele Fragezeichen, d.h. noch nicht definiert).
186
Java 2 Kompendium
Token
Kapitel 6 Abbildung 6.1: Zeichen des Unicode-Zeichensatzes
Das Programm hat eine ähnliche Struktur wie unser HelloJava-Programm. Es besteht nur aus einer Methode, der main()-Methode, die jedes eigenständige Java-Programm benötigt. Sie erinnern sich vielleicht, dass jede Klasse, die in dem Aufruf durch den Klassennamen spezifiziert wird, eine Methode namens main() (public static void main(String args[])) benötigt. Der Interpreter java endet nach der vollständigen Abarbeitung von main(). Innerhalb der main()-Methode finden Sie wie bei unserem HelloJava-Programm eine Methode zur Ausgabe auf dem Standardausgabegerät – System.out.print(). Der Unterschied zu System.out.println() ist der, dass in hier kein Zeilenvorschub nach der Ausgabe jedes Zeichens erfolgt. Eine weitere Änderung innerhalb der Methode System.out.print() ist offensichtlich. Es wird kein Text in Hochkommata eingeschlossen ausgegeben, sondern mit (char)i eine Variable. Dabei ist i die vorher mit int i; eingeführte Zählvariable einer Schleife (der for-Schleife), die von 0 bis kleiner 1500 zählt. Würden wir nun nur diese Zählvariable innerhalb der Methode System.out.print() notieren, würde auf dem Standardausgabegerät eine Zahlenkolonne von 0 bis 1499 ausgegeben. Da wir das nicht wollten, muss der numerische Wert in das zugehörige Zeichen des Unicodes überführt werden. Man nennt diesen Vorgang Casting. Das in Klammern vorangestellte (char) verwandelt die Zählvariable für die Ausgabe entsprechend. Sie können so etwas für alle primitiven Datentypen in Java machen (Achtung – boolean Typen sind eine Besonderheit). Dazu folgt gleich mehr.
Java 2 Kompendium
187
Kapitel 6
Java – die Hauptbestandteile der Sprache
6.1.2
Die UTF-8-Codierung
Mit UTF-8-Codierung wird ein Verfahren bezeichnet, das eine Folge von den 16 Bit langen Unicode-Zeichen zur effizienteren Speicherung in eine Datei codiert, indem die Unicode-Zeichen in Abhängigkeit von ihrem Wert in einem, zwei oder drei Byte verschlüsselt werden. Das Verfahren ist dem Huffman-Algorithmus (siehe Anhang) bei allgemeinen Komprimierungsverfahren nicht ganz unähnlich. Jedoch besteht hier nicht das Problem, zuerst die Häufigkeit einzelner Zeichen bestimmen zu müssen. Hier setzt man einfach voraus, dass die Zeichen des ASCII-Zeichensatzes (\u0001 – \u007F) besonders häufig vorkommen (und natürlich das erste Byte sowieso auf 0 gesetzt ist) und deshalb eine besonders kurze Darstellung in einem Byte benötigen. Die Zeichen von \u0080 bis \u07FF werden in zwei Byte und die Zeichen von \u0800 bis \uFFFF werden in drei Byte verschlüsselt. In Java stellen unter anderem die Klassen DataOutputStream und DataInputStream Methoden zum Speichern und Lesen von Zeichen im UTF8-Code zur Verfügung. Wir werden diese im Kapitel über Ein- und Ausgabe in Java näher behandeln.
6.1.3
Kleiner Vorgriff auf die Datentypen von Java
Wir werden etwas weiter hinten die Datentypen von Java im Detail beleuchten, aber da wir bereits bei den Token mehrfach auf die verschiedenen Datentypen zu sprechen kommen, soll ein kleiner Vorgriff für Klarheit sorgen. Java besitzt acht primitive Datentypen: 1.
Vier Ganzzahltypen mit unterschiedlichen Wertebereichen (byte, int, short, long)
188
2.
Einen logischen Datentyp (boolean)
3.
Zwei Gleitzahltypen mit unterschiedlichen Wertebereichen (float, double)
4.
Einen Zeichentyp (char)
Java 2 Kompendium
Token
6.1.4
Kapitel 6
Die Java-Token-Details
Java unterscheidet seine Token nach bestimmten Kriterien: Token
Beschreibung
Beispiele
Schlüsselworte
Alle Worte, die ein essenzieller Teil der Java-Sprachdefinition sind.
public, class, static, void, String, else, if, synchronized, this, while
Bezeichner oder Identifier
HelloWorld, main, args, Namen für Klassen, Objekte, System, out, println, j, Variablen, Konstanten, Bezeichnungsfelder, Methoden n32e20 usw., zusammengesetzt aus alphanumerischen UnicodeZeichen. An der ersten Stelle eines Bezeichners darf keine Zahl stehen.
Literale
Mit einem Literal können Vari- "HelloJava", 42, false, true ablen und Konstanten bestimmte Werte zugewiesen werden. Dies können sämtliche in der Java-Sprachdefinition erlaubten Arten von Werten sein (numerische Werte, boolesche Werte, Buchstaben, Zeichenketten).
Trennzeichen
Unter Trennzeichen versteht man alle Symbole, die dazu benutzt werden, Trennungen und Zusammenfassungen von Code anzuzeigen.
Operatoren
Operatoren sind Zeichen oder +, –, *, /, , >>>, <<< Zeichenkombinationen, die eine auszuführende Operation mit einer oder mehreren Variablen oder Konstanten angibt. Es gibt diverse Typen von Operatoren.
Java 2 Kompendium
Tabelle 6.1: Die Token-Typen
( ) } [ ] ; , .
189
Kapitel 6 Tabelle 6.1: Die Token-Typen (Forts.)
Java – die Hauptbestandteile der Sprache
Token
Beschreibung
Beispiele
Leerräume
[Space], [Tab], Zeichen, die in beliebiger [Zeilenende], Anzahl und an jedem Ort zwischen allen Token mit Funktion [Formularvorschub] platziert werden können und keinerlei andere Bedeutung haben, als den Quellcode übersichtlich zu gestalten.
Kommentare
Ein Kommentar dient zur übersichtlichen Gestaltung des Quellcodes und dazu, dass man bei späterer Kontrolle überhaupt noch etwas versteht. Der Compiler ignoriert Kommentare. Eine Besonderheit ist der javadoc-Kommentar, der vom Java-DokumentationsTool ausgewertet wird.
// Kommentar bis zum nächsten Zeilenende /*Eingebetteter Kommentar*/ /** javadoc-Kommentar */
Wir werden nun die Token im Detail beleuchten. Schlüsselworte Unter Schlüsselworten versteht man in Java alle Buchstabenfolgen, die ein wesentlicher Teil der Java-Sprachdefinition sind und die in Java eine besondere Bedeutung haben. Es gibt zusätzlich einige Token, die vorsorglich für spätere Versionen von Java reserviert wurden (byvalue, cast, const, future, generic, goto, inner, operator, outer, rest und var). Dass dies Sinn machen kann, zeigt das Schlüsselwort transient, das in der Version 1.0 noch ohne Bedeutung war. Mittlerweile hat es in Java einen wohldefinierten Wert. Die meisten dieser derzeit nicht verwendeten, jedoch vorsorglich reservierten Schlüsselworte werden Programmierern, die von C/C++ oder PASCAL kommen, bekannt vorkommen. Es folgt eine alphabetische Tabelle mit den Java-Schlüsselworten (ohne nähere Erläuterung, die folgt später). Tabelle 6.2: Die Java-Schlüsselworte
190
abstract
boolean
break
byte
case
cast
catch
char
class
const
continue
default
do
double
else
extends
false
final
finally
float
Java 2 Kompendium
Token
Kapitel 6
for
future
generic
goto
if
implements
import
inner
instanceof
int
interface
long
native
new
null
operator
outer
package
private
protected
public
rest
return
short
static
super
switch
synchronized
this
throw
throws
transient
true
try
var
void
volatile
while
Tabelle 6.2: Die Java-Schlüsselworte (Forts.)
Die Bedeutungen der einzelnen Schlüsselworte sollen wie bereits angedeutet an anderen Stellen erläutert werden, aber einige Anmerkungen sind jetzt bereits notwendig: Es wird ein Schlüsselwort auffallen, das in grauer Basic-Urzeit für viel Freude sorgte: goto. Es ist in Java zwar reserviert, indes ohne Bedeutung. Es besteht sogar berechtigte Hoffnung, dass es für immer ohne Bedeutung bleibt. Denkbar ist sogar, dass es nur deshalb als Schlüsselwort ohne Bedeutung reserviert wurde, damit es niemals mehr in einem Java-Quelltext auftaucht. Schlüsselworte haben in Java eine spezifische Bedeutung, können also nicht als Bezeichner für irgendetwas anderes wie beispielsweise Variablen, Konstanten, Klassennamen usw. benutzt werden. Beachten Sie jedoch, dass für Schlüsselworte (wie auch sonst) Groß- und Kleinschreibung zu unterscheiden ist. Ein Schlüsselwort Var gibt es beispielsweise nicht, und Sie könnten es z.B. im Extremfall als Name für eine Variablen nehmen. Davon ist allerdings dringend abzuraten. Java wird damit keine Probleme haben, aber Personen, die den Quelltext lesen und warten sollen. Sie können jedoch Schlüsselworte als Teil eines längeren Tokens verwenden, um damit die Bedeutung deutlich zu machen. Die Token true und false sind rein technisch betrachtet nur Werte für boolesche Variablen und Konstanten. Daher sollte man davon Abstand nehmen, sie als Identifier zu verwenden (benutzerdefinierte Namen und Beschriftungen).
Java 2 Kompendium
191
Kapitel 6
Java – die Hauptbestandteile der Sprache Java besitzt diverse Standardpakete. Dort sind viele Elemente enthalten, deren Namen zwar keine Schlüsselworte sind, die aber bei anderweitiger Verwendung die Lesbarkeit des Quelltextes gewaltig reduzieren (was in der Tat denkbar ist, wenn man die jeweiligen Pakete nicht importiert). Zu Paketen siehe Seite 331. Bezeichner und Namenskonventionen Unter einem Bezeichner oder Identifier versteht man in Java ein Wort, das durch Zuordnung zu einer Variablen, Konstanten, Klasse, Objekt, Beschriftung oder Methode für Java zu einem Token wird. Es gibt in Java – wie in allen Programmiersprachen – einige Regeln zur Namenvergabe bei Bezeichnern, die Sie zwingend einhalten müssen: 1.
Wie schon vorher erwähnt, dürfen Bezeichner nicht mit Java-Schlüsselworten und sollten nicht mit Namen von Java-Paketen identisch sein.
2.
Bezeichner sind in Java Zeichenketten, bestehend aus Unicode-Buchstaben und Zahlen, die im Prinzip eine unbeschränkte Länge haben dürfen (bis auf technische Einschränkungen durch das Computersystem).
3.
Das erste Zeichen eines Bezeichners muss ein Buchstabe, der Unterstrich (_) oder das Dollarzeichen ($) sein. Alle folgenden Zeichen müssen entweder Buchstaben oder Zahlen sein. Es müssen jedoch nicht unbedingt lateinische Buchstaben oder Zahlen sein. Sie können jedes Alphabet, das von Unicode unterstützt wird, benutzen.
Zwei Token gelten nur dann als derselbe Bezeichner, wenn sie dieselbe Länge haben und jedes Zeichen im ersten Token genau mit dem korrespondierenden Zeichen des zweiten Tokens identisch ist, d.h. den vollkommen identischen Unicode-Wert hat. Java unterscheidet deshalb Groß- und Kleinschreibung. Die beiden Token Ganzzahl und ganzzahl sind nicht identisch. Tabelle 6.3: Beispiele für gültige und ungültige Bezeichner
Bezeichner
gültig
ungültig
Begründung, falls ungültig
HelloJava
x x
Der Bezeichner beginnt mit einer Zahl.
Rock&Roll
x
& ist kein Zeichen eines Alphabets.
Rock und Roll
x
Leerzeichen sind verboten.
x
Der Bezeichner beginnt mit einer Zahl.
42HelloJava safetyfirst
Rock_Roll 42
192
x
x
Java 2 Kompendium
Token
Kapitel 6
Bezeichner
gültig
_42
x
a-b
ungültig
Begründung, falls ungültig
x
Das Minuszeichen ist kein Zeichen eines Alphabets. Java würde zwei verschiedene Bezeichner interpretieren, mit denen eine Operation durchgeführt werden soll.
Tabelle 6.3: Beispiele für gültige und ungültige Bezeichner (Forts.)
Neben den zwingenden Namenskonventionen gibt es einige Regeln, die man bei der Vergabe von Namen einhalten sollte. Es hat sich eingebürgert, diese Namenskonventionen in Java einzuhalten, was zwar nicht zwingend, aber für eine Lesbarkeit des Quelltexts auf Grund allgemeiner Bekanntheit sinnvoll ist: 1.
Man sollte möglichst sprechende Bezeichner zu verwenden. Ausnahmen sind Schleifen, wo meistens nur ein Buchstabe als Zählvariable (normalerweise i oder j) verwendet wird.
2.
Konstanten (Elemente mit dem Modifier final) sollten vollständig groß geschrieben werden.
3.
Die Identifier von Klassen sollten mit einem Großbuchstaben beginnen und anschließend klein geschrieben werden. Wenn sich ein Bezeichner aus mehreren Worten zusammensetzt, dürfen diese nicht getrennt werden. Die jeweiligen Anfangsbuchstaben werden jedoch innerhalb des Gesamtbezeichners jeweils groß geschrieben.
4.
Die Identifier von Variablen, Methoden und Elementen beginnen mit Kleinbuchstaben und werden auch anschließend klein geschrieben. Wenn sich ein Bezeichner aus mehreren Worten zusammensetzt, dürfen diese nicht getrennt werden. Die jeweiligen Anfangsbuchstaben von den folgenden Worten werden jedoch innerhalb des Gesamtbezeichners jeweils groß geschrieben.
Es folgen einige unübliche (keine falschen) Bezeichner. Da es bei Bezeichnern von der Art des Elements abhängt, ob der gewählte Bezeichner den gängigen Namenskonventionen entspricht, ist in der Tabelle die Art des Elements aufgeführt.
Java 2 Kompendium
193
Kapitel 6 Tabelle 6.4: Beispiele für einige unübliche Bezeichner
Java – die Hauptbestandteile der Sprache
Art
unüblicher Bezeichner
Begründung
Klasse
Hellojava
Das zweite Wort des Bezeichners sollte groß geschrieben werden.
Klasse
hellojava
Der Bezeichner enthält gleich zwei Verstö ß e gegen die guten Sitten. Der erste Buchstabe des Bezeichners und der des zweiten Worts innerhalb des Bezeichners sollten groß geschrieben werden.
Klasse
HELloJava
Zu viele Buchstaben sind am Anfang groß geschrieben. Ein solcher Bezeichner würde auch bei Methoden, Variablen oder anderen Elementen aufstoßen.
Klasse
i
Kein sprechender Name, außerdem klein geschrieben.
Konstante
Ende
Nicht vollständig groß geschrieben.
Variable
Wert
Bei Variablen sollte der erste Buchstabe klein geschrieben werden.
Variable
werterfassung
Auch bei Variablen sollte der Beginn eines zweiten Wortes in dem Bezeichner groß geschrieben werden.
Namensräume Java stellt eine Technik zur Verfügung, mit der Namenskonflikte aufgelöst werden können, wenn es zwei identische Bezeichner im Quelltext gibt. Java arbeitet mit so genannten Namensräumen. Man versteht unter einem Namensraum einen Bereich, in dem ein bestimmter Bezeichner benutzt werden kann. Namensräume sind in Java einer Hierarchie zugeordnet. Es gilt dabei die Regel, dass ein Bezeichner einen identischen Bezeichner in einem übergeordneten Namensraum überdeckt. Außerdem trennt Java die Namensräume von lokalem und nicht-lokalem Code. Die Hierarchie der Namensräume gliedert sich wie folgt:
194
Java 2 Kompendium
Token
Kapitel 6
1.
Außen (aus Sicht der Mengenlehre zu sehen) steht der Namensraum des Pakets, zu dem die Klasse gehört.
2.
Danach folgt der Namensraum der Klasse.
3.
Es folgen die Namensräume der einzelnen Methoden. Dabei überdecken die Bezeichner von Methodenparametern die Bezeichner von Elementen der Klasse. Sollten Elemente der Klasse überdeckt werden, können sie immer noch mit dem Verweisoperator this qualifiziert werden.
4.
Innerhalb von Methoden gibt es unter Umständen noch weitere Namensräume in Form von geschachtelten Blöcken (etwa try/catchBlöcke). Variablen, die innerhalb eines solchen geschachtelten Blocks deklariert werden, sind außerhalb des Blocks unsichtbar.
Um einen Bezeichner zuzuordnen, werden die Namensräume immer von innen nach außen aufgelöst. Wenn der Compiler einen Bezeichner vorfindet, wird er zuerst im lokalen Namensraum suchen. Sofern er dort nicht fündig wird, sucht er im übergeordneten Namensraum. Das Verfahren setzt sich analog bis zum ersten Treffer (ggf. bis zur obersten Ebene) fort. Es gelten immer nur die Vereinbarungen des Namensraums, wo der Treffer erfolgt ist.
6.1.5
Literale
Literale sind spezielle Token, die zu speichernde Werte als Datentypen byte, short, int, long, float, double, boolean und char darstellen. Darüber hinaus werden Literale dazu benutzt, Werte darzustellen, die in Zeichenketten gespeichert werden. Um es etwas verständlicher auszudrücken – Literale sind das, was bei einer Zuweisung einer Variablen zugewiesen bzw. das, was als Wert direkt bei einer Operation verwendet wird. Ganzzahl-Literale Die Datentypen int und long können dezimal, aber auch hexadezimal sowie oktal beschrieben werden. Man nennt diese beiden Datentypen Integer-Literale oder auch Ganzzahl-Literal. Die Voreinstellung ist dezimal und gilt immer dann, wenn die Werte ohne weitere Angaben dargestellt werden. Hexadezimale Darstellung beginnt immer mit der Sequenz 0x oder 0X. Oktale Darstellungen beginnen mit einer führenden Null. Negativen Ganzzahlen wird (nicht gerade überraschend) ein Minuszeichen vorangestellt. Integer-Literale haben per Voreinstellung den Typ int. Durch Anhängen von l oder L kann man jedoch explizit den Typ long wählen. Sofern man für einen int-Datentyp einen Wert wählt, der den zulässigen Wertebereich überschreitet, muss dies sogar erfolgen. Die nachfolgende Tabelle zeigt einige Beispiele mit Zahlen in verschiedenen Darstellungen.
Java 2 Kompendium
195
Kapitel 6 Tabelle 6.5: Ganzzahl-Literale
Java – die Hauptbestandteile der Sprache
Integer-Literal
Dezimalwert
Hexadezimalwert
Oktalwert
Typ
123
123
7B
173
int
0123
83
53
123
int
0x123
291
123
443
int
0x123L
291
123
443
long
Gleitpunkt-Literale Die beiden Gleitzahltypen vom Datentyp float und double werden Gleitzahl-Literale oder Gleitpunkt-Literale genannt. Der Dezimalpunkt trennt Vor- und Nachkommateil der Gleitzahl. Standardeinstellung ist double. Wenn ein Gleitzahl-Literal als float interpretiert werden soll, muss ein f oder ein F angehängt werden. Daher wird die Zuweisung float gleitzahl = 0.123;
einen Compilerfehler erzeugen, während die drei folgenden Zuweisungen korrekt sind: float gleitzahl = 0.123F; float gleitzahl = 0.123f; double gleitzahl = 0.123;
Negativen Gleitzahlen wird wieder ein Minuszeichen vorangestellt. Mit dem nachgestellten e oder E, gefolgt von einem Exponenten (ein negativer Exponent ist ebenso erlaubt), können für Gleitzahl-Literale Exponenten verwendet werden. Allerdings nur dann, wenn kein Dezimalpunkt vorhanden ist. Zeichenliterale Zeichenliterale werden durch ein einzelnes, zwischen hochgestellten und einfachen Anführungszeichen stehendes Zeichen ausgedrückt. Das gilt für alle Zeichenwerte, egal ob es sich dabei um ein lateinisches Zeichen oder ein anderes Unicode-Zeichen handelt. Als einzelne Zeichen gelten alle druckbaren Zeichen mit Ausnahme des Bindestrichs (-) und des Backslash (\). Die Zeichen werden in Unicode-Format gespeichert. Zeichenliterale lassen sich aber auch in Escape-Format darstellen. Die Escape-Zeichenliterale beginnen immer mit dem Backslash-Zeichen. Diesem folgt eines der Zeichen (b, t, n, f, r, ", ‘ oder \) oder eine Serie von Oktalziffern (3-stellig) oder ein u gefolgt von einer 4-stelligen Serie Hexadezimalziffern, die für ein nicht zeilenbeendendes Unicode-Zeichen stehen. Die vier Stellen der hexadezimalen Unicode-Darstellung (/u0000 bis /uFFFF) stehen damit für 65.535 mögliche Kodierungen. Damit ist es insbesondere möglich solche Zeichen innerhalb von Zeichenketten darzustellen, die ohne diese Maskierung eine besondere 196
Java 2 Kompendium
Token
Kapitel 6
Funktion haben. Dies ist z.B. der Fall, wenn Sie das doppelte Hochkommata innerhalb einer Zeichenkette ausgeben wollen (es dient normalerweise als Begrenzung von Zeichenketten). In der nachfolgende Tabelle sehen Sie einige Beispiele: EscapeLiteral
UnicodeOktal-Sequenz Steuersequenz
Bedeutung
\b
\u0008
\010
Rückschritt (Backspace)
\t
\u0009
\011
Tab
\n
\u000a
\012
Neue Zeile
\f
\u000c
\014
Formularvorschub (Formfeed)
\r
\u000d
\015
Wagenrücklauf (Return)
\"
\u0022
\042
Doppeltes Anführungszeichen
\’
\u0027
\047
Einfaches Anführungszeichen
\\
\u005c
\134
Backslash
Tabelle 6.6: Zeichenliterale in verschiedenen Darstellungen
Das nachfolgende kleine Beispiel zeigt die Verwendung von so maskierten Sonderzeichen, die innerhalb von Zeichenketten verwendet werden. Das Beispiel bewirkt nicht mehr, als Text auf dem Bildschirm auszugeben, der von Sonderzeichen durchsetzt ist. Geben Sie den nachfolgenden Quelltext ein.
class Literale { public static void main(String argv[]) { System.out.println("Tab\tTab\tTab"); System.out.println("Einfache Hochkommata \'"); System.out.println("Eine neue Zeile\n\042, die mit einem doppelten Hochkomma beginnt und endet.\""); System.out.println( "Jetzt kommt noch ein Backslash\\."); } }
Java 2 Kompendium
Listing 6.2: Ausgabe von Zeichenliteralen
197
Kapitel 6
Java – die Hauptbestandteile der Sprache
Abbildung 6.2: Ausgabe von Sonderzeichen über Zeichenliterale
Speichern und kompilieren Sie die Datei.
Lassen Sie das Programm laufen. Die als oktale Escape-Literale bezeichneten Zeichenliterale können zur Darstellung aller Unicode-Werte von \u0000 bis \u00ff (alte ASCII-Begrenzung) benutzt werden. Bei oktaler Darstellung mit Basis 8 ist diese Darstellung auf \000 bis \377 begrenzt. Beachten Sie, dass Oktalzahlen nur von 0 bis einschließlich 7 gehen. Die Unicode-Zeichenliterale werden schon zu einem sehr frühen Zeitpunkt vom Java-Compiler javac interpretiert. Wenn man daher die Escape-Unicode-Literale dazu verwendet, ein zeilenbeendendes Zeichen, wie zum Beispiel Wagenrücklauf oder neue Zeile, darzustellen, wird das ZeilenendeZeichen vor dem schließenden einfachen Anführungszeichen erscheinen. Das Resultat ist dann ein Kompilierfehler. Benutzen Sie also besser nicht das \u-Format, um ein Zeilenende-Zeichen darzustellen. Verwenden Sie statt dessen die Zeichen \n oder \r. Zeichenketten-Literale Zeichenketten-Literale sind aus mehreren Zeichenliteralen zusammengesetzte Ketten (Strings)2. Bei Zeichenketten-Literalen werden null oder mehr Zeichen in (doppelte) Anführungszeichen dargestellt. Java erzeugt Zeichen2
198
So wie in unserem letzten Beispiel, wo wir darauf vorgegriffen haben.
Java 2 Kompendium
Token
Kapitel 6
ketten als Instanz der Klasse String. Damit stehen alle Methoden der Klasse String zur Manipulation einer Zeichenkette zur Verfügung. Obwohl viele Merkmale von Zeichenketten identisch zu den Merkmalen von Zeichenarrays sind, sind sie im Unterschied zu C/C++ keine einfachen Zeichenarrays. Zeichenketten-Literale stehen zwischen zwei doppelten Anführungszeichen und können Steuerzeichen wie Tabulatoren, Zeilenvorschübe, nichtdruckbare Unicode-Zeichen oder druckbare Unicode-Spezialzeichen enthalten. Bei den verwendeten Zeichen kann es sich wie bei Zeichenliterale gleichfalls um Escape-Sequenzen handeln. Beispiele: "Safety First" "2 CV" "DS 21" "" // leere Zeichenkette
Beide Anführungszeichen müssen in derselben Zeile des Quellcodes stehen, damit die Zeichenkette nicht automatisch ein Zeichen für eine neue Zeile enthält. Wenn Sie den Effekt einer neuen Zeile innerhalb einer Zeichenkette erreichen wollen, müssen Sie eine Escape-Sequenz wie zum Beispiel \n oder \r benutzen. Die Zeichen für doppelte Anführungszeichen (") und Backslash (\) müssen ebenfalls durch die Verwendung von Escape-Sequenzen (\" und \\) dargestellt werden (wir haben es in dem letzten Programmbeispiel verwendet). Beispiele: "Tic \t Tac \t Toe " "2 \n CV"
Einige Anmerkungen zu Zeichenketten: Da Zeichenketten in Java native Datentypen sind, lässt sich eine Addition von Zeichenketten mit dem Verknüpfungsoperator (+) realisieren. Wenn Sie eine Zeichenkette aus mehreren kleinen Zeichenketten zusammengesetzten wollen, können Sie diese einfach mit dem Zeichenkettenverknüpfungs-Operator (+) verbinden. Wenn ein Wert, der keine Zeichenkette ist, mit einer Zeichenkette verbunden wird, so wird er vor dem Verbinden automatisch zu einer Zeichenkette konvertiert. Das bedeutet, dass beispielsweise auch ein numerischer Wert einer Zeichenkette hinzugefügt werden kann. Der
Java 2 Kompendium
199
Kapitel 6
Java – die Hauptbestandteile der Sprache numerische Wert wird zu einer entsprechenden Ziffernzeichenfolge konvertiert, die der ursprünglichen Zeichenkette dann hinzugefügt wird. Zeichenketten sind in Java auf der anderen Seite Objekte, oder genauer: Referenztypen. Als Instanzen der Klasse String lassen sich auf Zeichenketten viele nützlich Methoden dieser Klasse anwenden. Diese Methoden können zum Vergleichen oder Durchsuchen von Zeichenketten verwendet werden, oder dienen zum Extrahieren einzelner Zeichen. Wichtige Methoden sind equals(), die Zeichenketten auf Gleichheit überprüft, oder length(), die die Länge eines Strings zurückgibt. Boolesche Literale Es gibt, wie schon mehrfach erwähnt, nur zwei boolesche Literale: true und false. Es gibt keinen Nullwert und kein numerisches Äquivalent. Trennzeichen Trennzeichen sind in Java speziellen Token, die nur aus einem einzigen Zeichen bestehen, und andere Token trennen. Java kennt neun Trennzeichen:
Tabelle 6.7: Java-Trennzeichen
200
Token
Beschreibung
(
Der Token »KlammerAuf« wird sowohl zum Öffnen einer Parameterliste für eine Methode als auch zur Festlegung eines Vorrangs für Operationen in einem Ausdruck benutzt.
)
Der Token »KlammerZu« wird sowohl zum Schließen einer mit dem Token »KlammerAuf« geöffneten Parameterliste für eine Methode als auch zur Beendigung eines mit dem Token »KlammerAuf« festgelegten Vorrangs für Operationen in einem Ausdruck benutzt.
{
Der Token »GeschweifteKlammerAuf« wird zu Beginn eines Blocks mit Anweisungen oder einer Initialisierungsliste gesetzt.
}
Der Token »GeschweifteKlammerZu« wird an das Ende eines mit dem Token »GeschweifteKlammerAuf« geöffneten Blockes mit Anweisungen oder einer Initialisierungsliste gesetzt und schließt den Block wieder.
[
Der Token »EckigeKlammerAuf« steht vor einem Ausdruck, der als Index für ein Datenfeld dient.
]
Der Token »EckigeKlammerZu« folgt einem Ausdruck, der als Index für ein Datenfeld dient und beschließt den Index.
;
Das Semikolon dient sowohl zum Beenden einer Ausdrucksanweisung, als auch zum Trennen der Teile bei einer for-Anweisung.
Java 2 Kompendium
Token
Kapitel 6
Token
Beschreibung
,
Der Token »Komma« ist multifunktional und wird in vielen Zusammenhängen als Begrenzer verwendet.
.
Der Token »Punkt« wird zum einen als Dezimalpunkt, zum anderen als Trennzeichen von Paketnamen, Klassennamen oder Methodenund Variablennamen benutzt.
6.1.6
Tabelle 6.7: Java-Trennzeichen (Forts.)
Operatoren
Operatoren sind dazu da, eine Aktion zu spezifizieren, die mit einem oder mehreren gegebenen Operanden durchgeführt werden soll. In Java werden die Operatoren in mehreren Kategorien eingeteilt. Es gibt fünf arithmetische Operatoren (+, –, *, /, %), sechs Zuweisungsoperatoren (=, +=, *=, -=, / =, %=), einen Dekrementoperator (--), einen Inkrementoperator (++), vier bitweise arithmetische Operatoren (&, |, ^, ~), drei bitweise Verschiebungsoperatoren (<<, >>, >>>), sechs bitweise Zuweisungsoperatoren (&=, |=, ^=, <<=, >>=, >>>=), fünf Vergleichsoperatoren (==, !=, <>, <=, >=), drei logische Vergleichsoperatoren (&&, ||, !) und zwei Operatoren, die innerhalb if-then-else-Konstrukten als Ersatz für eine ausführliche Schreibweise fungieren, wenn sie zusammen benutzt werden (?, :). Dazu kommen noch der Typcast-Operator, der instanceof-Operator und der new-Operator, die aber an dieser Stelle nicht besprochen werden sollen. Die anderen JavaOperatoren sollen nun nach Kategorien getrennt beschrieben werden. Arithmetische Operatoren Arithmetische Operatoren benutzen ein oder zwei Operanden. In Fall von zwei Operanden sind diese entweder ganzzahlige Werte oder Fließkommazahlen. Als Rückgabe einer arithmetischen Operation erhalten Sie einen neuen Wert, dessen Datentyp sich auf Grund der Datentypen der Operanden wie folgt ergibt: Zwei ganzzahlige Datentypen (byte, short, int oder long) als Operanden ergeben immer einen ganzzahligen Datentyp als Ergebnis. Dabei kann als Datentyp des Ergebnisses immer nur ein Datentyp int oder long entstehen. byte und short sind nicht möglich, und der Datentyp long entsteht dann und nur dann, wenn einer der beiden Operanden bereits vom Datentyp long war oder das Ergebnis von der Grö ß e her nur als long dargestellt werden kann. Zwei Fließkommatypen als Operanden ergeben immer einen Fließkommatypen als Ergebnis. Die Anzahl der Stellen des Ergebnisses ist immer das Maximum der Stellenanzahl der beiden Operanden. Wenn die Operanden ein ganzzahliger Typ und ein Fließkommatyp sind, ist das Ergebnis immer ein Fließkommatyp. Java 2 Kompendium
201
Kapitel 6
Java – die Hauptbestandteile der Sprache Java kennt die folgenden arithmetischen Operatoren mit zwei Operanden:
Tabelle 6.8: Die arithmetischen Java-Operatoren mit zwei Operanden
Operator
Bedeutung
Beispiel
+
Additionsoperator
3 + 4
-
Subtraktionsoperator
4 – 3
*
Multiplikationsoperator
2 * 3
/
Divisionsoperator
2 / 3
%
Modulo-Operator (gibt den Rest einer Division zurück)
15 % 9
Die meisten Operatoren sind sicher klar. Eine Ausnahme ist möglicherweise der Modulo-Operator. Dieser ist oft nur Profis bekannt, was aber seine Bedeutung auf keinen Fall mindert. Viele Verschlüsselungs- und Komprimierungsverfahren kommen ohne ihn nicht aus und auch sonst ist er – gerade bei etwas komplexeren Anwendungen – unabdingbar. Der arithmetische Modulo- oder Rest-Operator gibt den Rest einer Division zurück. Wenn der Ausdruck x%y ausgewertet wird, ist der Rückgabewert der Operation der Rest der Division. Der Begriff Modulo stammt aus der Mathematik und wird hauptsächlich in Algebra und Zahlentheorie verwendet. Zwei ganze Zahlen werden als »kongruent modulo einem Faktor n« bezeichnet, wenn ihre Differenz ein Vielfaches von dem Faktor n ist. Sofern sie nicht »kongruent modulo einem Faktor n« sind, bleibt ein Rest. Alles klar? Mathematik ist doch einfach schön, oder ;-)?! Ein paar Beispiele zur Verdeutlichung: Tabelle 6.9: Modulo-Beispiele mit Ganzzahlen
Operation
Rest
Erklärung
1%7
1
Die Zahl 7 geht 0-mal in die Zahl 1 und als Rest bleibt 1. 1%7 = (0*7) – (0*7) + 1 = 1
4%7
4
Die Zahl 7 geht 0-mal in die Zahl 4 und als Rest bleibt 4. 4%7 = (0*7) – (0*7) + 4 = 4
8%7
1
Die Zahl 7 geht 1-mal in die Zahl 8 und als Rest bleibt 1. 8%7 = (1*7) – (1*7) + 1 = 1
9%7
2
Die Zahl 7 geht 1-mal in die Zahl 9 und als Rest bleibt 2. 9%7 = (1*7) – (1*7) + 2 = 2
13%7
6
Die Zahl 7 geht 1-mal in die Zahl 13 und als Rest bleibt 6. 13%7 = (1*7) – (1*7) + 6 = 6
202
Java 2 Kompendium
Token
Kapitel 6
Operation
Rest
Erklärung
14%7
0
Die Zahl 7 geht genau 2-mal in die Zahl 14. Es bleibt kein Rest übrig.
Tabelle 6.9: Modulo-Beispiele mit Ganzzahlen (Forts.)
14%7 = (2*7) – (2*7) + 0 = 0 7000000%7
Auch hier gilt trotz der großen Zahl vor dem Operator: die Division geht ohne Rest auf.
0
7000000/7 = (1000000*7) – (1000000*7) + 0 = 0 13%11
Noch ein Beispiel mit Rest und einem anderen ModuloFaktor. Die Zahl 11 geht 1-mal in die Zahl 13 und als Rest bleibt 2.
2
13/11 = (1*11) – (1*11) + 2 = 2
C-Programmierer kennen den Modulo-Operator von Ganzzahlen und Java erweitert den Rest-Operator sogar, weil auch Operationen mit Fließkommazahlen definiert sind! Es ist einfach die natürliche Fortsetzung der Operation auf die Menge der Fließkommazahlen. Der ausgegebene Wert ist immer noch der »Rest nach der Division«. Auch hier ein paar Beispiele zur Verdeutlichung: Operation
Rest
Erklärung
12%2.5
2.0
Die Zahl 2.5 geht 4-mal in die Zahl 12 und als Rest bleibt 2. Allerdings als Fließkommazahl.
Tabelle 6.10: Modulo-Beispiele mit Fließkommazahlen
12/2.5 = 2.0 4%3.3
0.7
Die Zahl 3.3 geht 1-mal in die Zahl 4 und als Rest bleibt 0.7. Natürlich als Fließkommazahl. 4/3.3 = 0.7
Die technische Formel, um den Wert von x%y zu bestimmen, wobei wenigstens x oder y ein Fließkommatyp ist, sieht folgendermaßen aus: x-((int)(x/y)*y) Der (int)-Operator ist ein Beispiel für den Casting-Operator, zu dem wir später noch kommen werden. Java kennt auch einstellige arithmetische Operatoren. So gibt es zwei einstellige arithmetische Operatoren (d.h. mit nur einem Operanden) in Java, die eine recht offensichtliche Bedeutung haben und dem Operanden einfach vorangestellt werden:
Java 2 Kompendium
203
Kapitel 6
Java – die Hauptbestandteile der Sprache Die einstellige arithmetische Negierung: Das Gegenteil der arithmetischen Negierung: + Die einstellige Negierung ergibt die arithmetische Vorzeichenumdrehung ihres numerischen Operanden. Daher ergibt ein Ausdruck wie beispielsweise -x das arithmetisch Negative von jedem beliebigen Wert x. Der einstellige Operator + tauchte das erste Mal in ANSI C auf und wurde hauptsächlich aus Symmetriegründen eingeführt. Er gibt ganz einfach den Wert seines Operanden aus; mit anderen Worten: Er tut gar nichts! Zu den einstelligen arithmetischen Operatoren werden auch die Inkrement-/ Dekrement-Operatoren gezählt. Sie werden nur in Verbindung mit einem ganzzahligen oder einem Fließkommaoperanden benutzt. Inkrement- und Dekrement-Operatoren sind C-Programmierern altvertraut. Sie werden zum Auf- und Abwerten eines einzelnen Wertes verwendet und sind zwei der Bestandteile einer Programmiersprache wie C, die bei häufiger Verwendung den Begriff »Lesbarkeit« bei einem Quelltext ad absurdum führen. Viele C-Profis werden mir da widersprechen, aber Abkürzungen helfen meist nur demjenigen, der einen Quelltext erstellt und nicht demjenigen, der das Programm warten soll (dabei schließe ich mit ein, dass es sich um dieselbe Person handelt). Die Verwendung von rein aus Abkürzungsgründen eingeführten Konstrukten muss bei einer professionellen Programmierung mit einer solch umfangreichen Dokumentation innerhalb des Quelltexten per Kommentare einhergehen, sodass die Ersparnis gegenüber normaler Zuweisung aufgehoben wird. Bezüglich der Performance wird kein Vorteil erzielt, denn der Compiler optimiert sowieso. Dennoch haben die Operatoren natürlich ihre Berechtigung und die Warnung beinhaltet ausdrücklich die häufige und vor allem verschachtelte Verwendung. Der Inkrement-Operator (++) erhöht den Wert des Operanden um 1. Die Reihenfolge von Operand und Operator ist wichtig. Wenn der Operator vor dem Operanden steht, erfolgt die Erhöhung des Wertes, bevor der Wert dem Operanden zugewiesen wird. Wenn er hinter dem Operanden steht, erfolgt die Erhöhung, nachdem der Wert bereits zugewiesen wurde. Der Dekrementoperator (--) arbeitet analog. Er erniedrigt den Wert des Operanden um 1. Die Reihenfolge von Operand und Operator ist auch hier von Bedeutung. Wenn der Operator vor dem Operanden steht, erfolgt die Erniedrigung des Wertes, bevor der Wert dem Operanden zugewiesen wird. Wenn er hinter dem Operanden steht, erfolgt die Erniedrigung, nachdem der Wert bereits zugewiesen wurde. Testen wir insbesondere die Inkrement-/Dekrement-Operatoren in einem kleinen Beispiel.
204
Java 2 Kompendium
Token
Kapitel 6
Geben Sie den nachfolgenden Quelltext ein.
class OpTest { public static void main(String args[]) { int i=1; int j=3; System.out.println("Startwert von i: " + i); System.out.println("i++:" + i++); System.out.println("++i:" + ++i); System.out.println("i*j:" + i*j); System.out.println("i%j:" + i%j); System.out.println("Startwert von j: " + j); System.out.println("j--:" + j--); System.out.println("--j:" + --j); } }
Listing 6.3: Inkrement-/Dekrement-Operatoren
Abbildung 6.3: Die Wirkung von Operatoren
Speichern und kompilieren Sie die Datei.
Lassen Sie das Programm laufen.
Java 2 Kompendium
205
Kapitel 6
Java – die Hauptbestandteile der Sprache Beachten Sie die Stellen, wo mit ++ der Wert erhöht, aber noch der nicht erhöhte Wert ausgegeben wird. Arithmetische Zuweisungsoperatoren In Java gibt es neben dem direkten Zuweisungsoperators (=) noch die arithmetischen Zuweisungsoperatoren. Diese sind eigentlich nur als Abkürzung für arithmetisch Operationen zu verstehen. Wie auch die arithmetischen Operatoren, können sie sowohl mit ganzen Zahlen als auch mit Fließkommazahlen verwendet werden. Das Ergebnis einer Zuweisung über einen arithmetischen Zuweisungsoperatoren steht immer auf der linken Seite.
Tabelle 6.11: Die arithmetischen Zuweisungsoperatoren
Operator
Bedeutung
Beispiel
Entspricht
+=
Additions- und Zuweisungsoperator
x += 5
x = x + 5
-=
Subtraktions- und Zuweisungsoperator
x -= 3
x = x – 3
*=
Multiplikations- und Zuweisungsoperator
x *= 10
x = x * 10
/=
Divisions- und Zuweisungsoperator
x /= 3
x = x / 3
%=
Modulo- und Zuweisungsoperator
x %= 7
x = x % 7
=
direkter Zuweisungsoperator
x = 3
Bitweise arithmetische Operatoren Bitweise Arithmetik wird im Wesentlichen zum Setzen und Testen einzelner Bits und Kombinationen einzelner Bits innerhalb einer Variablen benutzt. Es gibt eigentlich wenig triftige Gründe, unter Java solch eine bitweise Arithmetik anzuwenden. Die wichtigsten Gründe zur Benutzung bitweiser Operatoren betreffen die direkte Kommunikation mit Hardwarekomponenten oder die Arbeit mit Komprimierungsprozessen (dazu etwas mehr im Anhang unter dem Abschnitt zur Arbeitsweise von Komprimierungsprogrammen) bzw. Verschlüsselungsoperationen. Das wahrscheinlich wichtigste Argument ist, dass bestimmte Vorgänge bei der Arbeit auf Bitebene bezüglich der Performance verbessert werden können. Binäre Arbeit auf Datentypen ist in Java im Vergleich zu anderen Programmiertechniken ziemlich ungefährlich. Da die Datentypen auf allen Plattformen gleich implementiert sind und auch sonst extrem stabil gehandhabt werden, kann die binäre Vorgehensweise unter Java nicht zu den Problemen führen, die bei anderen Sprachen wie C/C++ die Geschichte recht heikel machen können (Zugriff auf falsche Speicherbereiche, Zerstören von Nachbarinformationen usw.).
206
Java 2 Kompendium
Token
Kapitel 6
Bitweise Arithmetik ist nur für die vier Integer-Typen und für Zeichentypen definiert, nicht aber für boolesche Typen und Fließkommatypen.
Operator
Beschreibung
Bedeutung
&
Bitweiser AND-Operator
Die Operation x & y verknüpft alle korrespondierenden Bits von x und y per UND.
|
Bitweiser OR-Operator
Die Operation x | y verknüpft alle korrespondierenden Bits von x und y per ODER.
^
Bitweiser XOR-Operator
Die Operation x ^ y verknüpft alle korrespondierenden Bits von x und y per EXKLUSIVODER.
~
Bitweiser Komplement-Operator Einstelliger, dem Operanden vorangestellter Operator, der alle Bits des Operanden invertiert.
Tabelle 6.12: Die Bit-Operatoren von Java
Wir werden in den folgenden Beispielen Binär- und Hexadezimalrechnung verwenden. Zu beiden Themen finden Sie einen kleinen Exkurs im Anhang. Anhand von Variablen des Typs byte lassen sich Binäroperationen am leichtesten beschreiben, aber der gewählte Beispieldatentyp ist ansonsten willkürlich. Ohne Vorzeichen besteht ein Byte aus 8 Bits, die wiederum nur die Werte 1 oder 0 annehmen können. Jede binäre Darstellung von 0 und 1 steht für eine dezimale Zahl. Die 8-Bit-Binärkkombination 00101010 steht für die Zahl 42. In Hexadezimalzahlen wird dies durch 0x2A ausgedrückt. Für die bitweise Arithmetik gelten nun die folgenden einfachen Regeln: Bitweiser AND-Operator (&) Wenn Sie den AND-Operator (&) mit zwei Bytes benutzen und das Ergebnis in einem dritten Byte ablegen, dann hat das resultierende Byte nur für die Bits den Wert 1, wenn alle beide Operanden an der gleichen Stelle Bits mit dem Wert 1 hatten.
Java 2 Kompendium
207
Kapitel 6
Java – die Hauptbestandteile der Sprache Beispiele:
Tabelle 6.13: Beispiele für &
00101010
&
00101010
=
00101010
00101010
&
00001000
=
00001000
00101010
&
10000000
=
00000000
11110000
&
00001111
=
00000000
10101010
&
01010101
=
00000000
11100011
&
11101100
=
11100000
Die Benutzung von AND hat immer das Resultat, dass maximal die gleichen oder weniger Bits auf 1 gesetzt werden. Das Resultat ist also immer die gleiche oder eine kleinere Dezimal- oder Hexadezimalzahl als das Maximum der beiden Zahlen vorher. Wir machen uns einmal den Spaß und stellen obige bitweise Arithmetik im Dezimal- und im Hexadezimalsystem dar (um deutlich zu machen, dass & nichts mit dem normalen arithmetischen + zu tun hat). Tabelle 6.14: Hexadezimale Beispiele für &
Tabelle 6.15: Dezimale Beispiele für &
208
2A
&
2A
=
2A
2A
&
8
=
8
2A
&
80
=
0
2A
&
F
=
0
AA
&
155
=
0
E3
&
EC
=
E0
42
&
42
=
42
42
&
8
=
8
42
&
128
=
0
42
&
15
=
0
170
&
341
=
0
227
&
236
=
224
Java 2 Kompendium
Token
Kapitel 6
Bitweiser OR-Operator (|) Wenn Sie den OR-Operatoren (|) mit zwei Bytes benutzen und das Ergebnis in einem dritten Byte ablegen, dann hat das resultierende Byte nur für die Bits den Wert 1, wenn mindestens einer der Operanden ein Bit an dieser Position mit dem Wert 1 hatte. Nehmen wir die oben angeführten Beispiele zur Hand: 00101010
|
00101010
=
00101010
00101010
|
00001000
=
00101010
00101010
|
10000000
=
10101010
11110000
|
00001111
=
11111111
10101010
|
01010101
=
11111111
11100011
|
11101100
=
11101111
Tabelle 6.16: Beispiele für |
Die Benutzung von OR-Operator (|) resultiert immer darin, dass die gleichen oder mehr Bits auf 1 gesetzt werden. Bitweiser XOR -Operator (^) Wenn Sie den XOR-Operator (^) (EXKLUSIV-ODER) mit zwei Bytes benutzen und das Ergebnis in einem dritten Byte ablegen, dann hat das resultierende Byte für ein Bit nur dann den Wert 1, wenn das dazugehörige Bit in genau einem der beiden Operanden-Bytes gesetzt wird. Es muss und darf nur einem der Operanden ein Bit an dieser Position auf 1 gesetzt sein. Ein Hinweis zur Eingabe von ^: Vielen Anwendern ist sicher schon aufgefallen, dass die Eingabe von ^ nicht so ganz logisch erfolgt (etwa, wenn sie in Excel potenzieren wollen). Sie müssen nach der Betätigung der ^-Taste eine weitere Taste (etwa die Leertaste) drücken – erst dann wird das ^-Zeichen auf dem Bildschirm erscheinen. Nehmen wir wieder die oben angeführten Beispiele: 00101010
^
00101010
=
00000000
00101010
^
00001000
=
00100010
00101010
^
10000000
=
10101010
11110000
^
00001111
=
11111111
Java 2 Kompendium
Tabelle 6.17: Beispiele für ^
209
Kapitel 6 Tabelle 6.17: Beispiele für ^ (Forts.)
Java – die Hauptbestandteile der Sprache
10101010
^
01010101
=
11111111
11100011
^
11101100
=
00001111
Der Bitweiser Komplement-Operator (~) Der bitweise Komplement-Operator (~) unterscheidet sich massiv von den anderen drei bitweisen Operatoren, denn Komplementieren ist eine einstellige bitweise Operation (d.h. nur ein Operand). Wenn ein Byte komplementiert wird, werden alle seine Bits invertiert. Auch hier wollen wir zur Verdeutlichung ein paar Beispiele heranziehen: Tabelle 6.18: Beispiele für ~
~
00101010
=
11010101
~
00001000
=
11110111
~
10000000
=
01111111
~
00001111
=
11110000
~
01010101
=
10101010
~
11101100
=
00010011
Wir wollen die bitweise Arithmetik in einem Beispiel testen und dabei die verschiedenen Operatoren verwenden. Listing 6.4: Die Arbeit mit binären Operatoren
class BitOp { public static void main(String argv[]) { char meinChar1 = 'a'; char meinChar2 = 'b'; System.out.println((int)meinChar1 + " " + (int)meinChar2); System.out.println((meinChar1 + meinChar2) + " " + (char)(meinChar1 meinChar2)); System.out.println((meinChar1 & meinChar2) + " " + (char)(meinChar1 meinChar2)); System.out.println((meinChar1 | meinChar2) + " " + (char)(meinChar1 meinChar2)); System.out.println((meinChar1 ^ meinChar2) + " " + (char)(meinChar1 meinChar2)); System.out.println(~meinChar1 + " " + (char)(~meinChar1)); } }
+ & | ^
Das Beispiel arbeitet mit zwei char-Variablen, die die Werte a und b zugewiesen bekommen. Das Zeichen a hat den Wert 97 in der Unicode-Darstellung, das Zeichen b den Wert 98 (das wird mit der ersten Ausgabe im Beispiel demonstriert). Das entspricht binär 0110 0001 und 0110 0010. Beachten Sie, dass das Beispiel Casting anwendet.
210
Java 2 Kompendium
Token
Kapitel 6
Wenn nun die beiden char-Variablen einfach addiert werden, werden deren Werte dezimal in der Unicode-Kodierung addiert. Das ergibt 195, was binär 1100 0011 entspricht (die zweite Ausgabe). Bitweise Addition führt dazu, dass binär 0110 0000 entsteht (dann und dann entsteht der Wert 1, wenn alle beide Operanden an der gleichen Stelle Bits mit dem Wert 1 hatten). Das entspricht dem Dezimalwert 96 (die dritte Ausgabe). Analog verhält es sich mit binärem Oder (dezimal entsteht 99 und binär 0110 0011) und den beiden anderen binären Operationen, was die nachfolgenden Ausgaben demonstrieren. Abbildung 6.4: Die Ergebnisse binärer Operationen
Bitweise Verschiebungsoperatoren Bitweise Verschiebungsoperatoren verschieben die Bits in der Darstellung einer ganzen Zahl. Die Bits des ersten Operanden werden um die Anzahl an Positionen verschoben, die im zweiten Operanden angegeben wird. Im Fall der Verschiebung nach links ist es immer eine Null, mit der die rechte Seite aufgefüllt wird. Dieser Vorgang entspricht dem Multiplizieren mit 2 hoch der Zahl, die durch den zweiten Operanden definiert wird. Der normale Verschiebungsoperator nach rechts vervielfacht das Vorzeichenbit. Dieser Vorgang entspricht der Division durch 2 hoch der Zahl, die durch den zweiten Operanden definiert wird. Die Verschiebung nach rechts mit Füllnullen vervielfacht eine Null von der linken Seite.
Java 2 Kompendium
211
Kapitel 6 Tabelle 6.19: Die bitweisen Verschiebungsoperatoren
Tabelle 6.20: Beispiele für bitweise Verschiebung
Listing 6.5: Die Arbeit mit binären Verschiebungen
Java – die Hauptbestandteile der Sprache
Operator
Beschreibung
Bedeutung
<<
Operator für bitweise Verschiebung nach links
Die Operation x << y bedeutet, dass alle Bits von x um y Positionen nach links verschoben werden. Die rechte Seite der Darstellung von x wird mit Nullen aufgefüllt.
>>
Operator für bitweise Verschiebung nach rechts
Die Operation x >> y bedeutet, dass alle Bits von x um y Positionen nach rechts verschoben werden. Dabei wird das Vorzeichenbit vervielfacht.
>>>
Operator für bitweise Verschiebung nach rechts mit Füllnullen
Die Operation x >>> y bedeutet, dass alle Bits von x um y Positionen nach rechts verschoben werden. Die linke Seite der Darstellung von x wird mit Nullen aufgefüllt.
01001111
<<
1
=
10011110
00111100
<<
2
=
11110000
01001111
>>
1
=
00100111
11110000
>>
2
=
11111100
01001111
>>>
1
=
00100111
11110000
>>>
2
=
00111100
class BitVerschieb { public static void main(String argv[]) { int a = 42; int b; b = a >> 1; System.out.println(b); System.out.println(b << 2); System.out.println(b >>> 1); } }
Das Beispiel arbeitet mit zwei int-Variablen. Die Variable a bekommt den Startwert 42 zugewiesen und b den Wert, der aus der Operation a >> 1 entsteht. Da dies der Division durch 2 entspricht, muss das Ergebnis 21 sein (was die erste Ausgabe demonstriert). Binär wird aus der Darstellung 0010 1010 für 42 jedes Bit um den Faktor 1 nach rechts verschoben (0001 0101), was dem Wert 21 in der Unicode-Darstellung entspricht.
212
Java 2 Kompendium
Token
Kapitel 6
Die zweite Operation ist das Verschieben der Bits um zwei Stellen nach links (0101 0100), was dezimal der Multiplikation mit dem Faktor 4 entspricht. Die dritte Operation entspricht verschiebt die Binärdarstellung 0001 0101 (den Wert von b) mit Füllnullen um eine Stelle nach links. Das ergibt 0000 1010, was dezimal dem Wert 10 entspricht. Abbildung 6.5: Die Ergebnisse binärer VerschiebeOperationen
Bitweise Zuweisungsoperatoren Bitweise Zuweisungsoperatoren verwenden einen Wert, führen eine entsprechende bitweise Operation mit dem zweiten Operanden durch und legen das Ergebnis als Inhalt des ersten Operanden ab. Operator
Beschreibung
&=
Bitweiser AND-Zuweisungsoperator.
|=
Bitweiser OR-Zuweisungsoperator.
^=
Bitweiser XOR-Zuweisungsoperator.
<<=
Zuweisungsoperator für die bitweise Verschiebung nach links.
>>=
Zuweisungsoperator für die bitweise Verschiebung nach rechts.
>>>=
Zuweisungsoperator für die bitweise Verschiebung nach rechts mit Füllnullen.
Tabelle 6.21: Die bitweisen Zuweisungsoperatoren
Vergleichsoperatoren Vergleichsoperatoren haben zwei Operanden gleichen Typs und vergleichen diese. Als Rückgabewert der Operation entsteht immer ein boolescher Wert (true oder false).
Java 2 Kompendium
213
Kapitel 6
Java – die Hauptbestandteile der Sprache Der Rückgabewert eines Java-Vergleichs ist auf jeden Fall ein Wahrheitswert. Es ist in Java nicht möglich, einen numerischen Rückgabewert zu erhalten (wie etwa in C/C++, wo man auf Gleichheit mit 0 oder Ungleichheit testen kann). Die Vergleichoperatoren lassen sich in Bezug auf Vergleichslogik wie folgt einteilen: 1.
Relationale Operatoren
2.
Logische Gleichheitsoperatoren
Relationale Operatoren sind zum Ordnen von Grö ß en bestimmt. Die Ordnung erfolgt beispielsweise danach, ob ein Wert grö ß er oder kleiner als ein anderer Wert ist. Die Werte zweier Variablen vom Typ char können ebenfalls verglichen werden und sind in der allgemeinen Beschreibung bereits enthalten. Es werden die Variablen vom Typ char bei der Verwendung eines Vergleichsoperators wie ganze 16-Bit-Zahlen (Werte 0 bis 65535) entsprechend ihrer UnicodeKodierung behandelt. Vergleichsoperatoren werden oft in Schleifen verwendet, die auf einen booleschen Wert abprüfen.
Tabelle 6.22: Die logischen JavaVergleichsoperatoren
Operator
Beschreibung
==
Gleichheitsoperator
!=
Ungleichheitsoperator
<
Kleiner-als-Operator
>
Grö ß er-als-Operator
<=
Kleiner-als-oder-gleich-Operator
>=
Grö ß er-als-oder-gleich-Operator
Und wenn es für Profis jetzt auch als lächerlicher Hinweis erscheint: Verwechseln Sie den Gleiheitsoperator (zwei hintereinander folgenden Gleichheitszeichen) nicht mit dem Zuweisungsoperator (ein einzelnes Gleichheitszeichen). Einige andere Programmiersprachen unterscheiden dahingehend übrigens nicht und verwenden das einfache Gleichzeichen für beide Fälle (Vergleich und Zuweisung).
214
Java 2 Kompendium
Token
Kapitel 6
Wir wollen an dieser Stelle wieder ein weiteres kleines Java-Programm schreiben, um sowohl die Schleife in Verbindung mit boolesche Werten zu erläutern als auch die Unicode-Kodierung von einigen Zeichen ansehen. Damit wir schon so langsam einen etwas anspruchsvolleren Java-Quelltext erstellen, setzen wir dabei ein paar Programmiertechniken voraus, die zwar bisher noch nicht angesprochen wurden (etwa Variablen, Casting und Schleifen), vielen Lesern aber sicher aus anderen Programmiersprachen bekannt sein dürften. Wir werden zudem das Programm Schritt für Schritt durchsprechen. Wenn Ihnen dennoch das Programm zu kompliziert ist – keine Angst, wir werden die einzelnen Techniken im Laufe des Kapitels noch sehr ausführlich beschreiben. class Zeichenspiele { public static void main (String args[]) { int i; char zeichen; for (i=10; i < 20 ;i++) { System.out.print(i); zeichen = (char)i; System.out.print(" " + (char)i + " "); zeichen = (char)(zeichen – 10); System.out.print(zeichen); System.out.print(" "); System.out.println((int)zeichen); System.out.println("------"); } } }
Listing 6.6: Die Verwendung vom Vergleich auf »kleiner«
Was tut dieses Programm? Wenn Sie das Programm wieder eingegeben, gespeichert und kompiliert haben, können Sie es mittels des Interpreters ausführen. Auf dem Standardausgabegerät (meist dem Bildschirm) bekommen Sie eine Blockstruktur angezeigt. Insgesamt 10 Blöcke und eine Trennlinie werden ausgegeben. Abbildung 6.6: Die Ausgabe der Schleife
Java 2 Kompendium
215
Kapitel 6
Java – die Hauptbestandteile der Sprache Das Programm hat eine ähnliche Struktur wie unser HelloJava – Programm und auch das Unicode-Programm. Es besteht im Wesentlichen wieder nur aus der main()-Methode, die jedes eigenständige Java-Programm benötigt. Am Anfang des Programms werden zwei Variablen vereinbart: int i; char zeichen;
Die erste Variable dient später als eine Zählvariable, die zweite später zur Ausgabe. Innerhalb der main()-Methode finden Sie weiterhin eine for-Schleife. Eine solche Schleife dient dazu, die in ihrem Inneren angegebenen Anweisungen so lange zu wiederholen, wie eine bestimmte Bedingung erfüllt ist. Diese Bedingung wird von der for-Schleife über (i=10; i < 20 ;i++) abgeprüft. Solange der Vergleich in dieser Überprüfung den Wert true liefert, wird die Schleife wiederholt. Innerhalb der for-Schleife finden Sie wie bei unseren bisherigen Beispielprogrammen die Methode System.out.println() sowie die verwandte Methode System.out.print(), die ohne Zeilenvorschub arbeitet. Die for-Schleife durchläuft 10 Durchgänge (von 10 bis inklusive 19), was die 10 Blöcke bewirkt. System.out.println("------"); erzeugt den jeweiligen Trennstrich zur optischen Unterscheidung der einzelnen Blocks. In unserem Beispiel geben wir als Erstes die Zählvariable innerhalb der Methode System.out.print() auf dem Standardausgabegerät aus (System.out.print(i);). Damit kontrollieren wir den Schleifenverlauf und den Wert der Zählvariable. Hinter der Zeile zeichen = (char)i;
versteckt sich eine Zuweisung in Verbindung mit einer Technik, die sich Casting nennt. Vorerst reicht es aus, dass Sie sich darunter eine Umwandlung einer Zahl in ein char-Zeichen vorstellen. Per Casting wird der numerische Wert in das zugehörige Zeichen des Unicodes überführt. Zudem werden einige Leerstrings als optische Trennung hinzugefügt. Als Abänderung wird das Ergebnis der Aktion in der am Anfang definierten Zeichen-Variable zeichen gespeichert. Die nachfolgende Ausgabe kennen wir. Es ist die Zeichenvariable. Wir hätten auch hier die Zeichenvariable zeichen direkt nehmen können, was wir im übernächsten Schritt tun werden.
216
Java 2 Kompendium
Token
Kapitel 6
Im Folgeschritt wird es jetzt spannend. Wir machen uns zunutze, dass die Variablen vom Typ char bei der Verwendung eines Vergleichsoperators oder Arithmetik mit Zahlen (wie hier) wie ganze 16-Bit-Zahlen (Werte 0 bis 65535) entsprechend ihrer Unicode-Kodierung behandelt werden. Die Arithmetik zeichen – 10 reduziert den Wert der Unicode-Kodierung von zeichen um den Faktor 10. Um allerdings dieses Ergebnis in einer Zeichenvariable speichern zu können, müssen wir wieder explizit Casting anwenden. System.out.print(zeichen); ist die Kontrollausgabe. Sie sehen, dass das ausgegebene Zeichen sich von der vorherigen Ausgabe unterscheidet (um die Codeverschiebung 10 nach unten).
Der letzte Schritt vor der Trennlinie gibt den jetzigen Unicode von zeichen aus. Auch dazu verwenden wir wieder die Typumwandlung mittels Casting, nur in die Richtung »Zeichen in Ganzzahl vom Typ int«. Die Priorität von relationalen Operatoren liegt unter der arithmetischer Operatoren, jedoch über der von Zuweisungsoperatoren. Interessant ist die Anwendung von Vergleichsoperatoren, wenn die Operanden Objekte sind. In diesem Fall muss man massiv zwischen den Objekten und den darin gespeicherten Werten unterscheiden. Zwar bedeutet eine Objektgleichheit immer die Gleichheit der Werte (in dem Fall liegt die Referenz auf den gleichen Speicherplatz vor), jedoch gilt die Umkehrung nicht. Zwei verschiedene Objekte können selbstverständlich gleiche Werte beinhalten. Der Vergleich mittels der Vergleichsoperatoren liefert dann Ungleichheit, obwohl der Inhalt unter Umständen gleich ist. Um die Gleichheit des Inhalts zu überprüfen, gibt es die in allen Objekten verfügbare Methode equals() (vererbt von Object). Ziehen wir zur Verdeutlichung das folgende Beispiel heran, wo Vergleiche zwischen Strings und einem Random-Objekt (ein Zufallsobjekt) durchgeführt wird. import java.util.*; public class ObjektVergleich { public static void main(String args[]) { String a = new String("hallo"); String b = new String("hallo"); Random c = new Random(); Random d = new Random(); String e = a; System.out.println( "Sind a und b das gleiche Objekt? " + (a==b)); System.out.println( "Haben a und b den gleichen Inhalt? " + a.equals(b)); System.out.println( "Sind a und e das gleiche Objekt? " + (a==e));
Java 2 Kompendium
Listing 6.7: Unterschied von Objektgleichheit und Gleichheit des Inhalts
217
Kapitel 6
Java – die Hauptbestandteile der Sprache System.out.println( "Haben a und e den gleichen Inhalt? " + a.equals(e)); System.out.println( "Sind c und d das gleiche Objekt? " + (c==d)); System.out.println( "Haben c und d den gleichen Inhalt? " + c.equals(d)); } }
Das Programm arbeitet mit fünf Variablen: drei Strings und zwei RandomObjekte. Zwei Strings werden explizit mit dem new-Operator erzeugt, sind also explizit verschiedene Objekte. Die dritte String-Variable bekommt jedoch das erste String-Objekt zugewiesen. Es handelt sich bei a und c um eine Referenz auf den gleichen Speicherbereich, d.h., die Objekte sind identisch. Die beiden Random-Objekte sind auch im Inhalt verschieden. Schauen Sie sich die Ausgabe des Programms zur Verdeutlichung an. Abbildung 6.7: Unterschied von Objektgleichheit und Gleichheit des Inhalts
Zeile 1 und 2 bestätigen, dass die beiden Variablen a und b verschiedene Objekte sind, jedoch den gleichen Wert haben, also die gleichen Zeichen in der identischen Reihenfolge enthalten sind. Zeile 3 bestätigt, dass die beiden Variablen a und e auch im Sinn der Objektgleichheit identisch sind. Daraus folgt trivialerweise die Gleichheit des Inhalts (Zeile 4). Zeile 5 und 6 bestätigen, dass c und d nicht identisch sind; weder bezüglich des Inhalts, noch im Sinne von Objektgleichheit.
218
Java 2 Kompendium
Token
Kapitel 6
Die logischen Vergleichsoperatoren Die logischen Gleichheitsoperatoren sind nicht zum Ordnen gedacht, sondern sie sagen nur aus, ob zwei Werte gleich sind oder nicht. Die Gleichheitsoperatoren haben eine niedrigere Priorität als relationalen Operatoren. Die logischen Vergleichsoperatoren können mit Operanden jeden Typs verwendet werden. Im Fall primitiver Datentypen werden die Werte der Operanden einfach verglichen. Die Vergleiche erzeugen auf jeden Fall nur boolesche Ergebnisse (Letzteres ist jedoch identisch mit gewöhnlichen Vergleichsoperatoren). Dabei stellt Java – im Gegensatz zu vielen anderen Programmiersprachen – die UND- und ODER-Verknüpfung in zwei verschiedenen Varianten zur Verfügung. Es gibt einmal die so genannte ShortCircuit-Evaluation, zum anderen die Bewertung ohne diese Technik. Bei der Short-Circuit-Evaluation eines logischen Ausdrucks wird von links nach rechts ausgewertet und eine Bewertung abgebrochen, wenn bereits ein ausgewerteter Teilausdruck die Erfüllung des gesamten Ausdrucks unmöglich macht. Mit anderen Worten: Eine Bewertung wird abgebrochen, wenn die weitere Auswertung eines Ausdrucks keine Rolle mehr spielt. Damit kann beispielsweise bei umfangreicheren Konstrukten eine Steigerung der Performance erreicht werden. Operator
Beschreibung
Bedeutung
&&
Logischer AND-Operator mit Short-Circuit-Evaluation
Die Operation x && y liefert true, wenn sowohl x als auch y true sind. Ist bereits x false, wird y nicht mehr bewertet.
||
Logischer OR-Operator mit Short-Circuit-Evaluation
Die Operation x || y liefert true, wenn mindestens einer der beiden Operanden true ist. Ist bereits x true, wird y nicht mehr bewertet.
!
Logischer NOT-Operator
Vorangestellter Operator mit einem Operanden. Umkehrung des Wahrheitswerts.
Tabelle 6.23: Logische Operatoren Teil 1
Analog zu den drei genannten logischen Vergleichsoperatoren gibt es auch hier die folgenden drei Operatoren, die schon bei den bitweisen Operatoren aufgetaucht sind.
Java 2 Kompendium
219
Kapitel 6
Java – die Hauptbestandteile der Sprache Im Prinzip beinhaltet die bitweise Betrachtungsweise bereits die logische, wenn man beachtet, dass der boolesche Datentyp nur ein Bit groß ist.
Tabelle 6.24: Logische Operatoren Teil 2
Operator
Beschreibung
Bedeutung
&
Logischer AND-Operator ohne Die Operation x & y liefert true, Short-Circuit-Evaluation wenn sowohl x als auch y true sind. Beide Operanden werden bewertet.
|
Logischer OR-Operator ohne Short-Circuit-Evaluation
Die Operation x | y liefert true, wenn mindestens einer der beiden Operanden true ist. Beide Operanden werden bewertet.
^
EXKLUSIV-ODER
Die Operation x ^ y liefert true, wenn beide Operanden verschiedene Wahrheitswerte haben.
Das nachfolgende Beispiel demonstriert die Verwendung von den logischen Operatoren (auch im Hinblick auf die binäre Anwendung bei der bitweisen Betrachtungsweise). Abbildung 6.8: Die Anwendung von logischen Operatoren
Listing 6.8: Logische Operatoren
220
class ShortCircuit { public static void main (String args[]) { boolean a=true; boolean b=false; int i=4; int j=5; System.out.println(!a);
Java 2 Kompendium
Token
Kapitel 6
System.out.println(a&&b); System.out.println(a||b); System.out.println(a&b); System.out.println(a|b); System.out.println(a^b); System.out.println(i&j); System.out.println(i|j); System.out.println(i^j); } }
Der Komma-Operator wird nur zur Trennung verwendet – etwa im Rahmen von for-Schleifen. Viele Quellen zu Java geben das Komma gar nicht als eigenen Operator an. Wir kommen darauf zurück, wenn er verwendet wird. Weitere Operatoren und einige Zusatzinformationen werden wir im Zusammenhang mit Ausdrücken behandeln, weil diese Operatoren doch einige weitere Grundlagen zu Datentypen voraussetzen und diese nach den Kommentaren abgehandelt werden.
6.1.7
Operatoren-Priorität
Wie jede Programmiersprache muss auch Java Operatoren nach Prioritäten gewichten. In der folgenden Tabelle sollen sämtliche Operatoren von Java aufgelistet werden, wobei der Operator mit höchstem Vorrang ganz oben steht. Operatoren in der gleichen Zeile haben gleiche Priorität. Sämtliche Java-Operatoren bewerten mit Ausnahme der einstelligen Operatoren von links nach rechts. Beschreibung
Operatoren
Hochvorrangig
. [] ()
Einstellig
+ – ~ ! ++ -- instanceof
Multiplikativ
* / %
Additiv
+ –
Relational
< <= >= > >
Gleichheit
== !=
Bitweises AND
&
Bitweises XOR
^
Bitweises OR
|
Short-turn AND
&&
Java 2 Kompendium
Tabelle 6.25: Die Java-Operatoren nach Priorität geordnet
221
Kapitel 6 Tabelle 6.25: Die Java-Operatoren nach Priorität geordnet (Forts.)
Java – die Hauptbestandteile der Sprache
Beschreibung
Operatoren
Short-turn OR
||
Bedingung
?:
Zuweisung
=
6.1.8
und alle Zuweisungoperatoren mit verbundener Operation
Kommentare
Java unterstützt drei verschiedene Kommentararten. Weder Kommentare noch deren Inhalte sind als echte Token zu verstehen. Java besitzt neben den zwei in C/C++ vorhandenen Kommentartypen – den so genannten traditionellen Kommentaren aus der Tradition der C-Sprache – noch einen weiteren Kommentartyp, der vom Dokumentationstool javadoc verwendet wird. Traditionelle Kommentare Einer der traditionellen C-artigen Kommentare beginnt mit einem Slash, gefolgt von einem Stern (/*), schließt beliebigen Text ein und endet mit den gleichen Zeichen in umgekehrter Reihenfolge – einem Stern gefolgt von einem Slash (*/). Diese Form von Kommentar kann überall beginnen und aufhören, mit Ausnahme innerhalb eines Zeichenketten-Literals, eines Zeichenliterals und eines anderen Kommentars. Letzteres bedeutet vor allem, dass Kommentare gleichen Typs nicht verschachtelt werden können. Bei einem verschachteln Konstrukt kann es zu einem Fehler des Compilers kommen. Diese Form eines Kommentars kann sich über mehrere Zeilen erstrecken oder nur in einer einzigen Zeile (außerhalb eines Token) enthalten sein. Man nutzt sie gerne, um ganze Teile eines Programms auszukommentieren und sie bei Bedarf wieder zur Verfügung zu haben, indem man einfach Anfang- und Endzeichen des Kommentars löscht. Der zweite der traditionellen Kommentare beginnt mit einem Doppel-Slash (//) und endet mit dem Zeilenende. Das bedeutet, alle Zeichen in einer Zeile hinter dem Doppel-Slash werden vom Compiler ignoriert. Man nutzt diese Kommentarform gerne, wenn nur eine Zeile eines Programms stört und man sie bei Bedarf wieder zur Verfügung haben möchte, indem man einfach die Kommentarzeichen löscht. javadoc-Kommentare Diese nicht in C/C++ vorhandene Kommentarart in Java ist ein Spezialfall der ersten Form des traditionellen Kommentars. Sie hat die gleichen Eigenschaften, allerdings kann der Inhalt dieses Kommentars noch in einer vom javadoc-Werkzeug automatisch generierten Dokumentation verwendet werden. Er beginnt mit /** und endet mit */. Innerhalb des Containers befindet sich der Kommentar. Das nachfolgende Beispiel zeigt die Anwendung. 222
Java 2 Kompendium
Typen
Kapitel 6
/** * Um was es geht. * @see Querverweis. * @version 3.42 * @author Ralph Steyer */ class HelloWorld { /* traditionelle Kommentarform */ public static void main (String args[]) { System.out.println("Hello Java!"); // Ausgabe } }
Listing 6.9: Beispiel für Kommentare
Beachten Sie, dass der javadoc-Kommentar außerhalb der Klassendefinition steht. Dies ist deshalb wichtig, weil der Generator bei einer Verschachtelung mit einer Klassendefinition mit Ignoranz des Kommentars reagiert. Mehr zu den Parametern innerhalb des javadoc-Kommentars finden Sie bei der Beschreibung von javadoc in dem Kapitel zu den JDK-Tools.
6.2
Typen
Ein Typ bzw. Datentyp gibt in einer Computersprache an, wie ein einfaches Objekt (wie zum Beispiel eine Variable) im Speicher des Computers dargestellt wird. Er enthält normalerweise ebenfalls Hinweise darüber, die Operationen mit und an ihm ausgeführt werden können. Viele Computersprachen lassen es beispielsweise nicht zu, dass mit einer alphanumerischen Zeichenfolge direkte arithmetische Operationen durchgeführt werden, außer es besteht eine explizite Anweisung, diese Zeichenfolge zuerst in eine Zahl umzuwandeln. Java besitzt, wie schon mehrfach erwähnt, acht primitive Datentypen: Vier Ganzzahltypen mit unterschiedlichen Wertebereichen Einen logischen Datentyp Zwei Gleitzahltypen mit unterschiedlichen Wertebereichen nach der internationalen Norm IEEE Standard for Binary Floating-Point Arithmetic, ANSI/IEEE Std. 754-1985 (IEEE, New York) zur Definition von Gleitpunktzahlen und Arithmetik Einen Zeichentyp Der Begriff »primitiv« ist übrigens nicht abwertend zu verstehen und erklärt sich dadurch, dass diese Datentypen im System integriert und nicht als Objekten zu verstehen sind.
Java 2 Kompendium
223
Kapitel 6
Java – die Hauptbestandteile der Sprache An dieser Stelle soll noch einmal explizit darauf hingewiesen werden, dass in Java die primitiven Datentypen plattformunabhängig sind. Eine weitere wichtige Eigenschaft von primitiven Datentypen in Java ist, dass sie immer einen wohldefinierten Default-Anfangswert haben. Im Gegensatz zu einigen anderen Programmiersprachen muss deshalb ein primitiver Datentyp nicht unbedingt mit einem Anfangswert manuell initialisiert werden, sondern ist sozusagen von Natur aus einsatzbereit. Eine Ausnahme bilden mit primitiven Datentypen definierte lokale Variablen, welchen auf jeden Fall vor einer Verwendung ein Anfangswert zugewiesen werden muss.
Tabelle 6.26: Primitive Datentypen der JavaSprache
224
Bezeichnung
Länge
Defaultwert
Kurzbeschreibung
byte
8 Bit
0
Kleinster Wertebereich mit Vorzeichen. Wird zum Darstellen von Ganzzahlwerten (ganzzahliges Zweierkomplement) von (- 2 hoch 7 = -128) bis (+ 2 hoch 7 – 1 = 127) verwendet.
short
16 Bit
0
Kurze Darstellung von Ganzzahlwerten mit Vorzeichen als ganzzahliges Zweierkomplement von (- 2 hoch 15 = -32.768) bis (+ 2 hoch 15 – 1 = 32.767).
int
32 Bit
0
Standardwertebereich mit Vorzeichen zur Darstellung von Ganzzahlwerten (ganzzahliges Zweierkomplement). Bereich von (- 2 hoch 31 = -2.147.483.648) bis (+ 2 hoch 31 – 1 = 2.147.483.647).
long
64 Bit
0
Grö ß ter Wertebereich mit Vorzeichen zur Darstellung von Ganzzahlwerten (ganzzahliges Zweierkomplement). Wertebereich von -9.223.372.036.854.775.808 (- 2 hoch 63) bis 9.223.372.036.854.775.807 (+ 2 hoch 63 – 1).
float
32 Bit
0.0
Kürzester Wertebereich mit Vorzeichen zur Darstellung von Gleitkommazahlwerten. Dies entspricht Fließkommazahlen mit einfacher Genauigkeit, die den IEEE 7541985-Standard benutzen.
Java 2 Kompendium
Typen
Bezeichnung
Kapitel 6
Länge
Defaultwert
Kurzbeschreibung Der Wertebereich liegt ungefähr zwischen +/- 3,4E+38. Es existiert ein Literal zur Darstellung von plus/ minus unendlich, sowie der Wert NaN (Not a Number) zur Darstellung von nicht definierten Ergebnissen.
double
64 Bit
0.0
Grö ß ter Wertebereich mit Vorzeichen zur Darstellung von Gleitkommazahlwerten. Der Wertebereich liegt ungefähr zwischen +/1,8E+308. Auch diese Fließkommazahlen benutzen den IEEE-7541985-Standard. Es existiert ein Literal zur Darstellung von plus/ minus Unendlich, sowie der Wert NaN (Not a Number) zur Darstellung von nicht definierten Ergebnissen.
char
16 Bit
\u0000
Darstellung eines Zeichens des Unicode-Zeichensatzes. Zur Darstellung von alphanumerischen Zeichen wird dieselbe Kodierung wie beim ASCII-Zeichensatz verwendet, aber das höchste Byte ist auf 0 gesetzt. Der Datentyp ist als einziger primitiver Java-Datentyp vorzeichenlos! Der Maximalwert, den char annehmen kann, ist \uFFFF (siehe dazu den Abschnitt zum Unicode).
boolean
1 Bit
false
Diese können die Werte true (wahr) oder false (falsch) annehmen. Alle logischen Vergleiche in Java liefern den Typ boolean.
Tabelle 6.26: Primitive Datentypen der JavaSprache (Forts.)
Einige Bemerkungen zu Datentypen Boolesche Variablen sind dem Java-Typ boolean zugeordnet und können nur die Werte true oder false annehmen. Die Zuordnung eines booleschen Datentyps mit einer Zahl (egal ob Null oder ungleich Null) erzeugt einen Fehler durch den Compiler. Zahlenoperationen können mit diesem Typ explizit nicht durchgeführt werden. Werte vom Typ boolean sind zu allen anderen primitiven Datentypen inkompatibel und lassen sich nicht durch Casting in andere Typen überführen.
Java 2 Kompendium
225
Kapitel 6
Java – die Hauptbestandteile der Sprache Einer char-Variable kann, da sie 2 Byte lang ist, eine Ganzzahl zwischen 0 und 65535 zugewiesen werden. Ohne Konvertierung! Es wird bei einer evtl. Ausgabe dann das zugeordnete Unicode-Zeichen dargestellt. Die Umkehrung – also die Zuweisung von char-Zeichen an andere Datentypen – funktioniert nur für den Typ int ohne Probleme. Für die anderen Datentypen ist keine direkte Zuweisung möglich. Hier müssen Cast-Konstrukte helfen (Ausnahme Datentyp boolean – hier ist keinerlei Konvertierung möglich). Boolesche Literale sind nur die Schlüsselwörter true und false. Diese Schlüsselwörter können in einem Java-Quelltext überall da verwendet werden, wo es Sinn macht. Es gibt einige andere virtuelle Maschinen, die noch weitere Datentypen besitzen.
6.2.1
Operationen mit den Datentypen
Die meisten Operationen, die sich mit den unterschiedlichen Datentypen ausführen lassen, sind für alle Datentypen recht ähnlich. Es gibt jedoch einige wichtige Abweichungen. Lassen Sie uns die Operationen mit den Datentypen nach den Datentypen aufschlüsseln. Operationen mit booleschen Variablen Operationen mit booleschen Variablen sind in Java etwas Besonderes, denn der Datentyp ist nicht numerisch. Dennoch – viele der gleichen Operatorsymbole werden genauso wie bei anderen Ausdrücken verwendet. In den meisten Fällen handelt es sich bei diesen Bedeutungen um eine natürliche Erweiterung der Operationen, die mit ganzzahligen Typen durchgeführt werden. Tabelle 6.27: Operationen mit booleschen Variablen
226
Operation
Name
Bedeutung
=
Zuweisung
Einer booleschen Variable wird der Wert true oder false zugewiesen.
==
Gleichheit
Innerhalb einer Kontrollstruktur wird ein Vergleich durchgeführt. Es wird nur dann true zurückgegeben, wenn beide boolesche Operanden denselben Wert (true oder false) haben. Ansonsten wird false zurückgegeben (entspricht dem nicht-exklusiven Oder NXOR).
Java 2 Kompendium
Typen
Kapitel 6
Operation
Name
Bedeutung
!=
Ungleichheit
Innerhalb einer Kontrollstruktur wird ein Vergleich durchgeführt. Es wird nur dann true zurückgegeben, wenn beide boolesche Operanden unterschiedliche Werte (true oder false) haben. Ansonsten wird false zurückgegeben (entspricht dem exklusiven Oder XOR).
!
Logisches NOT Wenn der Operand false ist, wird true zurückgegeben und umgekehrt.
&
AND
Es wird dann und nur dann true zurückgegeben, wenn beide Operanden true sind.
¦
OR
Es wird dann und nur dann false zurückgegeben, wenn beide Operanden false sind.
^
XOR
Es wird true zurückgegeben, wenn genau ein Operand true ist. Man nennt dies ein exklusives Oder, weil der Wert eines Operanden für das Ergebnis true ausschließt, dass der Wert des anderen Operanden identisch ist.
&&
Logisches AND Für boolesche Variablen ist das logische AND das Gleiche wie AND (&): Es wird dann und nur dann true zurückgegeben, wenn beide Operanden true sind.
¦¦
Logisches OR
Für boolesche Variablen ist das logische OR das Gleiche wie OR (¦): Es wird dann und nur dann false zurückgegeben, wenn beide Operanden false sind.
?:
if-else
Diese Operation benötigt einen booleschen Ausdruck vor dem Fragezeichen. Wenn er true ist, wird der Wert vor dem Doppelpunkt zurückgegeben, ansonsten der Wert hinter dem Doppelpunkt.
Tabelle 6.27: Operationen mit booleschen Variablen (Forts.)
Operationen mit Zeichenvariablen Der in Java verwendete Unicode-Standard ermöglicht den Gebrauch von Alphabeten vieler verschiedener Sprachen. Das lateinische Alphabet, die Zahlen und Satzzeichen haben in der Kodierung die gleichen Werte wie der ASCII-Zeichensatz. Zeichenvariablen können Operanden in jeder ganzzahligen Operation sein und werden dabei wie ganze 16-Bit-Zahlen ohne Vorzeichen behandelt. Das Resultat einer solchen Operation ist entweder vom Datentyp int oder long. Wenn beide Operanden char-Zeichen sind, ist auch der resultierende DatenJava 2 Kompendium
227
Kapitel 6
Java – die Hauptbestandteile der Sprache typ immer ein Zeichen. Falls man ein numerisches Ergebnis als Zeichen ausdrücken will, muss eine explizite Umwandlung in den Datentyp char erfolgen. Wenn Sie Zeichen in einen kleineren Typ umwandeln, werden Sie unter Umständen Informationen verlieren. Dies betrifft beispielsweise den HanZeichensatz (Chinesisch, Japanisch oder Koreanisch), wenn Sie eine Variable vom Datentyp char in eine Variable vom Datentyp short umwandeln. Operationen mit nur einer Zeichenvariable als Operanden (beispielsweise Zuweisungsoperationen, logische Verneinungen oder Inkrement- und Dekrementoperationen) bedürfen keiner besonderen Konvertierung. Die einstelligen Vorzeichenoperatoren (+ und -) haben keinerlei Bedeutung für Operanden vom Typ char, da diese keine Vorzeichen haben.
Tabelle 6.28: Operationen mit Zeichen-Variablen (mindestens einer der Operanden ist vom Typ char)
228
Operation
Name
Bedeutung
=
Zuweisung
Einer Zeichenvariable wird ein Wert zugewiesen.
==
Gleichheit
Innerhalb einer Kontrollstruktur wird ein Vergleich durchgeführt. Es wird nur dann der boolesche Wert true zurückgegeben, wenn beide Operanden denselben Wert (im Sinne von gleichem Unicode-Wert) haben. Ansonsten wird false zurückgegeben.
!=
Ungleichheit
Innerhalb einer Kontrollstruktur wird ein Vergleich durchgeführt. Es wird nur dann der boolesche Wert true zurückgegeben, wenn beide Operanden unterschiedliche Werte (im Sinne von gleichem Unicode-Wert) haben. Ansonsten wird false zurückgegeben.
<, <=, >, >=
Relational
Weitere Operatoren zum Vergleich innerhalb einer Kontrollstruktur. Mit diesen Operatoren wird auf Ungleichheit im Sinn »kleiner«, »kleinergleich«, »grö ß er«, »grö ß ergleich« der Werte (im Sinne von gleichem UnicodeWert) abgeprüft.
+,-
Vorzeichen
Vorzeichenoperatoren bei einem Operanden.
+, –, *, /
binäre Arithmetik Additions-, Subtraktions-, Multiplikations-, und Divisionsoperatoren zur Arithmetik mit Zeichenvariablen. Die Zeichenvariablen gehen in die Berechnung mit ihrem Unicode-Wert ein.
+=, -=, *=, /=
Zuweisung
Additions-, Subtraktions-, Multiplikations-, und Divisionszuweisungen.
Java 2 Kompendium
Typen
Kapitel 6
Operation
Name
++, --
binäre Arithmetik Inkrement- und Dekrementoperatoren für den Unicode-Wert der Zeichenvariablen.
<<, >>, >>>
Verschiebung
Bitweise Verschiebungsoperatoren. Operatoren für bitweise Verschiebung nach links, für bitweise Verschiebung nach rechts und für bitweise Verschiebung nach rechts mit Füllnullen.
<<=, >>=, >>>=
Verschiebung und Zuweisung
Bitweise Verschiebungs- und Zuweisungsoperatoren (nach links, nach rechts und nach rechts mit Füllnullen).
~
Bitweises NOT
Bitweiser logischer Verneinungsoperator (Komplementieren). Eine einstellige bitweise Operation. Wenn ein Zeichen komplementiert wird, werden alle seine Bits invertiert.
&
Bitweises AND
Wenn Sie den AND-Operator (&) mit zwei Zeichen benutzen und das Ergebnis in einem dritten Zeichen ablegen, dann hat nur das resultierende Zeichen nur für die Bits den Eintrag 1, wenn alle beide Operanden an der gleichen Stelle Bits mit dem Wert 1 hatten.
|
Bitweises OR
Wenn Sie den OR-Operator(|) mit zwei Zeichenvariablen benutzen und das Ergebnis in einem dritten Zeichen ablegen, dann hat nur das resultierende Zeichen nur für die Bits den Eintrag 1, wenn einer der Operanden ein Bit an dieser Position = 1 hatte.
^
Bitweises exklusives OR
Wenn Sie den XOR-Operator (^) (exklusives OR) mit zwei Zeichenvariablen benutzen und das Ergebnis in einem dritten Zeichen ablegen, dann hat nur das resultierende Zeichen nur für die Bits den Eintrag 1, wenn das dazugehörige Bit in genau einem der beiden Operanden-Bytes gesetzt wird. Es muss und darf genau einer der Operanden ein Bit an dieser Position auf 1 gesetzt haben.
&=, |=, ^=
Bitweise Zuweisung
Bitweise AND-, OR-, exklusive OR (XOR)und Zuweisungsoperatoren.
Java 2 Kompendium
Bedeutung
Tabelle 6.28: Operationen mit Zeichen-Variablen (mindestens einer der Operanden ist vom Typ char) (Forts.)
229
Kapitel 6 Listing 6.10: Operationen mit char-Variablen
Java – die Hauptbestandteile der Sprache class CharOperationen { public static void main (String args[]) { char meinChar1='a'; char meinChar2='b'; int b=5; System.out.println(meinChar1==meinChar2); System.out.println(meinChar1==b); System.out.println(meinChar1<meinChar2); } }
Abbildung 6.9: Die Anwendung von char-Operationen
Diejenigen, welchen die verkürzte Schreibweise von Operatoren nicht ganz so vertraut ist, können im Anhang eine kleine Erläuterung finden. Operationen mit Gleitkommazahlen Gleitkommazahlen oder Fließkommazahlen bestehen in Java immer (d.h. auf jeder Plattform) aus einer so genannten Zweier-Komplement-Repräsentation der ganzen Zahlen. Der eine Teil der Darstellung wird für den Nachkomma-Anteil und das Vorzeichen verwendet, der zweite Teil ist die Darstellung eines Exponenten zur Basis 2 mit einer Ausgleichszahl. Im Anhang finden Sie einige Hintergrundinformationen zu der Theorie des Zweier-Komplements. Daneben existieren einige spezielle Bitkonfigurationen mit besonderer Bedeutung: negative Unendlichkeit Null positive Unendlichkeit keine Zahl 230
Java 2 Kompendium
Typen
Kapitel 6
Die Fließkommaoperationen selbst sind in Java für alle Plattformen gültig, was in vielen anderen Programmiersprachen nicht zutrifft. Die meisten Fließkommaoperationen und Ganzzahloperationen sind identisch. Wichtigste Ausnahmen sind die Fließkommaoperationen, die den Nachkommateil betreffen und bei Ganzzahloperationen natürlich keinen Sinn machen. Damit sind binäre Verschiebungen gemeint, die insofern unsinnig sind, dass damit eine kaum kontrollierbare Verschiebung von Nachkommateil in den Exponten-Anteil und umgekehrt erfolgen könnte. Operation
Name
Bedeutung
=,+=, -=, *=, /=
Zuweisung
Einer Gleitzahlvariablen wird ein Wert zugewiesen, wobei bei einer arithmetischen Zuweisung die entsprechende arithmetische Operation vorher durchgeführt wird.
==
Gleichheit
Innerhalb einer Kontrollstruktur wird ein Vergleich durchgeführt. Es wird nur dann der boolesche Wert true zurückgegeben, wenn beide Operanden denselben Wert haben. Ansonsten wird false zurückgegeben.
!=
Ungleichheit
Innerhalb einer Kontrollstruktur wird ein Vergleich durchgeführt. Es wird nur dann der boolesche Wert true zurückgegeben, wenn beide Operanden unterschiedliche Werte haben. Ansonsten wird false zurückgegeben.
<, <=, >, >=
Relational
Weitere Operatoren zum Vergleich innerhalb einer Kontrollstruktur. Mit diesen Operatoren wird auf Ungleichheit im Sinn »kleiner«, »kleinergleich«, »grö ß er«, »grö ß ergleich« der Werte geprüft. Auch hier wird, unabhängig vom Typ der Operanden, immer ein boolesches Ergebnis zurückgegeben.
+,-
Vorzeichen
Vorzeichenoperatoren bei einem Operanden.
+, –, *, /
binäre Arithmetik
Additions-, Subtraktions-, Multiplikations-, und Divisionsoperatoren.
+=, -=, *=, /=
Zuweisung
Additions-, Subtraktions-, Multiplikations-, und Divisionszuweisungen.
++, --
binäre Arithmetik
Inkrement- und Dekrementoperatoren für den Wert der Variablen.
Java 2 Kompendium
Tabelle 6.29: Operationen mit den Typen float und double
231
Kapitel 6
Java – die Hauptbestandteile der Sprache Wenn eine Operation mit zwei Operanden des Typs float durchgeführt wird, ist das Ergebnis auch immer eine Variable vom Datentyp float. Analog verhält es sich mit dem Datentyp double. Wenn eine binäre Operation mindestens einen Operanden des Typs double enthält, ist das Ergebnis auch vom Datentyp double. Wenn eine Operation zwischen einem GanzzahlDatentyp und einem Gleitzahl-Datentyp durchgeführt wird, bestimmt der Gleitzahl-Datentyp den Datentyp des Ergebnisses. Gleitzahl-Datentypen können im Prinzip in jeden anderen Datentyp außer boolean konvertiert werden. Die Festlegung auf einen kleineren Typen kann
wie immer zu Informationsverlust führen. Fließkommazahlen werden in Java nach dem IEEE-754-Rundungsmodus »Runden auf den nächsten Wert« gerundet. Wenn ein Gleitzahl-Datentyp in eine ganze Zahl konvertiert wird, werden Nachkommastellen abgeschnitten. Java erzeugt keinerlei Ausnahmen bei Benutzung der Fließkomma-Arithmetik. Ein Overflow oder Überlauf (d.h. ein grö ß eres Ergebnis durch eine Operation, als durch den Wertebereich des jeweiligen Typen ausgedrückt werden kann), oder das Teilen aller möglichen Zahlen außer Null durch Null und ähnliche Operationen, resultieren in der Ausgabe von positiven bzw. negativen unendlichen Werten. Dies ist durchaus ein sinnvoller Wert, denn man kann ihn mit Vergleichsoperatoren auswerten. Ein Unterlauf (d.h. ein kleineres Ergebnis – außer Null – durch eine Operation, als durch den Wertebereich des jeweiligen Typen ausgedrückt werden kann) gibt einen speziellen Wert aus, der positiv oder negativ Null genannt wird. Das Teilen von Null durch Null ergibt den Wert NaN (keine Zahl). Auch dies ist durchaus ein sinnvoller Wert, denn man kann ihn mit Vergleichsoperatoren auswerten. Er wird den Wert false bewirken. Operationen mit ganzzahligen Variablen Ganzzahlige Variablen werden in Java allesamt als ZweierkomplementZahlen mit Vorzeichen verwendet. Tabelle 6.30: Operationen mit ganzzahligen Operanden
Operation
=,+=, -=, *=, / Zuweisung = ==
232
Name
Gleichheit
Bedeutung Einer Ganzzahl-Variablen wird ein Wert zugewiesen. Innerhalb einer Kontrollstruktur wird ein Vergleich durchgeführt. Es wird nur dann der boolesche Wert true zurückgegeben, wenn beide Operanden denselben Wert haben. Ansonsten wird false zurückgegeben.
Java 2 Kompendium
Typen
Kapitel 6
Operation
Name
Bedeutung
!=
Ungleichheit
Innerhalb einer Kontrollstruktur wird ein Vergleich durchgeführt. Es wird nur dann der boolesche Wert true zurückgegeben, wenn beide Operanden unterschiedliche Werte haben. Ansonsten wird false zurückgegeben.
<, <=, >, >=
Relational
Weitere Operatoren zum Vergleich innerhalb einer Kontrollstruktur. Mit diesen Operatoren wird auf Ungleichheit im Sinn »kleiner«, »kleinergleich«, »grö ß er«, »grö ß ergleich« der Werte geprüft. Auch hier wird, unabhängig vom Typ der Operanden, immer ein boolesches Ergebnis zurückgegeben.
+,-
Vorzeichen
Vorzeichenoperatoren bei einem Operanden.
+, –, *, /
binäre Arithmetik Additions-, Subtraktions-, Multiplikationsund Divisionsoperatoren.
+=, -=, *=, /=
Zuweisung
++, --
binäre Arithmetik Inkrement- und Dekrementoperatoren für den Wert der Variablen.
<<, >>, >>>
Verschiebung
Bitweise Verschiebungsoperatoren. Operatoren für bitweise Verschiebung nach links, für bitweise Verschiebung nach rechts und für bitweise Verschiebung nach rechts mit Füllnullen.
<<=, >>=, >>>=
Verschiebung und Zuweisung
Bitweise Verschiebungs- und Zuweisungsoperatoren (nach links, nach rechts und nach rechts mit Füllnullen).
~
Bitweises NOT
Bitweiser logischer Verneinungsoperator (Komplementieren). Eine einstellige bitweise Operation. Wenn ein Zeichen komplementiert wird, werden alle seine Bits invertiert.
&
Bitweises AND
Wenn Sie den AND-Operator (&) mit zwei Ganzzahlen benutzen und das Ergebnis in einer dritten Ganzzahlen ablegen, dann hat nur die resultierende Ganzzahl nur für die Bits den Eintrag 1, wenn alle beide Operanden an der gleichen Stelle Bits mit dem Wert 1 hatten.
Java 2 Kompendium
Tabelle 6.30: Operationen mit ganzzahligen Operanden (Forts.)
Additions-, Subtraktions-, Multiplikationsund Divisionszuweisungen.
233
Kapitel 6 Tabelle 6.30: Operationen mit ganzzahligen Operanden (Forts.)
Java – die Hauptbestandteile der Sprache
Operation
Name
Bedeutung
|
Bitweises OR
Wenn Sie den OR-Operator (|) mit zwei Ganzzahlen benutzen und das Ergebnis in einer dritten Ganzzahlen ablegen, dann hat nur die resultierende Ganzzahlen nur für die Bits den Eintrag 1, wenn einer der Operanden ein Bit an dieser Position mit dem Wert 1 hatte.
^
Bitweises exklusives OR
Wenn Sie den XOR-Operator (^) (exklusives OR) mit zwei Ganzzahlen benutzen und das Ergebnis in einer dritten Ganzzahl ablegen, dann hat nur die resultierende Ganzzahl nur für die Bits den Eintrag 1, wenn das dazugehörige Bit in genau einem der beiden Operanden-Bytes gesetzt wird. Es muss und darf genau einer der Operanden ein Bit an dieser Position auf 1 gesetzt haben.
&=, |=, ^=
Bitweise Zuweisung
Bitweise AND-, OR-, ausschließliche OR (XOR)- und Zuweisungsoperatoren.
Wenn eine Operation mit zwei Ganzzahl-Operanden durchgeführt wird, ist das Ergebnis immer vom Datentyp int oder long. Das Ergebnis wird nur dann als long dargestellt, wenn einer der Operanden vom Datentyp long war oder das Ergebnis nicht ohne Überlauf in einer Variable vom Datentyp int darzustellen ist. Die Datentypen byte oder short können als Ergebnis nur vorkommen, wenn es explizit festgelegt wird. Wenn eine Operation zwischen einem Ganzzahl-Datentyp und einem Gleitzahl-Datentyp durchgeführt wird, bestimmt der Gleitzahl-Datentyp den Datentyp des Ergebnisses. Die vier ganzzahligen Typen können im Prinzip in jeden anderen Datentyp außer boolean konvertiert werden. Die Festlegung auf einen kleineren Typen kann wie immer zu Informationsverlusten führen. Die Konvertierung in eine Fließkommazahl (float oder double) führt normalerweise zu Ungenauigkeiten, außer die ganze Zahl ist eine Zweierpotenz. Wenn irgendeine Operation eine Zahl erzeugt, die den erlaubten Wertebereich eines Datentyps überschreitet, wird die Ausnahme oder der Überlauf nicht angezeigt. Als Ergebnis werden die unteren Bits, die noch hineinpassen, zurückgegeben. Nur wenn der rechte Operand beim Teilen einer ganzen Zahl oder bei einer Modulus-Operation Null ist, wird eine arithmetische Ausnahme erzeugt.
234
Java 2 Kompendium
Datenfelder (Arrays)
6.3
Kapitel 6
Datenfelder (Arrays)
Datenfelder (Arrays) gehören zwar nicht zu den primitiven Datentypen, sondern neben Klassen und Schnittstellen zu den Referenzvariablen. Da sie jedoch von der Logik gut zu den primitiven Datentypen passen, aus ihnen oft zusammengesetzt werden und vergleichsweise einfach sind, werden wie sie hier im Zusammenhang behandeln. Arrays sind in Java gegenüber anderen Programmiersprachen wie C/C++ oder PASCAL anders konzipiert. Ein Datenfeld ist eine Ansammlung von Objekten eines bestimmten Typs (es sind keine verschiedenen Typen innerhalb eines Arrays erlaubt, allerdings kann ein Array selbst wieder Arrays enthalten und damit bewirkt das keinerlei Einschränkung), die über einen laufenden Index adressierbar sind. Arrays sind also auch selbst nichts anderes als (besondere) Objekte. Sie werden wie normale Objekte dynamisch angelegt und am Ende ihrer Verwendung vom Garbage Collector beseitigt. Weiterhin stehen in Arrays als Ableitung von Object alle Methoden dieser obersten Klasse zur Verfügung. Array-Bezeichner haben wie normale Objektvariablen einen Verweistyp. Es kann sich bei Arrays um Datenfelder bestehend aus sämtlichen primitiven Variablentypen (byte, char, short, int, long, float, double, boolean), aber auch anderen Datenfeldern oder Objekten handeln. Letzteres ist besonders deshalb wichtig, da Java keine multidimensionalen Arrays im herkömmlichen Sinn unterstützt, sondern für einen solchen Fall ein Array mit Arrays erwartet (und die können wiederum weitere Datenfelder enthalten – im Prinzip beliebig viele Ebenen). Verschachtelte Arrays wäre also eine korrektere Bezeichnung. Gegenüber normalen Objekten haben Arrays zwei wesentliche Einschränkungen: Arrays haben keine Konstruktoren. Statt dessen wird der new-Operator mit spezieller Syntax aufgerufen. Es können keine Subklassen eines Arrays definiert werden. Um ein Datenfeld in Java zu erstellen, muss man drei Schritte durchführen: 1.
Deklarieren des Datenfelds
2.
Zuweisen von Speicherplatz
3.
Füllen des Datenfelds
Einige Anmerkungen zu Datenfeldern: Es ist möglich, mehrere Schritte zur Erstellung eines Datenfeldes mit einer Anweisung zu erledigen. Die Indizierung von Datenfeldern beginnt mit 0 (wie bei C und C++). Java 2 Kompendium
235
Kapitel 6
Java – die Hauptbestandteile der Sprache Sie können ein Datenfeld nur teilweise bei der Initialisierung füllen. Datenfeldindizes müssen entweder vom Typ int (ganze 32-Bit-Zahl) sein, oder als int festgesetzt werden. Daher ist die grö ß tmögliche Datenfeldgrö ß e 2.147.483.647. Datenfelder können in Java durch die Verwendung des new-Operators dynamisch erstellt werden. Ein Datenfeld ist in Java – wie schon angedeutet – eine Variable, kein Zeiger. Oder genauer, ein Array ist ein so genannter Referenztyp, ein besonderer Typ von Objekt. Die Besonderheit beruht darauf, dass Arrays »klassenlose« Objekte sind. Sie werden vom Compiler erzeugt, besitzen aber keine explizite Klassendefinition. Vom Java-Laufzeitsystem werden Arrays wie gewöhnliche Objekte behandelt. Das hat weitreichende (positive) Konsequenzen. So kann auf kein Datenfeldelement in Java zugegriffen werden, das noch nicht erstellt worden ist; dadurch wird das Programm vor dem Abstürzen und nicht initialisierten Zeigern (Pointer) bewahrt. Des Weiteren besitzen Arrays Methoden und Instanzvariablen.
6.3.1
Deklarieren von Datenfeldern
Im ersten Schritt beim Anlegen eines Datenfeldes muss immer eine Variable erstellt werden, in welcher das Datenfeld gespeichert werden soll. Die Technik ist identisch mit anderen Variablen. Es müssen der Datentyp der Variable (byte, char, short, int, long, float, double, boolean oder ein Objekttyp) und der Name der Variablen festgelegt werden. Im Unterschied zu normalen Variablen muss jedoch mit eckigen Klammern die Variable als Datenfeld gekennzeichnet werden. Es sind im Prinzip zwei Positionen denkbar, wo diese eckigen Klammern die Variable als Datenfeld kennzeichnen können – nach der Variablen oder nach dem Datentyp der Variable. Beispiele: int antwort[]; int[] antwort;
Frage: Welche Variante ist richtig? Antwort: Beide! Java unterstützt beide Syntaxtechniken und Sie können sich die Syntax auswählen, die Ihnen am besten zusagt. Arrays mit anderen Arrays als Inhalt müssen natürlich auch deklariert werden können. Dazu wird pro Dimension einfach ein weiteres Paar an eckigen Klammern angefügt. Ein Datenfeld mit einem Datenfeld als Inhalt der Elemente wird z.B. wie folgt deklariert:
236
Java 2 Kompendium
Datenfelder (Arrays)
Kapitel 6
int antwort [] []; int[] [] [] antwort;
6.3.2
Erstellen von Datenfeldobjekten
Wir haben die Erstellung von Objekten im Allgemeinen noch nicht durchgenommen, jedoch bereits in einigen Abhandlungen (Objektorientierung von Java usw.) dazu einige Bemerkungen gemacht. Deshalb wird es Sie wahrscheinlich nicht überraschen, wenn Sie die Erzeugung von Datenfeldobjekten mittels new-Operator sehen. Dies ist die direkte Erzeugung eines Datenfeldobjekts (und eines anderen Objekts). Daneben gibt es die Möglichkeit, durch direktes Initialisieren des Array-Inhalts ein Datenfeldobjekt zu erzeugen. Die Erzeugung eines Datenfeldes mit dem new-Operator Bei der direkten Erzeugung eines Datenfeldobjekts wird eine neue Instanz eines Arrays erstellt. Das erfolgt schematisch so: new []
Beispiele: new int[5] new double[5] [7]
In der Regel wird das Array direkt einer Variablen zugewiesen. Das sieht dann schematisch so aus: = new []
Beispiele: a = new int[5] b = new double[5] [7]
Diese Variablen, welchen das Array zugewiesen werden soll, müssen vorher entsprechend (also mit der passenden Dimensionsangabe) deklariert worden sein. In der Regel fasst man diese Deklaration und die Zuweisung des Arrays in einem Schritt zusammen. Etwa wie im folgenden Beispiel: int[] antwort = new int[5];
Es entsteht ein neues Array vom Datentyp int mit fünf Elementen. Die Anzahl der Elemente muss bei der direkten Erzeugung eines Datenfeldobjekts angegeben werden.
Java 2 Kompendium
237
Kapitel 6
Java – die Hauptbestandteile der Sprache Beim Erzeugen eines Datenfeldobjekts mit new werden alle Elemente des Arrays automatisch initialisiert. Dabei gelten die Defaultwerte des jeweiligen Datentyps (false für boolesche, \0 für Zeichen-Arrays und 0 bzw. 0.0 für alle numerischen Datenfelder). Erzeugung eines Datenfeldes mit direktem Initialisieren des Array-Inhalts Für diese Technik der Erzeugung eines Datenfeldobjekts müssen Sie nach dem Gleichzeichen die Elemente des Arrays in geschweifte Klammern und mit Komma getrennt angegeben. Etwa wie in dem nachfolgenden Beispiel: int[] antwort = {41,42,43,44};
Ein Array mit der Anzahl der angegebenen Elemente wird automatisch erzeugt. Ein Datenfeld mit einem Datenfeld als Inhalt der Elemente wird z.B. wie folgt erzeugt (2x2-Array): int[][] antwort = {{41,42},{43,44}};
Diese Technik der Erzeugung und Initialisierung von Arrays nennt man auch »Literale Initialisierung«.
6.3.3
Dynamische Arrays
Es ist in Java extrem leicht, dynamische Arrays zu erstellen. Genau genommen ist es quasi »natürlich«, denn Arrays werden unter Java grundsätzlich erst zur Laufzeit erzeugt. Arrays unter Java werden als semidynamisch bezeichnet. Das bedeutet, die Grö ß e eines Arrays kann bei Bedarf erst zur Laufzeit festgelegt werden. Nach der Festlegung kann die Grö ß e des Arrays jedoch nicht mehr geändert werden. Dieses dynamische Verhalten der Java-Arrays beruht darauf, dass zum Zeitpunkt der Deklaration noch nicht festgelegt wird, wie viele Elemente das Array hat. Dies geschieht erst bei der Initialisierung. Nur wenn man Deklaration und Initialisierung in einem Schritt erledigt, hat man das Array quasi statisch erzeugt. Ein wichtiger Fall von der dynamischen Festlegung der Array-Grö ß e kennen Sie bereits. Die Übergabewerte an ein Java-Programm, die in der main()Methode angegeben werden, sind ein Array (String[] args bzw. String args[]), dessen Grö ß e erst zur Laufzeit dynamisch bestimmt wird (einfach auf Grund der Tatsache, wie viele Übergabewerte vom Aufrufer mitgegeben werden). Der Programmcode legt die Grö ß e nicht fest.
238
Java 2 Kompendium
Datenfelder (Arrays)
6.3.4
Kapitel 6
Speichern und Zugreifen auf Datenfeldelemente
Einen Weg, um Elemente von Arrays mit Inhalt zu versehen, haben wir gerade gesehen: die literale Initialisierung. Dies ist aber nur für die anfängliche Bestückung zu verwenden und hilft im Fall der direkten Erzeugung eines Datenfeldobjekts nicht weiter. Wir benötigen eine Technik, um auf die Werte von sämtliche Elementen eines Arrays zugreifen, sie zu testen und manipulieren zu können. Also Zugreifen auf Datenfeldelemente im allgemeinen Sinn. Zugreifen auf Elemente von Datenfeldern mit primitiven Datentypen Wenn Sie schon mit Arrays gearbeitet haben, wird Ihnen bei normalen Arrays mit primitiven Datentypen keine Überraschung bevorstehen – Sie geben einfach den Namen der Datenfeldvariable und in eckigen Klammern den Index an. Um auf das zweite Element des Datenfelds int[] antwort = {41,42,43,44};
zugreifen zu können, werden wir einfach antwort [1];
angeben. Der Index 1 für das zweite (!) Element unseres Datenfeldes ist kein Fehler. Der Index eines Arrays beginnt mit 0 (wie bei C/C++). Wenn Sie bei einem Array versuchen, auf Elemente zuzugreifen, die sich außerhalb der Array-Grenzen befinden, wird entweder ein Kompilierungsfehler oder ein Laufzeitfehler (genauer – eine Ausnahme) erzeugt. Der erste Fehler tritt ein, wenn innerhalb des Quelltexts eine falsche Zuweisung vom Compiler bereits erkennbar ist, der zweite Fall, wenn das Array-Element erst zur Laufzeit berechnet wird. Eine solche Ausnahme ist dann von der Form ArrayIndexOutOfBoundsException. Auf jeden Fall wird der Fehler abgefangen und kann nicht wie bei C einen Pointer ins Nirwana schicken und damit übelste Systemabstürze verursachen. Ändern von Elemente in Datenfeldern mit primitiven Datentypen Die Änderung von Werten in Datenfeldern mit primitiven Datentypen ist identisch mit der Änderung von Werten normaler Variablen. Geben Sie einfach den Namen an und weisen Sie einen Wert zu. Beispiel: antwort [2] = 42;
Java 2 Kompendium
239
Kapitel 6
Java – die Hauptbestandteile der Sprache Wir wollen Arrays in einem Beispiel testen:
Listing 6.11: Verschiedene Arrays
class Array1 { public static void main (String args[]) { int i; // Datenfeld mit 10 int-Werten // – nicht gefüllt int[] datenfelder = new int[10]; // fülle Datenfelder for (i=0;i < 10; i++) datenfelder[i] = i; // Ausgabe for (i=9;i > -1; i--) System.out.print(datenfelder[i] + " "); System.out.println("\n____________________"); // andere Variante für ein Datenfeld mit // 10 char-Werten – nicht gefüllt char datenfelder2[] = new char[10]; // fülle Datenfelder for (i=0;i < 10; i++) datenfelder2[i] = (char)(i*5); // Ausgabe for (i=9;i > -1; i--) System.out.print(datenfelder2[i] + " "); System.out.println("\n____________________"); // Datenfeld mit 10 long-Werten und gleich // bei der Deklaration Speicher zugewiesen // und gefüllt long[] fi = {1,2,3,5,7,11,13,17,23,29}; for (i=9;i > -1; i--) System.out.print(fi[i] + " "); System.out.println("\n____________________"); // andere Variante für ein Datenfeld mit // int-Werten und gleich bei der Deklaration // Speicher zugewiesen und gefüllt int NochEinFeld[] = {1,2,3}; for (i=0;i < 3; i++) System.out.print(NochEinFeld[i] + " "); } }
Dieses Programmbeispiel enthält neben Datenfeldern einige interessante Java-Techniken, die wir an dieser Stelle diskutieren wollen. Die Kommentare innerhalb des Source erklären bereits einige Schritte, aber es gibt noch einige Dinge, auf die gesondert eingegangen werden sollte. Die Zuweisung von Inhalt für die Elemente der Arrays erfolgt in den oben beschriebenen Techniken jeweils über for-Schleifen oder bereits durch direktes Initialisieren des Array-Inhalts. Dabei werden Arrays mit verschiedenen Datentypen verwendet. Zum Teil wird Casting verwendet. Beachten
240
Java 2 Kompendium
Datenfelder (Arrays)
Kapitel 6
Sie die Trennlinie, die mit einem einleitenden \n beginnt. Damit wird ein Zeilenvorschub innerhalb eines Strings ausgelöst. Mittels der for-Schleife for (i=9;i > -1; i--) erfolgt eine Ausgabe, indem der Index der Datenfelder von hinten nach vorne durchgezählt wird. Dies ist genauso zulässig. Dabei wird der Dekrementoperator (--) verwendet, um innerhalb der for-Schleife in den angegebenen Grenzen herabzuzählen. Abbildung 6.10: Eindimensionale Arrays
Multidimensionale Datenfelder Wir hatten bereits festgehalten, dass Java keine multidimensionalen Arrays im herkömmlichen Sinn unterstützt, sondern für diesen Fall ein Array mit Arrays erwartet (und die können wiederum weitere Datenfelder enthalten – im Prinzip beliebig viele Ebenen). Wir wollen der Einfachheit halber dennoch von multidimensionalen Arrays reden (obwohl verschachtelte Arrays eigentlich zutreffender wäre). Die Deklaration und Erzeugung haben wir schon gesehen, aber wie erfolgt der Zugriff? Hier ist tatsächlich eine Umstellung gegenüber Arrays in anderen Programmiersprachen notwendig. Ein Zugriff auf das zweite Element in der zweiten Spalte erfolgt beispielsweise über antwort [2][2];
Eine Zuweisung erfolgt analog über antwort [2][2] = 42;.
Der Unterschied gegenüber Arrays in anderen Programmiersprachen ist, dass die eckigen Klammern in der beschriebenen Weise angegeben werden müssen. Ein Zugriff in der Form antwort[2, 2] oder ähnlich wird einen Fehler erzeugen. Java 2 Kompendium
241
Kapitel 6
Java – die Hauptbestandteile der Sprache Das nachfolgende kleine Beispiel arbeitet mit multidimensionalen Arrays.
Listing 6.12: Multidimensionales Array
public class Array2 { public static void main(String args[]) { int a[][] = new int[2][3]; a[0][0] = 1; a[0][1] = 2; a[0][2] = 3; a[1][0] = 4; a[1][1] = 5; a[1][2] = 6; System.out.println("" + a[0][0] + a[0][1] + a[0][2]); System.out.println("" + a[1][0] + a[1][1] + a[1][2]); System.out.println(a[0][0] + a[0][1] + a[0][2]); System.out.println(a[1][0] + a[1][1] + a[1][2]); } }
Der den ersten beiden Ausgaben vorangestellte Leerstring verhindert, dass die Array-Elemente als numerische Werte zusammengezählt werden. Die Ausgaben drei und vier hingegen lassen es zu. Abbildung 6.11: Multidimensionales Array
Arrays mit allgemeinen Objekten als Inhalt der Elemente Multidimensionale Arrays sind ein spezieller Fall von Arrays mit Objekten als Inhalt der Elemente. Darin kann sich allerdings ebenso jegliche andere Form von Objekten befinden. Ein Array mit Objekten als Inhalt der Elemente enthält Referenzen auf diese Objekte. Wenn einem Datenfeldelement ein Wert zugewiesen wird, erstellen Sie eine Referenz auf das betreffende Objekt. Verschieben Sie die Werte in den Arrays, weisen Sie die Referenz neu zu. Es wird also nicht der Wert von
242
Java 2 Kompendium
Datenfelder (Arrays)
Kapitel 6
einem Element in ein anderes Element kopiert, wie es bei einem Array mit primitiven Datentypen der Fall wäre. Arrays mit Objekten als Inhalt sind eine einfache Möglichkeit, innerhalb eines Arrays verschiedene Arten von Informationen unterzubringen. Es gibt zwar in Java keine direkte Möglichkeit, ein Array mit verschiedenen Datentypen zu deklarieren, aber wenn man einfach Objekte mit unterschiedlichen Datentypen als Inhalt verwendet, ist das kein Problem (obgleich etwas Hintergrundwissen zu Java notwendig ist). Das nachfolgende kleine Beispiel arbeitet mit zwei so genannten Wrapperklassen, um dort Informationen eines bestimmten Datentyps (im Beispiel int und float) unterzubringen. Die damit erzeugten Objekte werden einem Array zugewiesen, das vom Typ eine Instanz der Klasse Number ist (der abstrakten Superklasse der beiden Wrapperklassen). Damit befinden sich in dem Array verschiedenen primitive Datentypen. Zwar in Objekte »eingepackt«, aber wie das Beispiel weiter zeigt, stehen Methoden bereit, die primitiven Werte wieder zu extrahieren. public class Array3 { public static void main(String args[]) { Integer b = new Integer(5); Float c = new Float("4.4f"); Number a[] = {b,c}; System.out.println(a[0].intValue()); System.out.println(a[1].floatValue()); } }
Listing 6.13: Daten verschiedenen Typs in einem Array
Die Ausgabe wird zuerst der Ganzzahlwert 5 und dann der Gleitzahlwert 4.4 sein. Es ist sogar in Java mit dieser Technik möglich, nicht-rechteckige Arrays zu erzeugen. Damit werden Verfahren wie Records oder Typedef-Konstrukte, wie sie in anderen Programmiersprachen vorkommen, überflüssig. Das nachfolgende Beispiel demonstriert eine solche Technik. public class Array4 { public static void main(String args[]) { int a[][] = { {8}, {7, 7}, {6, 6, 6}, {5, 5, 5, 5}, {4, 4, 4, 4, 4}, {1, 2, 3, 4, 5, 6} }; for (int i=0; i < a.length; i++) { for (int j=0;j
Java 2 Kompendium
Listing 6.14: Ein nicht-rechteckiges Array
243
Kapitel 6
Java – die Hauptbestandteile der Sprache
}
} System.out.println(""); } }
Beachten Sie in dem Beispiel, dass wir dort viele interessante Details ausnutzen: Zwei Zählvariablen, die beide erst innerhalb der for-Schleife deklariert werden (das nennt man schleifenlokal). Der Inkrementoperator sowohl voran- als auch nachgestellt. Zwei ineinander verschachtelte for-Schleifen. Das Charakteristikum von Arrays, Objekte zu sein, lässt uns Methoden und Eigenschaften verwenden, die auf jedem Objekt bereitstehen. Etwa die Eigenschaft length, mit der die Grö ß e jeder Dimension bestimmt werden kann. Das macht das Beispiel unempfindlich gegenüber Änderungen der Dimensionen und vor allem kann man für alle Grö ß en die gleiche for-Schleife verwenden (das Abbruchkriterium wird anhand des Arrays dynamisch bestimmt). Abbildung 6.12: Ein nicht-rechteckiges Array
6.3.5
Collections
Ein Spezialfall von Arrays sind so genannte Collections. Auch diese dienen dazu, Mengen von Daten aufzunehmen. Die Daten werden aber gekapselt abgelegt und es ist nur mithilfe vorgegebener Methoden möglich, darauf zuzugreifen. Ein wichtiger Spezialfall einer Collection ist eine Hashtabelle, die die Klasse Hashtable repräsentiert. Dies ist eine Collection, in der die Daten paarweise mit einer Referenzbeziehung gespeichert sind. Collections sind im Wesentlichen im Paket java.util untergebracht. Dort gibt es etwa die Klasse Vector als Java-Repräsentation einer linearen Liste oder das Inter-
244
Java 2 Kompendium
Ausdrücke, Operatoren und Casting
Kapitel 6
face Enumeration, was den sequenziellen Zugriff auf die Elemente eines Vektors mittels eines Iterators erlaubt.
6.4
Ausdrücke, Operatoren und Casting
In diesem Abschnitt sollen die Details zu Operatoren und Ausdrücken ergänzt und besprochen werden, die bisher entweder noch nicht behandelt wurden oder scheinbar »vom Himmel gefallen« sind. Dies betrifft einige besondere Operatoren und auch den Vorgang des Castings.
6.4.1
Ausdrücke
Die Ausdrücke in Java und Ausdrücke in C/C++ sind sehr ähnlich. Sie drücken einen Wert entweder direkt oder durch Berechnung aus. Es kann sich gleichfalls um Kontrollfluss-Ausdrücke handeln, die den Ablauf der Programmausführungen festlegen. Diese Ausdrücke können Konstanten, Variablen, Schlüsselworte, Operatoren und andere Ausdrücke beinhalten. Wir haben in unseren bisherigen Beispielen natürlich schon diverse Java-Ausdrücke verwendet. Ausdruck
Beschreibung
42
arithmetische Konstante
3.141592654
arithmetische Konstante
3*4
multiplikativer Ausdruck
1 + 3 / 4
additiver Ausdruck mit Division
2^32
Exponential-Ausdruck
x=42
Zuweisungs-Ausdruck
ausgabe[42]
Datenfeldindizierung
Tabelle 6.31: Beispiele für gültige Java-Ausdrücke
Java unterstützt, außer in Initialisierungs- und Weiterführungsklauseln für Schleifen-Anweisungen – z.B. for (k=1, j=1; j+k < 65; j++, k++) – keine mit Kommata zusammengesetzten Anweisungen. Man kann Ausdrücke am einfachsten folgendermaßen definieren: Ausdrücke sind das Ergebnis der Verbindung von Operanden und Operatoren über die syntaktischen Regeln der Sprache.
Java 2 Kompendium
245
Kapitel 6
Java – die Hauptbestandteile der Sprache Ausdrücke werden also für die Durchführung von Operationen (Manipulationen) an Variablen oder Werten verwendet. Dabei sind Spezialfälle wie arithmetische Konstanten kein Widerspruch, sondern nur die leere Operation. Bewertung von Ausdrücken Ausdrücke kommen selbstverständlich auch bei komplizierten Kombinationen von Operatoren und Operanden vor. Deshalb muss Java diese Kombinationen bewerten, also eine Reihenfolge festlegen, wie diese komplexeren Ausdrücke auszuwerten sind. Das ist in der menschlichen Logik nicht anders. Sie kennen sicher die Punkt-vor-Strichrechnung in der Mathematik. Überhaupt ist die Bewertung von Ausdrücken in Java meistens durch die Bewertung von Ausdrücken in der Mathematik intuitiv herleitbar. Wir werden uns nun mit drei Begriffen auseinander setzen müssen: 1.
Operatorassoziativität
2.
Operatorvorrang
3.
Bewertungsreihenfolge
Operatorassoziativität klingt zwar am kompliziertesten, der Vorgang ist aber die einfachste der Bewertungsregeln. Vielleicht kennen Sie die Assoziativitätsregel noch aus der Schulmathematik. Alle arithmetischen Operatoren bewerten (assoziieren) Ausdrücke defaultmäß ig von links nach rechts. Das heißt, wenn derselbe Operator in einem Ausdruck mehr als einmal auftaucht – wie beispielsweise der +-Operator bei dem Ausdruck 1 + 2 + 3 – dann wird der am weitesten links erscheinende zuerst bewertet, gefolgt von dem rechts daneben usw. Unterziehen wir folgende arithmetische Zuweisung einer näheren Betrachtung: x=1 + 2 + 3;
In diesem Beispiel wird der Wert des Ausdrucks auf der rechten Seite von dem Gleichheitszeichen zusammengerechnet und der Variablen x auf der linken Seite zugeordnet. Für das Zusammenrechnen des Werts auf der rechten Seite bedeutet die Tatsache, dass der Operator + von links nach rechts assoziiert, dass der Wert von 1 + 2 zuerst berechnet wird. Erst im nächsten Schritt wird zu diesem Ergebnis dann der Wert 3 addiert. Anschließend wird das Resultat dann der Variablen x zugewiesen. Immer, wenn derselbe Operator mehrfach benutzt wird, können Sie die Assoziativitätsregel anwenden. Diese Regel ist nicht ganz so trivial, wie sie im ersten Moment erscheint. Darüber lässt sich bewusst das Prinzip des Castings beinflussen. Beachten Sie das nachfolgende kleine Beispiel.
246
Java 2 Kompendium
Ausdrücke, Operatoren und Casting class OperatorAsso { public static void main (String args[]) { System.out.println("" + 1 + 2 + 3); System.out.println(1 + 2 + 3 + ""); } }
Kapitel 6 Listing 6.15: Operatorassoziativität
Die erste Ausgabe wird 123 sein, die zweite jedoch 6. Warum? In der ersten Ausgabe wird zuerst "" + 1 bewertet. Das erzwingt ein Resultat vom Typ String. Danach wird "1" + 2 bewertet ("1" ist ein String!) und es ergibt den String "12". Dann folgt das Spiel erneut. In der zweiten Version wird zuerst 1 + 2 bewertet und es entsteht die Zahl 3. Erst im letzten Schritt wird mit 6 + "" eine Konvertierung in einen String erzwungen. Operatorvorrang bedeutet die Beachtung der Priorität von Java-Operatoren. Wenn Sie einen Ausdruck mit unterschiedlichen Operatoren haben, muss Java entscheiden, wie Ausdrücke bewertet werden. Hier ist das Beispiel der Punkt-vor-Strich-Rechnung aus der Mathematik wieder sinnvoll. Java hält sich strikt an Regeln der Operatorvorrangigkeit. Je höher ein Operator priorisiert ist, desto eher wird er bewertet. Die multiplikativen Operatoren (*, / und %) haben Vorrang vor den additiven Operatoren (+ und -). In anderen Worten: In einem zusammengesetzten Ausdruck, der sowohl multiplikative als auch additive Operatoren enthält, werden die multiplikativen Operatoren zuerst bewertet. Dies ist übrigens einfach die Punkt-vorStrich-Rechnung. Beispiel: a = b-c*d/e;
Weil die Operatoren * und / Vorrang haben, wird der Unterausdruck zuerst berechnet. Erst danach wird die Subtraktion ausgeführt. Immer wenn Sie die Bewertungsreihenfolge von Operatoren in einem Ausdruck ändern wollen, müssen Sie Klammern benutzen. Klammern haben eine höhere Priorität als arithmetische Operatoren. Jeder Ausdruck in Klammern wird zuerst bewertet. Beispiel: a = (b-c)*d/e;
Hier würde zuerst die Subtraktion von b und c durchgeführt. Auch einstellige Operatoren haben eine sehr hohe Priorität.
Java 2 Kompendium
247
Kapitel 6
Java – die Hauptbestandteile der Sprache Beispiel: a=-b*c;
Der einstellige arithmetische Minusoperator bewirkt, dass -b mit c multipliziert wird. Mehr zu der Operatoren-Priorität finden Sie auf Seite 221 Das letzte zu beachtende Detail bei der Bewertung ist die Bewertungsreihenfolge. Der Unterschied zwischen Bewertungsreihenfolge und Operatorvorrang ist der, dass bei der Bewertungsreihenfolge die Operanden bewertet werden. Die Bewertungsreihenfolge legt fest, welche Operatoren in einem Ausdruck zuerst benutzt werden und welche Operanden zu welchen Operatoren gehören. Außerdem dienen die Regeln für die Bewertungsreihenfolge dazu festzulegen, wann Operanden bewertet werden. Es gibt drei plattformunabhängige Grundregeln in Java, wie ein Ausdruck bewertet wird: 1.
Bei allen binären Operatoren wird der linke Operand vor dem rechten bewertet.
2.
Zuerst werden immer die Operanden, danach erst die Operatoren bewertet.
3.
Wenn mehrere Parameter, die durch Kommata voneinander getrennt sind, durch einen Methodenaufruf zur Verfügung gestellt werden, werden diese Parameter immer von links nach rechts bewertet.
6.4.2
Operatoren
Wir werden uns nun der Operatoren noch einmal unter einem anderen Gesichtspunkt annehmen. Operatoren sind in diesem Zusammenhang spezielle Symbole (eine der Schlüsselkategorien von Token in Java), die verwendet werden, um die Durchführung von Operationen (Manipulationen) an Variablen oder Werten auszuführen. Wir haben Operatoren ja schon behandelt und ein Teil der hier diskutierten Ergebnisse wird Ihnen mittlerweile bekannt sein. Allerdings ist es dennoch sogar bei Überschneidungen keine reine Wiederholung, denn wir werden für die Operatoren aus der veränderten Betrachtungsweise neue Erkenntnisse herausziehen und die noch offenen Operatoren behandeln.
248
Java 2 Kompendium
Ausdrücke, Operatoren und Casting
Kapitel 6
Die Operandenanzahl Java-Operatoren können einen, zwei oder drei Operanden haben. Operatoren, die einen Operanden haben, werden als einstellige oder monadische Operatoren bezeichnet. Einige einstellige Operatoren stehen vor dem Operanden (so genannte Präfixoperatoren), andere stehen hinter dem Operanden (sie werden Postfixoperatoren genannt). Der Dekrementoperator (--) und der Inkrementoperator (++) sind Beispiele für einstellige Operatoren. Operatoren mit zwei Operanden werden als binäre oder dyadische Operatoren bezeichnet. Die arithmetischen Operatoren sind Beispiele dafür. Es gibt in Java ebenfalls einen Operator mit drei Operanden – den Bedingungsoperator zur Abkürzung der if-Struktur. Er wird als tenärer oder triadischer Operator bezeichnet. Der triadische Operator Dieser Operator ist ein unverändert gebliebenes Überbleibsel der C-Sprache. Es handelt sich dabei um eine Abkürzung für die gewöhnlichen if-elseAusdrücke. Er besteht aus folgendem Konstrukt: [ergebnis] = [bed1][Vergloperator][bed2] ? [erg1] : [erg2]
Zur Erläuterung: Der Wert [ergebnis] bekommt den Wert [erg1] zugeordnet, wenn der Vergleich (der boolesche Ausdruck vor dem Fragezeichen) zwischen [bed1] und [bed2] das Ergebnis true gebracht hat, ansonsten bekommt [ergebnis] den Wert [erg2] zugeordnet. Ziehen wir ein praktisches Beispiel zur Verdeutlichung her. class If_oder_Nicht { public static void main (String args[]) { String ergebnis; int a = 42; int b = 21; ergebnis = a > b? "a ist groesser" : "a ist kleiner"; System.out.println(ergebnis); } }
Listing 6.16: Der triadische Operator
Das Programmierbeispiel wird den Text »a ist groesser« (der Wert von a) auf dem Bildschirm ausgeben, denn der boolesche Wert vor dem Fragezeichen hat den Wert true.
Java 2 Kompendium
249
Kapitel 6
Java – die Hauptbestandteile der Sprache Man nennt diesen Vorgang bedingte Bewertung. Trotz der weiten Verbreitung in C-Welten, sollte dieses Konstrukt um der Lesbarkeit des Quelltextes willen gar nicht oder möglichst nur sehr sparsam verwendet werden. Eine saubere if-else-Struktur ist fast genauso schnell getippt und bedeutend besser zu lesen.
6.4.3
Typkonvertierungen und der Casting-Operator
Unter Casting versteht man die Umwandlung von einem Datentypen in einen anderen Datentypen. Java ist eine streng typisierte Sprache, weil sehr intensive Typüberprüfungen stattfinden. Außerdem gelten strikte Beschränkungen für die Umwandlung (Konvertierung) von Werten eines Datentyps zu einem anderen. Java unterstützt zwei unterschiedliche Arten von Konvertierungen: Explizite Konvertierungen, um absichtlich den Datentyp eines Wertes verändern. Ad hoc-Konvertierungen ohne Zutun des Programmierers. Ad-hoc-Typkonvertierungen Java führt bei der Bewertung von Ausdrücken einige Typkonvertierungen ad hoc durch, ja sogar ohne dass Sie es unter Umständen überhaupt wissen. Dies erfolgt dann, wenn die Situation es erfordert. Einen solche Situation tritt ein, wenn bei einer Zuweisung der Typ der Variablen und der Typ des zugewiesenen Ausdruck nicht identisch sind, der Wertebereich der Zuweisung eines Ausdrucks nicht ausreicht, verschiedene Datentypen in einem Ausdruck verknüpft werden oder die an einem Methodenaufruf übergebenen Parameter vom Datentyp nicht mit den geforderten Datentypen übereinstimmen. Die Regeln für eine dann durchgeführte automatische Konvertierung sind für numerische Datentypen untereinander allerdings sehr einfach. Wenn nur Ganzzahltypen miteinander kombiniert werden, legt der grö ß te Datentyp den Ergebnisdatentyp fest. Wenn also einer der beiden Operanden den Datentyp long hat, wird der andere gleichfalls zu long konvertiert und das Ergebnis vom Typ long sein. Aus der Kombination short und int wird int, byte und short wird zu short und byte und int wird zu int. Wenn das Ergebnis einer Verknüpfung vom Wert so groß ist, dass es im so vorgesehenen Wertebereich nicht mehr dargestellt
250
Java 2 Kompendium
Ausdrücke, Operatoren und Casting
Kapitel 6
werden kann, wird der nächstgrö ß ere Datentyp genommen. So kann es vorkommen, dass aus der Verknüpfung von zwei int -Werten der Typ long entsteht. Bei Operationen mit Fließkommazahlen gelten weitgehend die analogen Regeln. Wenn wenigstens einer der Operanden den Datentyp double hat, wird der andere ebenso zu double konvertiert, und das Ergebnis ist dann ebenfalls vom Typ double. Aus zwei float-Datentypen wird allerdings nicht (!) der Typ double, wenn der Wertebereich nicht ausreicht (also keine ad-hoc-Konvertierung). Statt dessen wird der wohldefinierte Wert Infinity zurückgegeben. Es ist also offensichtlich so, dass, wenn der entstehende Datentyp grö ß er als der zu konvertierende Datentyp ist, die Konvertierung ohne Probleme ad hoc funktioniert, da keine Informationen verloren gehen können. class Casting1 { public static void main (String args[]) { byte a = 125; short b = 32000; float c = 45.9f; float d = 4E37f; double e = 4E37; System.out.println(a); System.out.println(a + 3); System.out.println((byte)(a + 3)); System.out.println(b); System.out.println(a * b); System.out.println((short)(a * b)); System.out.println(c); System.out.println(d); System.out.println(c * d); System.out.println(c * e); System.out.println((float)(c * d)); System.out.println((double)c * d); } }
Listing 6.17: Beispiele für ad-hoc-Konvertierungen
Das Beispiel verknüpft Variablen verschiedenen Datentyps, und zwar so, dass dabei das Ergebnis jeweils den Wertebereich des ursprünglichen Datentyps sprengt. Es wird automatisch gecastet, wie die jeweils nachfolgende explizite Rückkonvertierung auf den ursprünglichen Datentyp zeigt (dazu gleich mehr).
Java 2 Kompendium
251
Kapitel 6
Java – die Hauptbestandteile der Sprache
Abbildung 6.13: Beispiele für ad-hoc-Konvertierungen
Wenn in Ausdrücken Verbindungen zwischen verschiedenen Familien von Datentypen (etwa char mit int oder byte mit double) durchgeführt werden, gilt Folgendes: Der Datentyp char wird auf int gecastet. Ganzzahlen werden bei Verbindung mit Fließkommazahlen auf float oder double konvertiert (je nach Grö ß e des beteiligten FließkommaOperanden). Listing 6.18: Beispiele für ad-hoc-Konvertierungen zwischen verschiedenen Familien von Datentypen
class Casting2 { public static void main (String args[]) { byte a = 125; float b = 45.9f; float c = 4E37f; double d = 4E37; char e = 'c'; System.out.println(a + b); System.out.println(a * c); System.out.println(a * d); System.out.println(e); System.out.println(e+1); } }
Die zweite und die dritte Ausgabe zeigen, dass es einen Unterschied ausmacht, ob ein Ganzzahlwert mit einem float- oder einem double-Datentyp verknüpft wird. Ausgabe fünf zeigt die ad-hoc-Konvertierung von einem char-Datentyp in einen int-Datentyp. Grundsätzlich kann man mit dem +-Operator primitive Werte mit einem String verbinden. In diesem Fall wird immer ein String erzeugt.
252
Java 2 Kompendium
Ausdrücke, Operatoren und Casting
Kapitel 6 Abbildung 6.14: Beispiele für ad-hoc-Konvertierungen zwischen verschiedenen Familien von Datentypen
Bei booleschen Werten ist die Situation etwas komplizierter. Diese lassen sich in Java grundsätzlich nicht in andere primitive Datentypen konvertieren (weder ad hoc, noch explizit). Man muss bei Bedarf eine Hilfskonstruktion (etwa mit einer if-Struktur) verwenden. Explizite Konvertierungen Eine explizite Konvertierung ist immer dann notwendig, wenn Sie eine Umwandlung in einen anderen Datentyp wünschen und diese nicht ad hoc auf Grund der oben beschriebenen Situationen eintritt. Um beispielsweise einen in einem großen Datentyp gespeicherten Wert in eine kleineren Datentyp umzuwandeln, müssen Sie explizites Casting anwenden. Dazu müssen Sie in der Regel den Casting-Operator (manchmal Festlegungsoperator genannt) verwenden. Es gibt neben der Verwendung des Casting-Operators noch die Fälle, dass Methoden Typkonvertierungen durchführen. Der Casting-Operator besteht bei Casting auf einen primitven Datentyp nur aus einem Datentypnamen in runden Klammern. Er ist ein einstelliger Operator mit hoher Priorität und steht vor seinem Operanden. Er ist also immer von der folgenden Form: () <Wert>
Der Festlegungsoperator ergibt den Datentyp, wie er in den Klammern bezeichneten Typ festgelegt wird.
Java 2 Kompendium
253
Kapitel 6
Java – die Hauptbestandteile der Sprache Es gibt die folgenden Casting-Operatoren:
Tabelle 6.32: Casting-Operatoren von primitiven Datentypen
Operator
Beispiel
Erläuterung
(byte)
(byte) (x/y) Wandelt das Ergebnis der Division x geteilt durch y in einen Wert vom Datentyp byte um.
(short)
(short) x
Wandelt den Datentyp x in einen Wert vom Datentyp short um.
(int)
(int) (x/y)
Wandelt das Ergebnis der Division x geteilt durch y in einen Wert vom Datentyp int um.
(long)
(long) x
Wandelt den Datentyp x in einen Wert vom Datentyp long um.
(float)
(float) x
Wandelt den Datentyp x in einen Wert vom Datentyp float um.
(double)
(double) x
Wandelt den Datentyp x in einen Wert vom Datentyp double um.
(char)
(char) x
Wandelt den Datentyp x in einen Wert vom Datentyp char um.
Casting hat eine höhere Priorität als Arithmetik. Deshalb müssen arithmetische Operationen in Verbindung mit Casting in Klammern gesetzt werden. Nicht alle Konvertierungen sind möglich. Variablen eines arithmetischen Typs können auf jeden anderen arithmetischen Typen festgelegt werden. Boolesche Werte können nicht auf irgendeinen anderen Wert festgelegt werden. Konvertieren von Objekten Mit Einschränkungen lassen sich sogar Klasseninstanzen in Instanzen anderer Klassen konvertieren (sowohl ad hoc als auch explizit). Die wesentliche Einschränkung ist, dass die Klassen durch Vererbung miteinander verbunden sein müssen. Allgemein gilt, dass ein Objekt einer Klasse auf seine Superklasse festgelegt werden kann. So kann beispielsweise ein Graphics2DObjekt auf ein Graphics-Objekt konvertiert werden (Graphics ist die Superklasse von Graphics2D). Beispiel: Graphics a = (Graphics) g2d;
Bei der Subklasse (die ja in der Regel mehr Informationen enthält) gibt es im Allgemeinen Probleme. Weil eine Festlegung immer eine unbedingte Typenkonvertierung beinhaltet (sofern überhaupt eine möglich ist), ist sie als Typenzwang bekannt. Dennoch gibt es diverse Situationen, wo eine Kon-
254
Java 2 Kompendium
Ausdrücke, Operatoren und Casting
Kapitel 6
vertierung eines Objekts auf die Subklasse sinnvoll ist. Etwa, wenn man im Rahmen der paint()-Standardmethode Java 2D verwenden will. In diesem Fall castet man das Graphics-Objekt auf ein Graphics2D-Objekt, dessen fehlende Informationen dann default belegt werden. Etwa so: public void paint(Graphics g) { Graphics2D g2d = (Graphics2D) g; ...// tue etwas sinnvolles }
Beim Konvertieren von einer Instanz auf eine Instanz seiner Superklasse gehen die spezifischen Informationen, welchen nur in der zu konvertierenden Subklasse vorhanden sind, natürlich verloren. Die Technik zum expliziten Konvertieren mit dem Casting-Operator ist analog dem Fall des Castings bei primitiven Datentypen. Er ist also immer von der folgenden Form: () ist der Name der Klasse, in die das Objekt konvertiert werden soll. ist eine Referenz auf das konvertierte Objekt. Casting erstellt eine neue Instanz der neuen Klasse. Das alte Objekt existiert unverändert weiter.
Konvertieren von Objekten in Schnittstellen Obwohl Schnittstellen bisher noch nicht behandelt wurden, gehört eine Diskussion der Konvertierung von Objekten in Schnittstellen der Vollständigkeit halber dazu. Mit Einschränkungen lassen sich Klasseninstanzen in Schnittstellen konvertieren. Dabei ist allerdings zwingend, dass die Klasse selbst oder eine Superklasse des Objekts die Schnittstelle implementiert. Durch Casting eines Objekts in eine Schnittstelle kann dann eine Methode dieser Schnittstelle verwendet werden, obwohl die Klasse des Objekts diese Schnittstelle unter Umständen nicht direkt implementiert hat. Konvertierung von primitiven Datentypen in Objekte und umgekehrt Wenn Sie jetzt nach der Technik fragen, wie primitive Datentypen in Objekte und umgekehrt konvertiert werden können, ist die Antwort ganz einfach: überhaupt nicht! Weder ad hoc noch durch explizites Casting. Das hat sehr weitreichende Konsequenzen, denn ein String ist ja beispielsweise in Java kein primitiver Datentyp. Soll das etwa bedeuten, dass aus einem String, der nur eine Zahl enthält, diese nicht extrahiert werden kann? Nein, natürlich nicht. Nur halt nicht per Casting.
Java 2 Kompendium
255
Kapitel 6
Java – die Hauptbestandteile der Sprache Im Java-Packet java.lang gibt es als Ersatz dafür Sonderklassen, die primitiven Datentypen entsprechen. Man nennt sie Wrapper-Klassen oder kurz Wrapper. Mit den in den Klassen definierten Klassenmethoden können Sie mithilfe des new-Operators jeweils ein Objekt-Gegenstück zu jedem primitiven Datentypen erstellen. Beispiel: Integer Objekt_vomTyp_int = new Integer(42);
Das Objekt Objekt_vomTyp_int ist eine Instanz der Klasse Integer und bekommt direkt den Wert 42 übergeben. Aber auch die Klasse String, auf der sämtliche Stringrepräsentationen von Java basieren, ist hier zu erwähnen. Die Konstruktoren der Wrapper-Klassen erlauben es auch, einen String als Übergabewert anzugeben. Über diesen Weg führt dann am sinnvollsten die Extrahierung einer Zahl aus einem String. Neben der Klasse Integer gibt es für jeden primitiven Datentyp ein Wrapper-Äquivalent. Tabelle 6.33: Wrapper für primitive Datentypen
Wrapper
Beschreibung
Boolean
Wrappt einen primitiven boolean-Wert in ein Objekt.
Byte
Wrappt einen primitiven byte-Wert in ein Objekt.
Character
Wrappt einen primitiven char-Wert in ein Objekt.
Double
Wrappt einen primitiven double-Wert in ein Objekt.
Float
Wrappt einen primitiven float-Wert in ein Objekt.
Integer
Wrappt einen primitiven int-Wert in ein Objekt.
Long
Wrappt einen primitiven long-Wert in ein Objekt.
Short
Wrappt einen primitiven short-Wert in ein Objekt.
In den gleichen Zusammenhang sind die Klassen Number (die abstrakte Superklasse von Byte, Double, Float, Integer, Long und Short) und Void (eine nicht-instanzierbare Platzhalterklasse zum Bereitstellen einer Referenz auf das Klassenobjekt, das den primitive Java-Typ void repräsentiert) zu setzten. Die Extrahierung aus einem per Wrapper erzeugten Objekt funktioniert mit den über die Klasse bereitgestellten Methoden. So stellt die Klasse Integer beispielsweise folgende Methoden bereit (Auswahl):
256
Java 2 Kompendium
Ausdrücke, Operatoren und Casting
Kapitel 6
Methode
Beschreibung
byte byteValue()
Rückgabe des Werts von einem Integer als byte
int compareTo(Integer anotherInteger)
Numerischer Vergleich zweier Integer
int compareTo(Object o)
Vergleich von Integer mit einem anderen Objekt
static Integer decode(String nm)
Dekodierung eines Strings in ein
Tabelle 6.34: Auswahl von Methoden der Interger-Klasse
Integer double doubleValue()
Rückgabe des Werts von einem Integer als double
boolean equals(Object obj)
Objektvergleich
float floatValue()
Rückgabe des Wert von einem Integer als float
static Integer getInteger(String nm)
Rückgabe eines Integer-Objekts auf Grund verschiedener Übergabewerte.
static Integer getInteger(String nm, int val) static Integer getInteger(String nm, Integer val) int hashCode()
Rückgabe eines Hashcodes für diesen Integer
int intValue()
Rückgabe des Werts von einem Integer als int
long longValue()
Rückgabe des Werts von einem Integer als long
static int parseInt(String s)
Parsed das Stringargument und gibt den gefundenen Integerwert dezimal zurück.
short shortValue()
Rückgabe des Werts von einem Integer als short
Die anderen Wrapper-Klassen stellen die gleichen oder verwandte Methoden bereit. Das nachfolgende Beispiel extrahiert den Wert des Objekts als primitiven Datentyp int aus dem Integer-Objekt. Die verwendete Methode ist intValue().
Java 2 Kompendium
257
Kapitel 6 Listing 6.19: Multiplikation von zwei an ein Programm übergebenen Werten
Java – die Hauptbestandteile der Sprache class Multi { public static void main(String args[]) { Integer a = new Integer(args[0]); Integer b = new Integer(args[1]); System.out.println(a.intValue()*b.intValue()); } }
Wenn Sie das Programm mit zwei Integerwerten als Übergabewerte aufrufen (also z.B. java Multi 3 4), werden diese miteinander multipliziert und ausgegeben. Da in Java Übergabewerte an ein Programm immer als Strings übergeben werden (ein dynamisches String-Array), muss man eventuell dort zu übergebende primitive Werte mit geeigneten Wrappern behandeln und dann mit passenden Methoden die primitiven Werte extrahieren. Beachten Sie, dass das Programm nicht gegen Falscheingaben (falsches Format der Übergabewerte oder gar fehlende Parameter) gesichert ist.
6.4.4
Der Instanceof-Operator
Der Instanceof-Operator ist ein binärer Operator mit zwei Operanden: einem Objekt auf der linken und einem Klassennamen auf der rechten Seite. Wenn das Objekt auf der linken Seite des Operators tatsächlich eine Instanz der Klasse auf der rechten Seite des Operators ist (ohne einer ihrer Subklassen), dann gibt dieser Operator den booleschen Wert true zurück. Ansonsten wird false zurückgegeben. Beispiel: neuesObjekt instanceof BestehendeKlasse
Dieser Operator wurde in früheren Java-Versionen oft genutzt, um im Ereignisbehandlungsmodell (Version 1.0) zu überprüfen, von welcher Komponente ein Ereignis ausging, etwa von einem Button oder einem Menü-Eintrag. Wir werden bei der Diskussion der Ereignisbehandlungsmodelle darauf zurückkommen.
6.5
Anweisungen
Wie viele Elemente sind auch Anweisungen in Java denen in C/C++ sehr ähnlich. Anweisungen werden einfach der Reihe nach ausgeführt. Ausnahmen sind Kontrollfluss-Anweisungen oder Ausnahmeanweisungen. Sie werden aufgrund ihres Effektes ausgeführt und haben selbst keine Werte. Java hat viele verschiedene Arten von Anweisungen.
258
Java 2 Kompendium
Anweisungen
Kapitel 6
Anweisungart
Beschreibung
Leere Anweisung
Sie tut nichts und dient als Platzhalter.
Blockanweisungen
Ein Zusammenfassen von grö ß eren Sourceteilen zu Blockstrukturen.
Bezeichnete Anweisung
Jede Anweisung kann mit einer Bezeichnung beginnen. Diese Bezeichnungen dürfen keine Schlüsselworte, bereits festgelegte lokale Variablen oder schon in diesem Modul verwendeten Bezeichnungen sein.
Deklarationen
Einführung eines primitiven Datentyps, eines Datenfelds, einer Klasse, einer Schnittstelle oder eines Objekts.
Ausdrucksanweisungen
Ausdrucksanweisungen werden am häufigsten verwendet. Java verwendet sieben verschiedene Ausdrucksanweisungsarten:
Tabelle 6.35: Anweisungsarten in Java
Zuordnung Pre-Inkrement Pre-Dekrement Post-Inkrement Post-Dekrement Methodenaufruf Zuweisungsausdruck Auswahlanweisung
Sie sucht einen von mehreren möglichen Kontrollflüssen aus. Es gibt in Java drei verschiedene Arten von Auswahlanweisungen: if, if-else switch-case-default.
Dies ist identisch mit C und C++. Iterationsanweisung
Sie gibt an, wann und wie Schleifen gestartet werden. Es gibt in Java drei Arten von Iterationsanweisungen: while do for
Bis auf Sprünge und Bezeichnungen sind sie identisch mit den gleichnamigen Iterationsanweisungen in C und C++.
Java 2 Kompendium
259
Kapitel 6 Tabelle 6.35: Anweisungsarten in Java (Forts.)
Java – die Hauptbestandteile der Sprache
Anweisungart
Beschreibung
Sprunganweisungen
Sprunganweisungen geben die Steuerung entweder an den Anfang oder das Ende des derzeitigen Blocks oder aber an bezeichnete Anweisungen weiter. Beachten Sie, dass es in Java keine goto-Anweisung gibt. Das optionale Bezeichnungsargument für Unterbrechungsund Fortsetzungsanweisungen ist in C oder C++ nicht vorhanden. Diese Bezeichnungen müssen im selben Block stehen, und continue-Bezeichnungen müssen bei den Iterationsanweisungen stehen. Diese Anweisungen beinhalten auch Implikationen für Synchronisierungsanweisungen im selben Block. Bei den vier Arten von Sprunganweisungen handelt es sich um: break continue return throw throw-Anweisungen sind ein wichtiger Bestand-
teil des Ausnahmemechanismus. Synchronisationsanweisung
Sie wird für den Umgang mit Multithreading benutzt. Die Schlüsselworte synchronized und threadsafe werden zum Markieren von Methoden und Blöcken benutzt, die eventuell vor gleichzeitiger Verwendung geschützt werden sollen.
Schutzanweisung
Schutzanweisungen werden zur sicheren Handhabung von Code, der Ausnahmen auslösen könnte (beispielsweise das Teilen durch Null), gebraucht. Diese Anweisungen benutzen die Schlüsselworte try, catch und finally.
Unerreichbare Anweisung
Sie erzeugt einen Fehler zur Kompilierzeit.
Schauen wir uns die Anweisungen im Detail an.
6.5.1
Blöcke und Anweisungen
Methoden und statische Konstruktoren (spezielle Konstruktoren, um Variablen mit einem Startwert zu belegen) werden in Java durch Anweisungsblöcke definiert. Bei einem Anweisungsblock handelt es sich um eine Reihe von Anweisungen, die in geschweiften Klammern ({}) stehen. Diese Struktur ist ohne Veränderung aus C/C++ übernommen. Wenn die Form einer 260
Java 2 Kompendium
Anweisungen
Kapitel 6
Anweisung eine Anweisung oder eine Unteranweisung verlangt, kann jeder sinnvolle Block anstelle der Unteranweisung eingefügt werden. Ein Anweisungsblock hat seinen eigenen Geltungsbereich für die in ihm enthaltenen Anweisungen. Das bedeutet, dass lokale Variablen in diesem Block deklariert werden können, die außerhalb dieses Blocks nicht verfügbar sind, und deren Existenz erlischt, wenn der Block ausgeführt wurde. Blöcke können beliebig ineinander geschachtelt werden. Sie müssen allerdings die Schachtelung wieder sauber schließen. Viele Fehler beruhen auf geöffneten und nicht korrekt geschlossenen Blöcken. Der Java-Compiler überprüft natürlich solche Blockstrukturen. Die im Fehlerfall zurückgegebene Meldung kann jedoch oft in die Irre führen, da der endgültige Fehler sich erst an einer anderen Stelle auswirkt.
6.5.2
Leere Anweisungen
In Java ist es erlaubt, leere Anweisungen zu erstellen. Leere Anweisungen erscheinen als eine eigene Anweisung erst einmal unsinnig, denn es handelt sich dabei um eine Anweisung, die zwar Platz im Code belegt, aber keine Funktion besitzt. Es gibt jedoch ein paar sinnvolle Anwendungen: 1.
Man kann Kennzeichen setzen.
2.
Man kann eine leere Anweisung bei Bedarf mit Debugging-Befehlen füllen. Wenn die Debugging-Befehle nicht gebraucht werden, kommentiert man sie aus und lässt die leere Anweisung stehen.
3.
Man kann eine leere Anweisungen schon einmal prophylaktisch in einen Source einfügen und erst mit Befehlen füllen, wenn man sich richtig an die Programmstelle begibt. Das hilft erheblich gegen Vergesslichkeit.
Für den Compiler sieht eine leere Anweisung nur wie ein zusätzliches Semikolon aus.
6.5.3
Bezeichnete Anweisung
Jede Anweisung kann in Java eine Bezeichnung bekommen. Die eigentliche Benennung hat die gleichen Eigenschaften wie jeder andere Bezeichner; sie darf nicht den gleichen Namen wie ein Schlüsselwort oder ein anderer, bereits deklarierter lokaler Bezeichner haben. Wenn sie aber den gleichen Namen wie eine Variable, eine Methode oder ein Typ hat, die für diesen Block verfügbar sind, dann erhält die neue Benennung innerhalb dieses Blocks Vorrang, und die außenstehende Variable, die Methode oder der Typ wird versteckt. Die Reichweite der Benennung erstreckt sich über den
Java 2 Kompendium
261
Kapitel 6
Java – die Hauptbestandteile der Sprache ganzen Block. Der Benennung folgt immer ein Doppelpunkt. Diese Technik ist uralt. Man kennt sie sogar schon von der Batch-Programmierung unter DOS. Die Benennungen werden nur von den Sprunganweisungen break und continue benutzt. Wir kommen bei der Behandlung der beiden Anweisungen darauf zurück. Wer sich noch an goto erinnert und diese Sprunganweisung lieben gelernt hat, muss enttäuscht werden. Obwohl das (Un-)Wort in Java reserviert ist, hat es keine Funktion.
6.5.4
Deklarationen
Deklarationen definieren eine Variable. Dabei ist es egal, ob diese Variable eine Klasse, eine Schnittstelle, ein Datenfeld, ein Objekt oder ein primitiver Typ ist. Das konkrete Format einer solchen Anweisung jedoch hängt davon ab, welcher der fünf verschiedenen Typen deklariert wird. Klassendeklaration Eine Klassendeklaration besteht immer aus sechs Teilen, die in der nachfolgend in der Tabelle angegebenen Reihenfolge zusammengesetzt werden. Tabelle 6.36: Klassendeklaration
262
Bestandteil
Status
Beschreibung
Klassenmodifier
Optional
Dies sind die Schlüsselworte abstract, final oder public. Eine Klasse kann nicht sowohl final als auch abstract als Modifier haben.
Klasse
Zwingend
Das Schlüsselwort class.
Bezeichner
Zwingend
Ein normaler Bezeichner.
Super
Optional
Das Schlüsselwort extends gefolgt von einem Typnamen. Der Typ muss eine verfügbare Klasse sein, die nicht final ist.
Schnittstellen
Optional
Das Schlüsselwort implements, gefolgt von einer durch Kommata getrennten Liste mit Schnittstellen.
Klassenkörper
Zwingend
Java 2 Kompendium
Anweisungen
Kapitel 6
Schnittstellendeklaration Eine Schnittstellendeklaration besteht immer aus fünf Teilen, die in der nachfolgend in der Tabelle angegebenen Reihenfolge zusammengesetzt werden. Bestandteil
Status
Beschreibung
Schnittstellenmodifier
Optional
Dies sind die Schlüsselworte abstract oder public. Alle Schnittstellen sind abstrakt, der Modifier kann jedoch trotzdem aufgrund der Eindeutigkeit gesetzt werden.
Interface
Zwingend
Das Schlüsselwort interface.
Bezeichner
Zwingend
Ein normaler Bezeichner. Das Schlüsselwort extends, gefolgt von einer durch Kommata getrennten Liste von Schnittstellenbezeichnern.
Schnittstellenerweiterung Optional
Schnittstellenkörper
Tabelle 6.37: Schnittstellendeklaration
Zwingend
Datenfelddeklaration Eine Datenfelddeklaration besteht immer aus fünf Teilen, die in der nachfolgend in der Tabelle angegebenen Reihenfolge zusammengesetzt werden. Bestandteil
Status
Beschreibung
Datenfeldmodifier
Optional
Dies sind die Schlüsselworte public, protected, private oder synchronized.
Typenname
Zwingend
Der Name des Typen oder der Klasse, die aufgestellt werden.
Klammern
Zwingend
[ ].
Initialisierung
Optional
Semikolon
Zwingend
Tabelle 6.38: Datenfelddeklaration
;
Objektdeklaration Ein Objekt zu deklarieren bedeutet, eine Referenz zu erstellen. Diese Referenz verweist nur dann auf ein Objekt, wenn dieses Objekt initialisiert oder dieser Referenz zugeordnet wurde. Eine Objektdeklaration besteht aus den folgenden Teilen:
Java 2 Kompendium
263
Kapitel 6 Tabelle 6.39: Objektdeklaration
Java – die Hauptbestandteile der Sprache
Bestandteil
Status
Beschreibung
Objektmodifier
Optional
Dies sind die Schlüsselworte public, protected, private oder synchronized.
Typenname
Zwingend
Der Name der Klasse, deren Instanz dieses Objekt ist.
Initialisierung
Optional
Semikolon
Zwingend
;
Deklaration primitiver Typen Eine Variable eines primitiven Typen zu deklarieren bedeutet, dass Speicherplatz für diese Variable eingerichtet wird. Wenn ihr kein Wert bei einer expliziten Initialisierung zugewiesen worden ist, nimmt sie ihren spezifischen Grundwert an. Die Deklaration von primitiver Datentypen setzt sich aus den folgenden Teilen zusammen: Tabelle 6.40: Deklaration primitiver Typen
Bestandteil
Status
Beschreibung
Datenfeldmodifier
Optional
Dies sind die Schlüsselworte public, protected, private oder synchronized.
Typenname
Zwingend
Die Bezeichnung des Datentyps: boolean, char, byte, short, int, long, float, double.
Initialisierung
Optional
Semikolon
Zwingend
6.5.5
;
Ausdrucksanweisungen
In Java gibt es wie bereits beschrieben sieben verschiedene Arten von Ausdrucksanweisungen.
264
Java 2 Kompendium
Anweisungen
Kapitel 6
Ausdrucksanweisungen
Beispiel
Zuordnung
a = 42
Pre-Inkrement
++wert
Pre-Dekrement
--wert
Post-Inkrement
wert++
Post-Dekrement
wert--
Methodenaufruf
System.out.println("Hello World!")
Zuweisungsausdruck
Byte wert = new Byte();
1.
Alle Ausdrucksanweisungen müssen mit einem Semikolon beendet werden.
2.
Eine Ausdrucksanweisung wird immer vollständig durchgeführt, bevor die nächste Anweisung ausgeführt wird.
3.
Eine Zuweisungsanweisung kann einen Ausdruck rechts von dem Gleichheitszeichen (dem Zuweisungsoperator =) stehen haben. Dieser Ausdruck kann jede der sieben Ausdrucksanweisungen sein. Es darf in Java immer nur die rechte Seite einer solchen Zuweisung festgelegt werden.
4.
Unter Umständen kann der Rückgabewert einer Methode, die nicht leer ist, ohne Zuweisung aufgerufen werden. Dazu muss der Rückgabewert explizit als void festgelegt werden.
5.
Eine Ausdrucksanweisung kann natürlich aus komplexen Verschachtelungen bestehen. Klammern können zur Festlegung der Reihenfolge dienen, in der die einzelnen Unteranweisungen bewertet werden.
6.5.6
Tabelle 6.41: Ausdrucksanweisungen
Auswahlanweisungen
Bei Auswahlanweisungen bleibt es gleichermaßen spannend, denn auch diese gehören zu den wichtigsten Anweisungen in einer Programmiersprache. Java unterstützt drei verschiedene Arten von Auswahlanweisungen: if if-else switch
Die if- und die if-else-Anweisung Eine if-Anweisung testet eine boolesche Variable oder einen Ausdruck. Wenn die boolesche Variable oder der Ausdruck den Wert true hat, wird
Java 2 Kompendium
265
Kapitel 6
Java – die Hauptbestandteile der Sprache die nachstehende Anweisung oder der nachstehende Anweisungsblock ausgeführt. Wenn die boolesche Variable oder der Ausdruck den Wert false hat, wird die nachstehende Anweisung oder der nachstehende Anweisungsblock ignoriert und mit dem folgenden Block bzw. der folgenden Anweisung fortgefahren. Eng verwandt ist die if-else-Anweisung, die genau genommen nur eine Erweiterung der if-Anweisung ist. Sie hat zusätzlich nur noch einen zusätzlichen else-Teil. Dieser else-Teil – eine Anweisung oder ein Block – wird dann ausgeführt, wenn der boolesche Test im if-Teil der Anweisung den Wert false ergibt. Ein kleines Beispiel zeigt die Verwendung.
Listing 6.20: Die Anwendung von if-else
import java.util.*; public class IfTest { public static void main(String args[]) { Random a = new Random(); if(a.nextFloat()<0.5) System.out.println("Klein"); else System.out.println("Gross"); } }
In dem Beispiel wird mit einem Zufallsobjekt gearbeitet. Die Methode nextFloat() extrahiert daraus den Zufallswert, der zwischen 0.0 und 1.0 liegt. Die nachfolgende if-else-Anweisung wird je nach Wert den ersten oder den zweiten Zweig auswählen. Wenn Sie innerhalb des else-Zweigs eine neue if-Anweisung notieren, haben Sie mit der resultierenden if-else-if-Anweisung einen Spezialfall der if-else-Anweisung. Schreiben wir unser Beispiel entsprechend um. Listing 6.21: Die Anwendung von if-else-if
import java.util.*; public class IfTest2 { public static void main(String args[]) { Random a = new Random(); if(a.nextFloat()<0.2) System.out.println("Ganz klein"); else if(a.nextFloat()<0.4) System.out.println("Klein"); else if(a.nextFloat()<0.6) System.out.println("Mittel"); else if(a.nextFloat()<0.8) System.out.println("Gross"); else System.out.println("Ganz Gross"); } }
Ein solches Konstrukt kann für eine etwas grö ß ere Auswahl von Möglichkeiten durchaus Sinn machen. Es gibt jedoch eine dann meist noch etwas besser geeignete Auswahlanweisung – die switch-Anweisung.
266
Java 2 Kompendium
Anweisungen
Kapitel 6
Die switch-Anweisung Eine switch-Anweisung ermöglicht das Weitergeben des Kontrollflusses an eine von vielen Anweisungen in ihrem Block mit Unteranweisungen. An welche Anweisung innerhalb der switch-Anweisung der Kontrollfluss weitergereicht wird, hängt vom Wert des Ausdrucks in der Anweisung ab. Es wird die erste Anweisung nach einer case-Bezeichnung ausgeführt, die denselben Wert wie der Ausdruck hat. Wenn es keine entsprechenden Werte gibt, wird die erste Anweisung hinter der default-Bezeichnung ausgeführt. Wenn auch die nicht vorhanden ist, wird die erste Anweisung nach dem switch-Block ausgeführt. Die zu testenden switch-Ausdrücke und caseBezeichnungskonstanten müssen alle vom Typ byte, short, char oder int sein. Mit dieser Auswahlanweisung haben Sie eine handlichere Auswahlanweisung, die oft die gleichen Möglichkeiten wie die Erweiterung der ifelse-Anweisung bietet. Einschränkung gegenüber dieser ist jedoch, dass nur diskrete Werte getestet werden können (also Gleichheit) und keine Vergleiche auf »kleiner« oder »grö ß er« möglich sind. Auch dürfen keine zwei caseBezeichnungen im gleichen Block denselben Wert haben. So etwas ist in der if-else-if-Anweisung im Prinzip denkbar (mehrfacher Vergleich in verschiedenen Zweigen auf den gleichen Wert), wenn auch nicht sonderlich sinnvoll, denn nach dem ersten Treffer werden folgende Treffer nicht mehr entdeckt, weil der Kontrollfluss aus der if-else-if-Anweisung herausspringt. Bezeichnungen beeinflussen den Kontrollfluß nicht. Die Kontrolle behandelt diese Bezeichnungen so, als seien sie nicht vorhanden. Daher können beliebig viele Bezeichnungen vor derselben Codezeile stehen. Schreiben wir unser Beispiel für die if-else-if-Anweisung um (beachten Sie, dass wir wegen der Datentypen mit dem Faktor 5 multiplizieren und casten). import java.util.*; public class SwitchTest { public static void main(String args[]) { Random a = new Random(); switch((byte)(a.nextFloat()*5)) { case 1: System.out.println("Ganz klein"); case 2: System.out.println("Klein"); case 3: System.out.println("Mittel"); case 4: System.out.println("Gross"); default: System.out.println("Ganz Gross"); } } }
Listing 6.22: Die Anwendung von switch-case
Was wird die Ausgabe sein? Vielleicht werden Sie überrascht. Im Gegensatz zu der if-else-if-Anweisung springt der Kontrollfluss nach einem Treffer nicht automatisch aus der Struktur, sondern es wird von dem ersten Treffer
Java 2 Kompendium
267
Kapitel 6
Java – die Hauptbestandteile der Sprache an die Struktur bis zum Ende ausgeführt. Das heißt, alle nachfolgend notierten Anweisungen werden explizit ausgeführt. Dies ist in diversen anderen Sprachen anders und damit lauert hier eine gefährliche Fehlerquelle. Wenn dieses Verhalten unterbunden werden soll, setzt man in jedem Block hinter einem Label eine break-Anweisung. Damit vermeiden Sie die Ausführung von mehr als einem Block. Die gesamte switch-case-Struktur wird nach einem Treffer beendet. Unser Beispiel sieht dann so aus:
Listing 6.23: Die Anwendung von switch-case in Verbindung mit break
import java.util.*; public class SwitchTest2 { public static void main(String args[]) { Random a = new Random(); switch((byte)(a.nextFloat()*5)) { case 1: { System.out.println("Ganz klein"); break; } case 2: { System.out.println("Klein"); break; } case 3: { System.out.println("Mittel"); break; } case 4: { System.out.println("Gross"); break; } default: { System.out.println("Ganz Gross"); break; } } } }
Natürlich können Sie Breaks auch gezielt einsetzen, um durch Auslassen von break-Anweisungen den Durchlauf von mehreren Blöcken zu erreichen. Etwa bei einer angeordneten Auswahl, wo ab einer gewissen Grö ß e alle Folgeanweisungen Sinn machen.
268
Java 2 Kompendium
Anweisungen
6.5.7
Kapitel 6
Iterationsanweisungen
Iterationsanweisungen werden auch Wiederholungsanweisungen genannt und dieser Name macht deutlich, um was es geht: die kontrollierte Wiederholung von Anweisungsfolgen zur Laufzeit. Es gibt in Java drei Arten von Iterationsanweisungen: while do for
Diese sind fast identisch zu den analogen Anweisungen in C und C++, mit der Ausnahme, dass in Java die Anweisungen die optionalen Parameter continue und break haben. Die while-Anweisungen Die while-Anweisung testet eine boolesche Variable oder einen Ausdruck. Solange der Test den Wert true hat, wird die Unteranweisung oder der Block ausgeführt. Erst wenn die boolesche Variable oder der Ausdruck den Wert false ausweist, wird die Wiederholung eingestellt und die Kontrolle an die nächste Anweisung nach dem while-Konstrukt weitergegeben. Die Syntax sieht so aus: while()
Erstellen wir wieder ein kleines Testprogramm. class WhileTest { public static void main (String args[]) { int testvariable=0; // Eine numerische Variable while (testvariable < 5) { System.out.println(testvariable); testvariable = testvariable + 1; } System.out.println("Und Schluss"); } }
Listing 6.24: Eine while-Schleife
Die Ausgabe wird die Zahlenkolonne von 0 bis 4 und danach Und Schluss sein. Um die while-Schleife jemals verlassen zu können, wird der Wert der Testvariablen in jedem Schleifendurchgang um den Wert 1 erhöht. Wenn der Ausdruck nicht von Anfang an true ist, wird der Block in der Unteranweisung niemals ausgeführt. Wenn er dahingegen true ist, dann wird dieser Codeblock so lange wiederholt, bis er nicht mehr true ist, oder
Java 2 Kompendium
269
Kapitel 6
Java – die Hauptbestandteile der Sprache eine Sprung-Anweisung ausgeführt wird, und er die Kontrolle an eine Anweisung außerhalb der Schleife weitergibt. Eine while-Schleife ist ein guter Kandidat für so genannte Endlosschleifen. Lassen Sie in unserem Beispiel einfach mal die Zeile testvariable = testvariable + 1; weg. Die Bedingung zum Durchlaufen der Schleife wird immer erfüllt sein und Sie hängen in einer Endlosschleife. Mit ein bisschen Glück lässt sich das Programm noch vom Betriebssystem beenden, mit Pech müssen Sie den Rechner ausschalten. Die do-Anweisung Auch die do-Anweisung (oder auch do-while-Anweisung genannt) testet eine boolesche Variable oder einen Ausdruck. Solange dieser Test den Wert true hat, wird die Unteranweisung oder der Block ausgeführt. Erst wenn die boolesche Variable oder der Ausdruck den Wert false ausweist, wird die Wiederholung eingestellt und die Schleife verlassen. Es gibt aber einen ganz wichtigen Unterschied zur while-Schleife: der Codeblock innerhalb der doAnweisung wird auf jeden Fall mindestens einmal ausgeführt. Dies geschieht immer, ob die Bedingung erfüllt ist oder nicht. Rein von der Syntax her kann man es sich dadurch verdeutlichen, dass die Überprüfung am Ende der Struktur steht. Sie sieht immer so aus: do while()
Programmbeispiel: Listing 6.25: Eine do-Schleife
import java.util.*; class DoTest { public static void main (String args[]) { byte testvariable=0; // Eine numerische Variable Random a = new Random(); do { System.out.println(testvariable); testvariable = (byte)(a.nextFloat()*5); } while (testvariable < 3); System.out.println("Und Schluss"); } }
Das Beispiel wiederholt so lange die Schleife, bis die zufällig generierte Testvariable grö ß er als 3 ist. Die do-Schleife wird aber auf jeden Fall einmal durchlaufen.
270
Java 2 Kompendium
Anweisungen
Kapitel 6
Die for-Anweisung Die for-Anweisungen sind uns ja schon ein paar Mal begegnet. Es sind die komplexesten der drei Iterationsanweisungen. Eine for-Anweisung sieht wie folgt aus: for (; ;)
Einige Erklärungen zu der Syntax: 1.
Hinter for kann optional ein Leerzeichen folgen.
2.
Der Initialisierungsteil kann eine durch Kommata getrennte Reihe von Deklarations- und Zuweisungsanweisungen enthalten. Erst durch ein Semikolon wird der Initialisierungsteil beendet. Diese Deklarationen haben nur Gültigkeit für den Bereich der for-Anweisung und ihrer Unteranweisungen.
3.
Der Testteil enthält eine boolesche Variable oder einen Ausdruck, der einmal pro Schleifendurchlauf neu bewertet wird. Wenn der Vergleich den Wert false ergibt, wird die for-Schleife verlassen. Auch dieser Teil wird wieder durch ein Semikolon beendet.
4.
Auch der In- oder Dekrementteil kann eine durch Kommata getrennte Reihe von Ausdrücken sein, die einmal pro Durchlauf der Schleife bewertet werden. Diese mehrfachen Ausdrücke in diesem Teil der forSchleife machen nur dann Sinn, wenn sie bereits im Initialisierungsteil deklariert wurden. Dieser Teil wird gewöhnlich dazu verwendet, einen Index, der im Testteil überprüft wird, zu inkrementieren (hochzuzählen) oder zu dekrementieren (herabzuzählen).
Nutzen wir zur praktischen Veranschaulichung der for-Schleife ein Beispiel, das die Summe einer Reihe von 1 bis zu einem vorgegebenen Endwert berechnet. /* Berechnet die Summe einer Reihe mit vorgegebener Zahl über eine forSchleife – eine Alternative zu der echten Gauss-Formel */ class Gauss { public static void main(String argv[]) { long ergebnis=0; int ende=70; for (int i=1;i<=ende;i++) { ergebnis += i; } System.out.println("Ergebnis Summe 1 bis " + ende + ": "+ergebnis); } }
Java 2 Kompendium
Listing 6.26: Reihenberechnung – Variante 1
271
Kapitel 6
Java – die Hauptbestandteile der Sprache Das Beispiel arbeitet in der Schleife mit so genannten schleifenlokalen Variablen. Das bedeutet in unserem Fall, dass die Zählvariablen in for-Schleifen nicht unbedingt außerhalb der Schleife vereinbart werden müssen, sondern ebenso direkt im Initialisierungsteil der for-Schleife direkt vereinbart werden können. Sie sind dann auch nur dort bekannt. Diese im Initialisierungsteil der for-Schleife direkt vereinbarten Zählvariablen sind ein Sonderfall von normalen lokalen Variablen und überdecken ggf. gleichnamige Variablen im übergeordneten Programmblock. Die Variablen im übergeordneten Programmblock bleiben hierdurch unverändert. Die Berechnung der Summe einer Reihe geht natürlich viel eleganter, wenn man die echte Gauß-Formel verwendet. Das könnte dann so aussehen:
Listing 6.27: Reihenberechnung – Variante 2
/* Berechnet die Summe einer Reihe mit vorgegebener Zahl nach der GaussFormel */ class Gauss2 { public static void main(String argv[]) { int n; long x; n = 70; x = (long)((n+1) / 2.0 * n ); System.out.println("Ergebnis Summe 1 bis "+n+": "+x); } }
Die Schleife for(;;), d.h. ohne explizite Parameter, wird keinen Compilerfehler erzeugen, denn syntaktisch ist sie völlig korrekt. Analog der Syntax while(true) wird sie eine Endlosschleife erzeugen.
6.5.8
Java-Sprunganweisungen
Ähnlich dem alten goto-Befehl gibt es auch in Java Sprunganweisungen. Diese unterbrechen einen jeweiligen Programmablauf und übergeben den Programmfluss an eine andere Stelle. Java kennt vier Arten von Sprunganweisungen: break continue return throw
Die break-Anweisung Die Unteranweisungsblöcke von Schleifen und switch-Anweisungen können durch die Verwendung der break-Anweisung verlassen werden (wir haben es im Beispiel der switch-Anweisungen ja schon gesehen). Eine unbezeichnete break-Anweisung springt zu der nächsten Zeile nach der derzeitigen (inners-
272
Java 2 Kompendium
Anweisungen
Kapitel 6
ten) Wiederholungs- oder switch-Anweisung. Als Beispiel soll hier auf das Beispiel bei der Behandlung von switch-case verwiesen werden (siehe Seite 267). Mit einer bezeichneten break-Anweisung am Anfang einer Schleife kann an eine Anweisung mit dieser Bezeichnung in der derzeitigen Methode gesprungen werden. Dazu müssen Sie vor dem Anfangsteil der Schleife ein Label (eine Beschriftung) mit einem Doppelpunkt eingeben. Sofern Sie ein falsch gesetztes oder nicht vorhandenes Label in einer Sprunganweisung angeben, wird der Compiler eine Fehlermeldung ausgeben. Wenn es beim Auslösen der break-Anweisung eine umgebende Ausnahmebehandlungsroutine mit finally-Teil gibt, wird immer dieser Teil zuerst ausgeführt, bevor die Kontrolle weitergegeben wird. Richtig interessant werden die benannten Schleifen aber eigentlich erst in Verbindung mit verschachtelten Schleifen. Es wird Ihnen vielleicht auffallen, dass diese bezeichneten Anweisungen ziemlich an das goto-return-Konstrukt aus alten Programmiererzeiten erinnern. Diese Assoziation ist leider nicht ganz von der Hand zu weisen, denn für ein solches Verfahren lässt sie sich missbrauchen. Glücklicherweise sind mit diesen Konstrukten keine beliebigen Sprünge innerhalb des Programms erlaubt, sondern es lassen sich in Java immer nur Sprünge über mehrere Blöcke innerhalb einer Schleife durchführen. Die continue-Anweisung Durch die Anweisung continue wird im Gegensatz zu break nicht die gesamte Schleife abgebrochen, sondern der aktuelle Schleifendurchlauf wird unterbrochen. Es wird zum Anfang der Schleife zurückgekehrt, falls hinter continue kein Bezeichner steht. Ansonsten wird zu einer äußer