Table Of Content

Joach im Goll Cornelia Weiß Frank Müller Java als erste Prog ram mi ersprache Vom Einsteiger zum Profi 3., durchgesehene und erweiterte Auflage Teubner B. G. Teubner Stuttgart· Leipzig· Wiesbaden Die Deutsche Bibliothek - CIP-Einheitsaufnahme Ein Titeldatensatz für diese Publikation ist bei Der Deutschen Bibliothek erhältlich. Prof. Dr. Joachim GolI, Jahrgang 1947, unterrichtet seit 1991 im Fachbereich Informationstechnik der Fachhochschule Esslingen - Hochschule für Technik (FHTE) Programmiersprachen, Betriebssysteme, Soft ware Engineering und Objektorientierte Modellierung. Während seiner beruflichen Tätigkeit in der Industrie befasste er sich vor allem mit dem Entwurf von Verteil ten Informationssystemen. Prof. Goll ist Leiter des Stein beis-Transferzentrums Softwaretechnik Esslingen. Cornelia Weiß, MSc, Jahrgang 1976, studierte Soft waretechnik an der FHTE. Seit ihrem Diplom im Jahre 1999 ist sie Lehrbeauftragte für Objektorientierte Modellierung an der FHTE. Cornelia Weiß arbeitet seit 1999 beim Steinbeis-Transferzentrum Softwaretechnik als System Designerin für Verteilte Objektorientiere Systeme. Sie ist Lehrbeauftragte an der Brunel Uni versity of West-London für Java. Frank Müller, MSc, Jahrgang 1969, studierte Soft waretechnik an der FHTE nach Lehre und Beruf. Seit seinem Diplom im Jahre 1999 arbeitet Herr Müller als System Designer für Verteilte Objektorientierte Systeme beim Steinbeis-Transferzentrum Softwaretechnik. Er ist Lehrbeauftragter für die Vorlesung eCommerce an der FHTE und für Kommunikation in Verteilten Systemen an der Brunel University of West-London. Im vorliegenden Buch erwähnte Produkt-und Firmennamen wie Borland, IBM, MS-DOS u. a. sind gesetzlich geschützt, ohne dass im einzelnen darauf hingewiesen wird. 1. Auflage Januar 2000 2., durchges. Auflage Oktober 2000 3., durchges. und erweiterte Auflage September 2001 ISBN 978-3-322-94125-1 ISBN 978-3-322-94124-4 (eBook) DOI 10.1007/978-3-322-94124-4 Alle Rechte vorbehalten © B. G. Teubner StuttgartiLeipzig/Wiesbaden, 2001 Softcover reprint ofthe hardcover 3rd edition 2001 Der Verlag Teubner ist ein Unternehmen der Fachverlagsgruppe BertelsmannSpringer. www.teubner.de Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede Verwertung außerhalb der engen Grenzen des Urheberrechtsgesetzes ist ohne Zustimmung des Verlags unzulässig und strafbar. Das gilt insbesondere für Vervielfältigungen, Übersetzungen, Mikroverfilmungen und die Einspeicherung und Verarbeitung in elektronischen Systemen. Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Waren und Markenschutz Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften. Umschlaggestaltung: Ulrike Weigel, www.CorporateDesignGroup.de Umschlagfoto: Reinhard Tierfoto, Hans Reinhard, Heiligkreuzsteinach Gedruckt auf säurefreiem und chlorfrei gebleichtem Papier Vorwort Innerhalb kürzester Zeit hat Java die Programmierung revolutioniert. Java ist eine Sprache, die basierend auf C und C++ die Tradition dieser führenden Program miersprachen in einer neuartigen und überraschenden Weise fortsetzt. So kann ein Java-Programm auf jedem beliebigen Rechner weltweit ohne irgendeine Änderung laufen, wenn für den entsprechenden Rechner eine virtuelle Maschine verfügbar ist. Für die Programmierung im Internet bietet Java die Technik der Applets, d.h. von kleinen Programmen, die in einer Web-Seite laufen. Diese Technik erlaubt es, von irgendeinem Rechner des Internets auf seinen eigenen Rechner Web-Seiten mit Applets zu laden und diese Applets lokal im Browser des eigenen Rechners auszu führen. Java findet seinen Einsatz jedoch nicht nur in Netzen, sondern auch als universell einsetzbare Programmiersprache für die verschiedensten Aufgaben steIlungen. Das vorliegende Buch setzt weder C noch C++ Kenntnisse voraus. Es erlaubt dem Einsteiger, Java ohne Vorkenntnisse anderer Programmiersprachen zu erlernen. Daher der Titel .Java als erste Programmiersprache". Dabei hat dieses Buch das ehrgeizige Ziel, dem Neuling die Sprachkonzepte von Java und die Grundkonzepte der objektorientierten Programmierung so präzise wie möglich und dennoch in leicht verständlicher Weise vorzustellen. Für den erfahrenen C++ Programmierer lohnt sich ein Blick in Anhang D, wo die wesentlichen Unterschiede zwischen C++ und Java übersichtlich dargestellt sind. "Lernkästchen", auf die grafisch durch eine kleine Glühlampe aufmerksam gemacht wird, stellen eine Zusammenfassung eines Kapitels dar. Sie erlauben eine rasche Wiederholung des Stoffes. Ein fortgeschrittener Leser kann mit ihrer Hilfe gezielt bis zu der Stelle vorstoßen, an der für ihn ein detaillierter Einstieg erforderlich wird. Um sowohl einem Neuling als auch einem erfahrenen Programmierer gerecht werden zu können, sind in dieser Auflage Abschnitte, die eine Vertiefung darstellen, mit dem Symbol gekennzeichnet. Diese Abschnitte stellen für das Folgende keine Voraussetzung dar. Sie können deshalb vom Einsteiger beim ersten Durchlauf übersprungen werden, um rasch einen Überblick über die ganze Breite von Java zu erhalten. Die Vertiefungs abschnitte können dann bei Bedarf herangezogen werden. Bereits nach einem Jahr wurde erfreulicherweise eine 3. Auflage erforderlich, in die die Neuerungen des JDK1.3 mit aufgenommen wurden. Unser Dank gilt einer Vielzahl von fleißigen Helfern, die durch ihren Einsatz an der Qualität des Buches in einem hohen Maße beteiligt waren. Ein besonderer Dank gilt Thorsten Beise, Oliver Bühler, Olaf Fischer, Thomas Fischer, Andreas Gottschol, Jens Härer, Axel Hallwachs, Thomas Rüter, Heiner Seifried, Thomas Vollmer und Johannes-Markus Waizenegger, die an der Erstellung von einzelnen Kapiteln - sei es durch Materialsammlungen, Tips und vieles mehr - mit beteiligt waren. Kein Buch - auch nicht dieses - sollte ohne sorgfältiges Korrekturlesen außer Hause gehen. Bei dieser zeitintensiven Aufgabe haben uns Prof. Dr. Ulrich Bröckl-Fox, Prof. Dr. Manfred Dausmann und Thomas Gehrung sehr geholfen. Für die Erstellung der Grafiken und HTML-Seiten richtet sich unser Dank an Heinrich Plener und Sascha Heinisch. Ein besonderer Dank gilt an dieser Stelle Peter Rothländer, der als Co-Autor an den ersten beiden Auflagen dieses Buches mitgeschrieben hat. Peter Rothländer studierte Nachrichtentechnik an der FHTE. Nach seinem Diplom im Jahre 1997 arbeitete Peter Rothländer beim Steinbeis-Transferzentrum Software technik Esslingen als Projektleiter für Verteilte Systeme unter Java. Er baute bereits ab Frühjahr 1997 die Java-Vorlesung an der FHTE auf. Seit dem Jahre 2000 arbeitet er als Chef-Designer für DaimlerChrysler an der Konzeption und Realisierung von eCommerce Frameworks und ist zur Zeit mit der technischen Leitung eines Projektes in den USA beauftragt. Esslingen, im Mai 2001 J. Goll / C. Weiß / F. Müller Unterstützt durch die Competence-Center "Engineering Data Management" und "Document Management Solutions" der Firma T-Systems debis Systemhaus Industry zur Förderung des Ingenieur- und Informatik-Nachwuchses an Schulen, Fachhochschulen und Universitäten Wegweiser durch das Buch Gerade als Anfänger in einer Programmiersprache macht man gerne den Fehler, sich beim Lesen an nicht ganz so wesentlichen Einzelheiten fest zu beißen. Um zu erkennen, welche Information. grundlegend für das weitere Vorankommen ist und welche Information nur ein Detailwissen darstellt - und deshalb auch noch zu einem späteren Zeitpunkt vertieft werden kann - weist dieses Buch Kapitel oder Kapitelteile, die beim ersten Lesen übersprungen werden können, mit dem SymbollC aus. Generell ist es empfehlenswert, ein oder mehrere Kapitel zu überfliegen, um sich einen Überblick zu verschaffen, und dann erst mit der Feinarbeit zu beginnen und gründlicher zu lesen. Dennoch gilt: Eine Vorgehensweise, die sich für den einen Leser als optimal erweist, muss noch lange nicht für alle Leser das Allheilmittel darstellen. Wenn Sie zu den Lesern gehören, die es gewohnt sind, von Anfang an möglichst detailliert zu lesen, um möglichst viel sofort zu verstehen, so sollten Sie zumindest darauf achten, dass Sie in den Kapiteln mit dem "Überspringe und komm zurück"-Zeichen beim ersten Durchgang nicht zu lange verweilen. Bei all den guten Ratschlägen gilt: Programmieren hat man zu allen Zeiten durch Programmierversuche erlernt. ,,00 it yourself' heißt der rote Faden zum Erfolg. So wie ein Kleinkind beim Erlernen der Muttersprache einfach zu sprechen versucht, so sollten auch Sie möglichst früh versuchen, in der Programmiersprache zu sprechen - das heißt, eigene Programme zu schreiben. Gestalten Sie den Lernvorgang abwechslungsreich - lesen Sie einen Teil und versuchen Sie, das Erlernte im Programmieren gleich umzusetzen. Um die mühsame Tipparbeit am Anfang minimal zu halten, sind alle Beispielprogramme des Buches im Internet unter der Adresse http://www.it.fht-esslingen.de/javabuch zu finden. Zur weiteren Vertiefung der einzelnen Kapitel finden Sie unter der genannten Adresse auch kapitel bezogene Übungsaufgaben und Lösungen. Die nachfolgende Tabelle soll es dem Leser erleichtern, einzuordnen, welche Kapitel zu den Grundlagen (Symbol QI) zählen und auf jeden Fall verstanden werden sollten, welche Kapitel zuerst übersprungen werden können und dann bei Bedarf gelesen werden sollten (Symbol lO) und welche Kapitel reine fortgeschrittenen Themen (Symbol ~ behandeln, die unabhängig voneinander gelesen werden können. 1 Grundbegriffe der Programmierung 2 Einführung in die Programmiersprache Java 3 Lexikalische Konventionen 4 Einfache Beispielprogramme 5 Datentypen und Variablen 6 Ausdrücke und Operatoren 7 Kontrollstrukturen 8 Blöcke und Methoden 9 Klassen und Objekte 10 Vererbung und Polymorphie 11 Pakete 12 Ausnahmebehandlung - Exception Handling 13 Schnittstellen 14 Geschachtelte Klassen 15 Ein-/Ausgabe und Streams 16 Collections 17 Threads 18 Die Architektur der Virtuellen Maschine 19 Das Java Native Interface 20 Applets 21 Oberflächen programmierung mit Swing 22 Sicherheit in Java 23 Beans 24 Servlets 25 Netzwerkprogrammierung mit Sockets 26 Remote Method Invocation 27 JDBC Schreibweise In diesem Buch sind der Quellcode und die Ein-/Ausgabe von ganzen Beispiel programmen sowie einzelne Anweisungen und Ein-/Ausgaben in der Schriftart Courier New geschrieben. Dasselbe gilt für Programmteile wie Variablennamen, Funktionsnamen etc., die im normalen Text erwähnt werden. Einige Programm beispiele enthalten Platzhalter wie Anweisung oder Bedingung für konkrete Anweisungen oder Ausdrücke in der Programmiersprache. Ihre Rolle als Platzhalter ist jedoch so offensichtlich, dass für sie keine eigene Schriftart verwendet wurde. Sie sind wie die Wörter der Sprache in Courier New geschrieben. Wichtige Begriffe im normalen Text sind fett gedruckt, um sie hervorzuheben. Beispielprogramme und Bilder, sowie Aufgaben und Lösungen zu den einzelnen Kapiteln aus diesem Buch finden Sie unter http://www.it.fht-esslingen.de/javabuch Ihre Verbesserungsvorschläge und kritischen Hinweise, die wir gerne annehmen, erreichen uns unter der Adresse: Joachim Goll Fachhochschule Esslingen - Hochschule für Technik, Fachbereich Informationstechnik Flandernstraße 101 73732 Esslingen oder via email: [email protected] Inhaltsverzeichnis 1 GRUNDBEGRIFFE DER PROGRAMMIERUNG ............................................. 2 1.1 Probleme und Algorithmen .........................................................................................................2 1.2 Entwicklung der höheren Programmiersprachen ..................................................................... 14 1.3 Der objektorientierte Ansatz ..................................................................................................... 18 2 EINFÜHRUNG IN DIE PROGRAMMIERSPRACHE JAVA ........................... 40 2.1 Sprachkonzepte von Java ....................................................................................................... .40 2.2 Eigenschaften von Java .......................................................................................................... .41 2.3 Die Java-Plattform ....................................................................................................................4 2 2.4 Programmerzeugung und -ausführung .....................................................................................4 8 2.5 Die Entwicklung von Java-Programmen mit dem Java Development Kit... .............................. 54 2.6 Java-Anwendungen, Java-Applets und Java-Script ................................................................. 57 2.7 Klassen in Java ........................................................................................................................5 8 2.8 Starten von Java-Anwendungen und von Java-Applets ........................................................... 58 3 LEXIKALISCHE KONVENTIONEN ............................................................... 62 3.1 Zeichenvorrat von Java ............................................................................................................6 2 3.2 Lexikalische Einheiten ..............................................................................................................6 5 4 EINFACHE BEISPIELPROGRAMME ........................................................... 82 4.1 Das Programm .Hello, world" ...................................................................................................8 2 4.2 Programm zur Umrechnung von Fahrenheit in Celsius ............................................................ 84 4.3 Zeichenzählprogramm ..............................................................................................................8 8 4.4 Klasse Punkt mit Konstruktor ...................................................................................................9 1 5 DATENTYPEN UND VARIABLEN ................................................................ 96 5.1 Datentypen ...............................................................................................................................9 6 5.2 Variablen ................................................................................................................................ 10 6 5.3 Modifikatoren .......................................................................................................................... 121 5.4 Arrays .....................................................................................................................................1 22 5.5 Konstante und variable Zeichen ketten ................................................................................... 134 5.6 Wrapper-Klassen .................................................................................................................... 144 5.7 Verkettung von Strings und Variablen anderer Datentypen ................................................... 147 6 AUSDRÜCKE UND OPERATOREN ........................................................... 150 6.1 Operatoren und Operanden ................................................................................................... 150 6.2 Ausdrucke und Anweisungen ................................................................................................. 152 6.3 Nebeneffekte .......................................................................................................................... 153 VIII Inhaltsverzeichnis 6.4 Auswertungsreihenfolge .........................................................................................................1 54 6.5 L-Werte und R-Werte ............................................................................................................. 156 6.6 Zusammenstellung der Operatoren ........................................................................................ 157 6.7 Konvertierung von Datentypen ............................................................................................... 175 6.8 Ausführungszeitpunkt von Nebeneffekten .............................................................................. 184 7 KONTROLLSTRUKTUREN ......................................................................... 188 7.1 Blöcke - Kontrollstrukturen für die Sequenz .......................................................................... 188 7.2 Selektion ................................................................................................................................. 188 7.3 Iteration ................................................................................................................................... 194 7.4 Sprunganweisungen ............................................................................................................... 199 8 BLÖCKE UND METHODEN ........................................................................ 204 8.1 Struktur eines Blockes ............................................................................................................2 04 8.2 Die leere Anweisung ...............................................................................................................2 05 8.3 Lokale Variablen .....................................................................................................................2 05 8.4 Schachtelung von Blöcken ..................................................................................................... 206 8.5 Gültigkeit, Sichtbarkeit und Lebensdauer ............................................................................... 207 8.6 Methoden ................................................................................................................................2 09 8.7 Übergabe von Parametern beim Programmaufruf ................................................................. 225 8.8 Iteration und Rekursion ..........................................................................................................2 26 9 KLASSEN UND OBJEKTE ......................................................................... 232 9.1 Information Hiding ..................................................................................................................2 32 9.2 Klassenvariablen und Klassenmethoden - das Schlüsselwort static ..................................... 234 9.3 Die this-Referenz ....................................................................................................................2 39 9.4 Initialisierung von Datenfeldem ..............................................................................................2 45 9.5 Instantiierung von Klassen .....................................................................................................2 61 9.6 Freigabe von Speicher ...........................................................................................................2 64 9.7 Die Klasse Object ...................................................................................................................2 67 9.8 Die Klasse Class ....................................................................................................................2 68 10 VERERBUNG UND POLyMORPHIE .......................................................... 272 10.1 Das Konzept der Vererbung ................................................................................................... 272 10.2 Polymorphie und das Liskov Substitution Principle ................................................................ 277 10.3 Konstruktoren bei abgeleiteten Klassen ................................................................................. 284 10.4 Typkonvertierung von Referenzen .........................................................................................2 88 10.5 Verdecken und Überschreiben ............................................................................................... 295 10.6 Verträge von Methoden ..........................................................................................................3 13 10.7 Identifikation der Klasse eines Objektes ................................................................................. 318 Inhaltsverzeichnis IX 10.8 Abstrakte Basisklassen ..........................................................................................................3 23 10.9 Konsistenzhaltung von Quell-und Bytecode ..........................................................................3 25 11 PAKETE ....................................................................................................... 330 11.1 .Programmierung im Großen" ................................................................................................ 330 11.2 Pakete als Entwurfseinheiten ................................................................................................. 332 11.3 Erstellung von Paketen ...........................................................................................................3 33 11.4 Benutzung von Paketen ......................................................................................................... 335 11.5 Paketnamen ...........................................................................................................................3 37 11.6 Gültigkeitsbereich von Klassennamen ................................................................................... 341 11.7 Zugriffsmodifikatoren ..............................................................................................................3 43 12 AUSNAHMEBEHANDLUNG - EXCEPTION HANDLING .......................... 352 12.1 Das Konzept des Exception Handlings ..................................................................................3 52 12.2 Implementierung von Exception-Handlem in Java ................................................................. 354 12.3 Ausnahmen vereinbaren und auswerfen ................................................................................3 58 12.4 Die Exception-Hierarchie ........................................................................................................3 60 12.5 Ausnahmen behandeln ...........................................................................................................3 63 12.6 Einschränkungen beim Überschreiben von Methoden ........................................................... 370 12.7 Vorteile des Exception-Konzeptes ..........................................................................................3 70 13 SCHNITTSTELLEN ..................................................................................... 372 13.1 Trennung von Spezifikation und Implementierung ................................................................. 372 13.2 Ein weiterführendes Beispiel ..................................................................................................3 74 13.3 Aufbau einer Schnittstelle .......................................................................................................3 78 13.4 Verwenden von Schnittstellen ................................................................................................3 81 13.5 Vergleich Schnittstelle und abstrakte Basisklasse ................................................................. 393 13.6 Das InterfaceCloneable .........................................................................................................3 96 13.7 Das Interface COmparable ...................................................................................................... 402 14 GESCHACHTELTE KLASSEN ................................................................... 408 14.1 Elementklassen ......................................................................................................................4 1 0 14.2 Lokale Klassen .......................................................................................................................4 15 14.3 Anonyme Klassen ...................................................................................................................4 19 14.4 Statische geschachtelte Klassen und statische geschachtelte Schnittstellen ........................ 423 14.5 Realisierung von geschachtelten Klassen ..............................................................................4 25 15 EIN-/AUSGABE UND STREAMS ................................................................ 432 15.1 Ein-und Ausgabe ...................................................................................................................4 32 15.2 Streams .................................................................................................................................. 434 15.3 Klassifizierung von Stream-Klassen .......................................................................................4 35 15.4 Einteilung der Stream-Klassen ................................................ ,. .............................................4 41 X Inhaltsverzeichnis 15.5 Ein-und Ausgabe von Bytes ..................................................................................................4 52 15.6 Ein-und Ausgabe von Daten primitiver Typen .......................................................................4 56 15.7 Standardeingabe und Standardausgabe ................................................................................4 59 15.8 Ein-und Ausgabe von Zeichen ..............................................................................................4 60 15.9 Ein-und Ausgabe von Objekten ............................................................................................. 465 16 COLLECTIONS ............................................................................................ 474 16.1 Listen ......................................................................................................................................4 75 16.2 Collections ohne Duplikate - Sets .......................................................................................... 488 16.3 Collections mit Schlüssel-Wert-Paaren - Maps .................................................................... .492 17 THREADS .................................................................................................... 498 17.1 Zustände und Zustandsübergänge von Betriebssystem-Prozessen ...................................... 503 17.2 Zustände und Zustandsübergänge von Threads .................................................................... 504 17.3 Programmierung von Threads ................................................................................................ 507 17.4 Scheduling von Threads .........................................................................................................5 15 17.5 Zugriff auf gemeinsame Ressourcen ......................................................................................5 16 17.6 Daemon-Threads ....................................................................................................................5 38 18 DIE ARCHITEKTUR DER VIRTUELLEN MASCHINE ................................ 542 18.1 Ausführungs-Maschine ...........................................................................................................5 43 18.2 Method-Area ...........................................................................................................................5 44 18.3 Klassenlader ...........................................................................................................................5 44 18.4 Bytecode-Verifier ....................................................................................................................5 46 18.5 Native Method Linker.. ............................................................................................................5 47 18.6 Garbage Collected Heap ........................................................................................................5 47 18.7 Security Manager und Access Controller ............................................................................... 547 19 DAS JAVA NATIVE INTERFACE ............................................................... 550 19.1 Aufruf und Implementierung von nativen Methoden ............................................................... 552 19.2 Architektur des Java Native Interface ..................................................................................... 557 19.3 Namensraum von nativen Methoden ...................................................................................... 561 19.4 Namenskonventionen .............................................................................................................5 63 19.5 Java-Datentypen und native Datentypen ............................................................................... 565 19.6 Zugriff auf Java-Methoden in nativem Code ........................................................................... 568 20 APPLETS ..................................................................................................... 582 20.1 Die Seitenbeschreibungssprache HTML ................................................................................ 583 20.2 Das .Hello, world·-Applet... ..................................................................................................... 593 20.3 Der Lebenszyklus eines Applets ............................................................................................ 595 20.4 Parameterübemahme aus einer HTML-Seite .........................................................................5 99