Verfügbarkeit: Handbuch der Java-Programmierung | Technische Universität München

Handbuch der Java-Programmierung: Standard-Edition Version 6

Gespeichert in:

Bibliographische Detailangaben
Beteiligte Personen:	Krüger, Guido (VerfasserIn), Stark, Thomas (VerfasserIn)
Format:	Buch
Sprache:	Deutsch
Veröffentlicht:	München Addison Wesley 2008
Ausgabe:	5. Aufl.
Schriftenreihe:	Programmer's Choice
Schlagwörter:	Java Standard Edition 7 Java Standard Edition 6 Java > Programmiersprache Java 2 Standard Edition 5.0 JDK 1.4
Links:	http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=015464546&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
Beschreibung:	auf DVD: [alle Beispiele aus dem Buch, die HTML-Ausgabe ; Java 6 SDK und Eclipse 3.3 ; ausgewählte Video-Trainings ; eBook "Masterclass Java EE 5"]
Umfang:	1327 S. Ill. 1 DVD (12 cm)
ISBN:	9783827323736 3827323738

Internformat

MARC


LEADER	00000nam a2200000 c 4500
001	BV022253794
003	DE-604
005	20221214
007	t\|
008	070202s2008 gw a\|\|\| \|\|\|\| 00\|\|\| ger d
015			\|a 07,N05,0016 \|2 dnb
016	7		\|a 982473540 \|2 DE-101
020			\|a 9783827323736 \|c Gb. : EUR 59.95, EUR 61.70 (AT), sfr 99.50 \|9 978-3-8273-2373-6
020			\|a 3827323738 \|c Gb. : EUR 59.95, EUR 61.70 (AT), sfr 99.50 \|9 3-8273-2373-8
024	3		\|a 9783827323736
035			\|a (OCoLC)229922481
035			\|a (DE-599)BVBBV022253794
040			\|a DE-604 \|b ger \|e rakddb
041	0		\|a ger
044			\|a gw \|c XA-DE-BY
049			\|a DE-859 \|a DE-29 \|a DE-91 \|a DE-1051 \|a DE-91G \|a DE-12 \|a DE-M347 \|a DE-739 \|a DE-523 \|a DE-83 \|a DE-11
082	0		\|a 005.133 \|2 22/ger
084			\|a ST 250 \|0 (DE-625)143626: \|2 rvk
084			\|a DAT 362f \|2 stub
084			\|a 68N15 \|2 msc
084			\|a 004 \|2 sdnb
100	1		\|a Krüger, Guido \|e Verfasser \|0 (DE-588)112915019 \|4 aut
245	1	0	\|a Handbuch der Java-Programmierung \|b Standard-Edition Version 6 \|c Guido Krüger ; Thomas Stark
250			\|a 5. Aufl.
264		1	\|a München \|b Addison Wesley \|c 2008
300			\|a 1327 S. \|b Ill. \|e 1 DVD (12 cm)
336			\|b txt \|2 rdacontent
337			\|b n \|2 rdamedia
338			\|b nc \|2 rdacarrier
490	0		\|a Programmer's Choice
500			\|a auf DVD: [alle Beispiele aus dem Buch, die HTML-Ausgabe ; Java 6 SDK und Eclipse 3.3 ; ausgewählte Video-Trainings ; eBook "Masterclass Java EE 5"]
650	0	7	\|a Java Standard Edition 7 \|0 (DE-588)7751205-4 \|2 gnd \|9 rswk-swf
650	0	7	\|a Java Standard Edition 6 \|0 (DE-588)7554591-3 \|2 gnd \|9 rswk-swf
650	0	7	\|a Java \|g Programmiersprache \|0 (DE-588)4401313-9 \|2 gnd \|9 rswk-swf
650	0	7	\|a Java 2 Standard Edition 5.0 \|0 (DE-588)4799436-8 \|2 gnd \|9 rswk-swf
650	0	7	\|a JDK 1.4 \|0 (DE-588)4669316-6 \|2 gnd \|9 rswk-swf
689	0	0	\|a Java Standard Edition 6 \|0 (DE-588)7554591-3 \|D s
689	0		\|5 DE-604
689	1	0	\|a Java \|g Programmiersprache \|0 (DE-588)4401313-9 \|D s
689	1		\|8 1\p \|5 DE-604
689	2	0	\|a Java 2 Standard Edition 5.0 \|0 (DE-588)4799436-8 \|D s
689	2		\|8 2\p \|5 DE-604
689	3	0	\|a JDK 1.4 \|0 (DE-588)4669316-6 \|D s
689	3		\|8 3\p \|5 DE-604
689	4	0	\|a Java Standard Edition 7 \|0 (DE-588)7751205-4 \|D s
689	4		\|8 4\p \|5 DE-604
700	1		\|a Stark, Thomas \|e Verfasser \|0 (DE-588)132250470 \|4 aut
856	4	2	\|m Digitalisierung UB Passau \|q application/pdf \|u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=015464546&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA \|3 Inhaltsverzeichnis
883	1		\|8 1\p \|a cgwrk \|d 20201028 \|q DE-101 \|u https://d-nb.info/provenance/plan#cgwrk
883	1		\|8 2\p \|a cgwrk \|d 20201028 \|q DE-101 \|u https://d-nb.info/provenance/plan#cgwrk
883	1		\|8 3\p \|a cgwrk \|d 20201028 \|q DE-101 \|u https://d-nb.info/provenance/plan#cgwrk
883	1		\|8 4\p \|a cgwrk \|d 20201028 \|q DE-101 \|u https://d-nb.info/provenance/plan#cgwrk
943	1		\|a oai:aleph.bib-bvb.de:BVB01-015464546

Datensatz im Suchindex

DE-BY-TUM_call_number	0002 DAT 362f 2006 B 618(5)
DE-BY-TUM_katkey	1614857
DE-BY-TUM_location	00
DE-BY-TUM_media_number	040006502278
_version_	1821932697958744064
adam_text	Inhaltsverzeichnis Vorwort ................................................ 25 Die Icons in diesem Buch............................. 31 Teil I Einleitung .......................... 33 ι Was ist Java? ...................................... 35 1.1 Historie .........................................35 1.2 Eigenschaften von Java ........................43 1.2.1 Sprachmerkmale .......................43 1.2.2 Applets: eine neue Klasse von Programmen ...........................45 1.2.3 Grafikprogrammiemng................46 1.2.4 Umfangreiche Klassenbibliothek......48 1.3 Bewertung......................................50 1.3.1 Einige weitverbreitete Missverständnisse......................50 1.3.2 Ausblick ................................52 1.4 Zusammenfassung.............................54 2 Schnelleinstieg .................................... 55 2.1 Installation des JDK............................55 2.1.1 Hard ware- Voraussetzungen...........55 2.1.2 Installation..............................56 2.2 Erste Gehversuche .............................59 2.2.1 Quelltext erstellen, übersetzen und ausführen...............................59 2.2.2 Die Beispielprogramme................64 2.3 Tipps für eigene Experimente .................65 2.3.1 Der Entwicklungszyklus in Kurzform 65 2.3.2 Einfache Ausgaben.....................66 2.3.3 Einfache Eingaben .....................67 2.3.4 Formatierung der Quelltexte ..........68 2.3.5 Namenskonventionen..................70 2.3.6 Aufruf von Java-Programmen unter Windows ...............................70 2.3.7 Troubleshooting ........................72 2.4 Zusammenfassung.............................75 3 Wie geht es weiter? ................................................................... 77 3.1 Wie sollte man dieses Buch lesen? ...................................................77 3.1.1 Zu welchem Typ Leser gehören Sie?.........................................77 3.1.2 Was ist der Inhalt der einzelnen Kapitel?....................................79 3.1.3 Wie geht es nun weiter? ......................................................81 3.2 Weiterführende Informationen.......................................................82 3.2.1 Die Dokumentation des JDK .................................................82 3.2.2 Informationen im Internet ....................................................84 3.2.3 Die HTML-Ausgabe ..........................................................87 3.2.4 Die im Buch verwendete UML-Notation ....................................90 3.3 Zusammenfassung .................................................................... 91 Teil M Grundlagen der Sprache .........................................93 4 Datentypen ............................................................................95 4.1 Lexikalische Elemente eines Java-Programms.......................................95 4.1.1 Eingabezeichen................................................................95 4.1.2 Kommentare................................................................... 96 4.1.3 Bezeichner .....................................................................97 4.1.4 Weitere Unterschiede zu С ...................................................97 4.2 Primitive Datentypen .................................................................97 4.2.1 Der logische Typ ..............................................................99 4.2.2 Der Zeichentyp................................................................99 4.2.3 Die integralen Typen.........................................................100 4.2.4 Die Fließkommazahlen ......................................................101 4.3 Variablen .............................................................................102 4.3.1 Grundeigenschaften .........................................................102 4.3.2 Deklaration von Variablen...................................................102 4.3.3 Lebensdauer/Sichtbarkeit ..................................................103 4.4 Arrays ................................................................................104 4.4.1 Deklaration und Initialisierung .............................................104 4.4.2 Zugriff auf Array-Elemente .................................................105 4.4.3 Mehrdimensionale Arrays ...................................................106 4.5 Referenztypen........................................................................108 4.5.1 Beschreibung .................................................................108 4.5.2 Speichermanagement ........................................................109 4.6 Typkonvertierungen .................................................................109 4.6.1 Standardkonvertierungen ...................................................109 4.6.2 Vorzeichenlose Bytes ........................................................111 4.7 Zusammenfassung...................................................................113 5 Ausdrücke ............................................................................ 115 5.1 Eigenschaften von Ausdrücken .....................................................115 5.2 Arithmetische Operatoren...........................................................117 5.3 Relationale Operatoren ..............................................................118 5.4 Logische Operatoren.................................................................119 5.5 Bitweise Operatoren .................................................................120 5.6 Zuweisungsoperatoren ..............................................................121 5.7 Sonstige Operatoren .................................................................122 5.7.1 Weitere Operatoren für primitive Typen ...................................122 5.7.2 Operatoren für Objekte ......................................................123 5.7.3 Welche Operatoren es nicht gibt ............................................127 5.8 Operator-Vorrangregeln.............................................................127 5.9 Zusammenfassung...................................................................131 6 Anweisungen ......................................................................... 133 6.1 Elementare Anweisungen ...........................................................133 6.1.1 Die leere Anweisung.........................................................133 6.1.2 Der Block .....................................................................133 6.1.3 Variablendeklarationen .....................................................134 6.1.4 Ausdrucksanweisungen .....................................................135 6.2 Verzweigungen ......................................................................135 6.2.1 Die if-Anweisung ............................................................135 6.2.2 Die switch-Anweisung.......................................................137 6.3 Schleifen..............................................................................139 6.3.1 Die while-Schleife ............................................................139 6.3.2 Die do-Schleife ...............................................................139 6.3.3 Die for-Schleife ...............................................................139 6.4 Sonstige Anweisungen ..............................................................144 6.4.1 Die assert-Anweisung .......................................................144 6.5 Zusammenfassung...................................................................151 Teil IM Objektorientierte Programmierung ............................ 153 7 OOP I: Grundlagen ................................................................... 155 7.1 Konzepte objektorientierter Programmiersprachen ................................155 7.1.1 Einführung ...................................................................155 7.1.2 Abstraktion...................................................................155 7.1.3 Kapselung ....................................................................157 7.1.4 Wiederverwendung..........................................................157 7.1.5 Beziehungen..................................................................158 7.1.6 Polymorphismus .............................................................161 7.1.7 Fazit...........................................................................162 7.2 Klassen und Objekte in Java.........................................................163 7.2.1 Klassen .......................................................................163 7.2.2 Objekte........................................................................163 7.3 Methoden.............................................................................164 7.3.1 Definition.....................................................................164 7.3.2 Aufruf ........................................................................165 7.3.3 Parameter.....................................................................166 7.3.4 Variable Parameterlisten ....................................................167 7.3.5 Rückgabewert ................................................................169 7.3.6 Überladen von Methoden ...................................................170 7.3.7 Konstruktoren................................................................171 7.3.8 Destruktoren .................................................................174 7.4 Zusammenfassung...................................................................175 8 OOP II: Vererbung, Polymorphismus und statische Elemente ....................... 177 8.1 Vererbimg ............................................................................177 8.1.1 Ableiten einer Klasse ........................................................177 8.1.2 Die Klasse Object .............................................................179 8.1.3 Überlagern von Methoden...................................................179 8.1.4 Vererbung von Konstruktoren ..............................................181 8.2 Modifier ..............................................................................183 8.2.1 Sichtbarkeit...................................................................183 8.2.2 Die Attribute im Überblick ..................................................184 8.3 Statische Methoden und Membervariablen ........................................187 8.3.1 Klassenvariablen .............................................................187 8.3.2 Konstanten ...................................................................188 8.3.3 Klassenmethoden ............................................................189 8.3.4 Statische Initialisierer ........................................................190 8.4 Abstrakte Klassen und Polymorphismus ...........................................191 8.4.1 Abstrakte Klassen............................................................191 8.4.2 Ein Beispiel für Polymorphismus ...........................................192 8.4.3 Polymorphe Methodenaufrufe in Konstruktoren ..........................195 8.5 Zusammenfassung...................................................................196 9 OOP III: Interfaces .................................................................... 197 9.1 Grundlagen ..........................................................................197 9.1.1 Definition eines Interface ....................................................197 9.1.2 Implementierung eines Interface ............................................198 9.1.3 Verwenden eines Interface ..................................................200 9.2 Das Interface Comparable ...........................................................202 9.3 Mehrfachimplementierung und Vererbung ........................................204 9.3.1 Mehrfachimplementierung ..................................................204 9.3.2 Vererbung von Interfaces....................................................205 9.3.3 Ableiten von Interfaces ......................................................206 9.4 Weitere Anwendungen von Interfaces..............................................207 9.4.1 Konstanten in Interfaces .....................................................207 9.4.2 Implementierung von Flags .................................................209 9.4.3 Nachbildung von Funktionszeigern ........................................210 9.5 Interfaces und Hilfskiassen..........................................................212 9.5.1 Die Default-Implementierung ...............................................213 9.5.2 Delegation an die Default-Implementierung ...............................214 9.5.3 Die leere Implementierung ..................................................215 9.6 Zusammenfassung...................................................................216 10 OOP IV: Verschiedenes ............................................................... 217 10.1 Lokale und anonyme Klassen .......................................................217 10.1.1 Grundlagen...................................................................217 10.1.2 Nichtstatische lokale Klassen................................................218 10.1.3 Anonyme Klassen............................................................221 10.1.4 Statische lokale Klassen......................................................222 10.2 Wrapper-Klassen .....................................................................223 10.2.1 Vordefinierte Wrapper-Klassen .............................................223 10.2.2 Call by Reference .............................................................227 10.2.3 Autoboxing und Autounboxing.............................................228 10.3 Aufzählungstypen ...................................................................229 10.3.1 Grundlagen...................................................................229 10.3.2 Erweiterung der Aufzählungsklasse ........................................232 10.4 Design Patterns ......................................................................233 10.4.1 Singleton .....................................................................234 10.4.2 Immutable ...................................................................235 10.4.3 Interface ......................................................................237 10.4.4 Factory .......................................................................237 10.4.5 Iterator ....................................................................... 244 10.4.6 Delegate ......................................................................247 10.4.7 Composite ...................................................................250 10.4.8 Visitor ........................................................................253 10.4.9 Observer .....................................................................257 10.5 Zusammenfassung...................................................................261 Teil IV Weiterführende Spracheigenschaften..........................263 11 Strings ................................................................................265 11.1 Grundlegende Eigenschaften........................................................265 11.2 Methoden der Klasse String .........................................................266 11.2.1 Konstruktoren................................................................266 11.2.2 Zeichenextraktion ............................................................267 11.2.3 Die Länge der Zeichenkette .................................................267 11.2.4 Vergleichen von Zeichenketten .............................................268 11.2.5 Suchen in Zeichenketten.....................................................270 11.2.6 Ersetzen von Zeichenketten .................................................271 11.2.7 Zerlegen von Zeichenketten.................................................271 11.2.8 Konvertierungsfunktionen ..................................................272 11.3 Weitere Eigenschaften ...............................................................273 11.3.1 Die Klasse String ist final ....................................................273 11.3.2 Was ist ein String für den Compiler? .......................................273 11.3.3 String-Objekte sind nicht dynamisch .......................................274 11.4 Die Klasse StringBuilder.............................................................275 11.4.1 Konstruktoren................................................................275 11.4.2 Einfügen von Elementen.....................................................276 11.4.3 Löschen von Elementen .....................................................276 11.4.4 Verändern von Elementen...................................................276 11.4.5 Längeninformationen ........................................................277 11.4.6 Konvertierung in einen String ...............................................277 11.5 Das Interface CharSequence.........................................................277 11.5.1 Parameterübergabe von beliebigen Zeichenketten .........................277 11.6 Ausgabeformatierung ...............................................................278 11.6.1 Grundlagen...................................................................278 11.6.2 Die Formatangaben ..........................................................280 11.7 Zusammenfassung...................................................................283 12 Exceptions ............................................................................285 12.1 Grundlagen und Begriffe ............................................................285 12.2 Behandlung von Exceptions .........................................................286 12.2.1 Die try-catch-Anweisung ....................................................286 12.2.2 Das Fehlerobjekt .............................................................288 12.2.3 Die Fehlerklassen von Java ..................................................289 12.2.4 Fortfahren nach Fehlern .....................................................289 12.2.5 Mehr als eine catch-Klausel .................................................290 12.2.6 Die finally-Klausel ...........................................................292 12.3 Weitergabe von Exceptions ..........................................................293 12.3.1 Die catch-or-throw-Regel ....................................................293 12.3.2 Weitergabe einer Exception .................................................294 12.3.3 Auslösen von Ausnahmen...................................................294 12.4 Zusammenfassung...................................................................296 13 Strukturierung von Java-Programmen ...............................................297 13.1 Programmelemente ..................................................................297 13.1.1 Anweisungen.................................................................297 13.1.2 Blöcke.........................................................................298 13.1.3 Methoden.....................................................................300 13.1.4 Klassen .......................................................................300 13.1.5 Pakete.........................................................................301 13.1.6 Applikationen ................................................................301 13.1.7 Applets .......................................................................302 13.2 Pakete.................................................................................302 13.2.1 Verwendung von Paketen ...................................................302 13.2.2 Die Bedeutung der Paketnamen.............................................305 13.2.3 Einbinden zusätzlicher Pakete ..............................................308 13.2.4 Erstellen eigener Pakete .....................................................309 13.3 Der Entwicklungszyklus.............................................................312 13.3.1 Schematische Darstellung ...................................................312 13.3.2 Projektverwaltung ...........................................................313 13.4 Auslieferung von Java-Programmen................................................315 13.4.1 Weitergabe des Bytecodes ...................................................315 13.4.2 Einbinden von Ressourcen-Dateien.........................................319 13.5 Java Web Start........................................................................322 13.5.1 Einleitung und Funktionsweise .............................................322 13.5.2 Erstellen einer WebStart-Applikation.......................................324 13.5.3 Das jnlp-API..................................................................329 13.6 Zusammenfassung...................................................................333 14 Collections I .......................................................................... 335 14.1 Grundlagen und Konzepte ..........................................................335 14.2 Die Klasse Vector ....................................................................336 14.2.1 Einfügen von Elementen.....................................................336 14.2.2 Zugriff auf Elemente.........................................................337 14.2.3 Der Vektor als Iterator .......................................................338 14.3 Die Klasse Stack......................................................................339 14.4 Die Klasse Hashtable ................................................................341 14.4.1 Einfügen von Elementen.....................................................341 14.4.2 Zugriff auf Elemente.........................................................342 14.4.3 Hashtable als Iterator ........................................................342 14.4.4 Die Klasse Properties ........................................................343 14.5 Die Klasse BitSet .....................................................................345 14.5.1 Elementweise Operationen ..................................................345 14.5.2 Mengenorientierte Operationen .............................................346 14.6 Zusammenfassung...................................................................347 15 Collections II ......................................................................... 349 15.1 Grundlagen und Konzepte ..........................................................349 15.2 Die Collection des Typs List.........................................................352 15.2.1 Abstrakte Eigenschaften .....................................................352 15.2.2 Implementierungen ..........................................................353 15.3 Iteratoren .............................................................................355 15.3.1 Das Interface Iterator ........................................................355 15.3.2 Das Interface Listlterator ....................................................357 15.4 Die Collection des Typs Set .........................................................358 15.4.1 Abstrakte Eigenschaften .....................................................358 15.4.2 Implementierungen ..........................................................359 15.5 Die Collection des Typs Map........................................................360 15.5.1 Abstrakte Eigenschaften .....................................................360 15.5.2 Implementierungen ..........................................................362 15.6 Sortierte Collections ..................................................................364 15.6.1 Comparable und Comparator ............................................... 364 15.6.2 SortedSet und TreeSet .......................................................365 15.6.3 SortedMap und TreeMap ....................................................368 15.7 Die Klasse Collections ...............................................................368 15.7.1 Sortieren und Suchen ........................................................368 15.7.2 Synchronisieren von Collections ............................................370 15.7.3 Erzeugen unveränderlicher Collections .....................................371 15.8 Typisierte Klassen und generische Collections ................................... 371 15.8.1 Grundlagen...................................................................371 15.8.2 Collections mit mehreren Typparametern..................................374 15.8.3 Eine eigene typisierte Listenklasse ..........................................375 15.8.4 Typkompatibilität ............................................................379 15.8.5 Sonstiges......................................................................382 15.9 Zusammenfassung...................................................................384 16 Utility-Klassen I .......................................................................385 16.1 Die Klasse Random ..................................................................385 16.1.1 Initialisierung des Zufallszahlengenerators ................................385 16.1.2 Erzeugen von Zufallszahlen.................................................385 16.2 Die Klassen Date, Calendar und GregorianCalendar ..............................387 16.2.1 Konstruktoren................................................................388 16.2.2 Abfragen und Setzen von Datumsbestandteilen ...........................389 16.2.3 Vergleiche und DatumsVZeitarithmetik ...................................394 16.2.4 Umwandlung zwischen Date und Calendar ...............................396 16.3 Die Klasse System ....................................................................397 16.3.1 System-Properties ............................................................397 16.3.2 in, err und out ................................................................399 16.3.3 exit ............................................................................399 16.3.4 gc ..............................................................................400 16.3.5 currentTimeMillis ............................................................400 16.3.6 arraycopy .....................................................................403 16.4 Die Klasse RunTime .................................................................404 16.4.1 Grundlagen...................................................................404 16.4.2 Interaktion mit dem externen Programm...................................406 16.5 Die Klasse Arrays ....................................................................410 16.6 Zusammenfassung...................................................................411 17 Utility-Klassen II ...................................................................... 413 17.1 Reguläre Ausdrücke .................................................................413 17.1.1 Die Klasse Pattern............................................................413 17.1.2 Die Klasse Matcher ..........................................................414 17.1.3 Vergleich einer Zeichenkette mit einem regulären Ausdruck .............414 17.1.4 Teilen einer Zeichenkette mit einem regulären Ausdruck .................416 17.2 Die Klasse Math......................................................................417 17.2.1 Winkelfunktionen............................................................417 17.2.2 Minimum und Maximum ...................................................417 17.2.3 Arithmetik....................................................................418 17.2.4 Runden und Abschneiden...................................................418 17.3 Die Klassen Biginteger und BigDecimal............................................418 17.3.1 Die Klasse Biginteger ........................................................419 17.3.2 Die Klasse BigDecimal.......................................................421 17.4 Internationalisierung und Lokalisierung ...........................................424 17.4.1 Die Klasse Locale ............................................................425 17.4.2 Zahlen formatieren...........................................................427 17.4.3 Datum und Uhrzeit formatieren ............................................430 17.4.4 Laden von Ressourcen.......................................................432 17.5 Zusammenfassung...................................................................438 18 Character-Streams ................................................................... 439 18.1 Allgemeine Konzepte................................................................439 18.2 Ausgabe-Streams.....................................................................441 18.2.1 Die abstrakte Klasse Writer ..................................................441 18.2.2 Auswahl des Ausgabegeräts ................................................441 18.2.3 Schachteln von Ausgabe-Streams ..........................................445 18.3 Eingabe-Streams .....................................................................452 18.3.1 Die abstrakte Klasse Reader .................................................452 18.3.2 Auswahl des Eingabegeräts .................................................453 18.3.3 Schachteln von Eingabe-Streams ...........................................456 18.4 Zusammenfassung...................................................................460 ig Byte-Streams .........................................................................461 19.1 Architektur und Vergleich mit Character-Streams .................................461 19.2 Ausgabe-Streams.....................................................................461 19.2.1 Die Basisklasse OutputStream...............................................461 19.2.2 Aus OutputStream direkt abgeleitete Klassen..............................462 19.2.3 Aus FilterOutputStream abgeleitete Klassen ...............................464 19.3 Eingabe-Streams .....................................................................470 19.3.1 Die Basisklasse InputStream.................................................470 19.3.2 Aus InputStream direkt abgeleitete Klassen................................471 19.3.3 Aus FilterlnputStream abgeleitete Klassen .................................473 19.4 Zusammenfassung...................................................................478 20 Random-Access-I/O.................................................................. 479 20.1 Grundlegende Operationen .........................................................479 20.2 Navigation in der Datei..............................................................480 20.2.1 Positionierung des Dateizeigers.............................................480 20.2.2 Die Länge der Datei..........................................................481 20.3 Lesezugriffe ..........................................................................482 20.4 Schreibzugriffe .......................................................................485 20.5 Zusammenfassung...................................................................486 21 Datei- und Verzeichnis-Handling.................................................... 487 21.1 Konstruktion eines File-Objekts .....................................................487 21.2 Zugriff auf Teile des Pfadnamens...................................................488 21.3 Informationen über die Datei .......................................................489 21.4 Zugriff auf Verzeichniseinträge .....................................................490 21.4.1 Lesen von Verzeichniseinträgen ............................................490 21.4.2 Ändern von Verzeichniseinträgen ..........................................494 21.5 Temporäre Dateien und Lockdateien ...............................................496 21.5.1 Temporäre Dateien...........................................................496 21.5.2 Lockdateien ..................................................................497 21.6 Zusammenfassung...................................................................498 22 Multithreading ...................................................................... 499 22.1 Grundlagen und Begriffe ............................................................499 22.2 Die Klasse Thread ....................................................................500 22.2.1 Erzeugen eines neuen Thread ...............................................500 22.2.2 Abbrechen eines Thread .....................................................502 22.2.3 Anhalten eines Thread .......................................................505 22.2.4 Weitere Methoden ...........................................................506 22.3 Das Interface Runnable ..............................................................507 22.3.1 Implementieren von Runnable ..............................................507 22.3.2 Multithreading durch Wrapper-Klassen....................................509 22.4 Synchronisation ......................................................................513 22.4.1 Synchronisationsprobleme ..................................................513 22.4.2 Monitore......................................................................516 22.4.3 wait und notify ...............................................................520 22.4.4 PipedlnputStream und PipedOutputStream ...............................523 22.5 Verwalten von Threads.............................................................. 525 22.5.1 Priorität und Name ..........................................................525 22.5.2 Thread-Gruppen .............................................................526 22.6 Zusammenfassung...................................................................527 Teil V Grafikprogrammierung mit dem AWT..........................529 23 Grafikausgabe ........................................................................ 531 23.1 Das Abstract Windowing Toolkit ...................................................531 23.1.1 Grundlegende Eigenschaften................................................531 23.1.2 Von AWT nach Swing .......................................................532 23.2 Grundlagen der Grafikausgabe .....................................................533 23.2.1 Anlegen eines Fensters ......................................................533 23.2.2 Die Methode paint ...........................................................534 23.2.3 Das grafische Koordinatensystem...........................................534 23.2.4 Schließen eines Fensters .....................................................535 23.3 Elementare Grafikroutinen ..........................................................537 23.3.1 Linie ..........................................................................539 23.3.2 Rechteck ......................................................................540 23.3.3 Polygon.......................................................................541 23.3.4 Kreis ..........................................................................542 23.3.5 Kreisbogen ...................................................................544 23.4 Weiterführende Funktionen.........................................................545 23.4.1 Linien- oder Füllmodus......................................................545 23.4.2 Kopieren und Löschen von Flächen ........................................546 23.4.3 Die Clipping-Region .........................................................548 23.5 Zusammenfassung...................................................................550 24 Textausgabe.......................................................................... 551 24.1 Ausgabefunktionen ..................................................................551 24.2 Unterschiedliche Schriftarten........................................................553 24.2.1 Font-Objekte..................................................................553 24.2.2 Standardschriftarten .........................................................556 24.3 Eigenschaften von Schriftarten......................................................558 24.3.1 Font-Informationen ..........................................................558 24.3.2 Font-Metriken ................................................................559 24.4 Zusammenfassung...................................................................562 25 Farben ................................................................................563 25.1 Das Java-Farbmodell.................................................................563 25.2 Erzeugen von Farben ................................................................564 25.3 Verwenden von Farben..............................................................565 25.4 Systemfarben.........................................................................567 25.5 Zusammenfassung...................................................................570 26 Drucken............................................................................... 571 26.1 Einleitung ............................................................................571 26.2 Drucken mit dem JDK 1.1 ...........................................................572 26.2.1 Grundlagen...................................................................572 26.2.2 Seitenweise Ausgabe.........................................................573 26.2.3 Platzierung des Codes zur Druckausgabe ..................................574 26.3 Drucken seit dem JDK 1.2 ...........................................................577 26.3.1 Überblick .....................................................................577 26.3.2 Zusammenspiel der Klassen.................................................578 26.3.3 Ausdrucken einer Textdatei .................................................584 26.4 Zugriff auf serielle und parallele Schnittstellen ....................................589 26.4.1 Das Java Communications API..............................................590 26.4.2 Ein einfaches Beispielprogramm ............................................591 26.5 Zusammenfassung...................................................................593 27 Fenster................................................................................595 27.1 Die verschiedenen Fensterklassen ..................................................595 27.2 Aufrufen und Schließen eines Fensters .............................................597 27.3 Visuelle Eigenschaften...............................................................599 27.4 Anzeigezustand ......................................................................601 27.5 Fensterelemente......................................................................602 27.5.1 Der Fenstertitel...............................................................602 27.5.2 Das Icon des Fensters ........................................................603 27.5.3 Der Mauscursor ..............................................................603 27.5.4 Die Vorder- und Hintergrundfarbe .........................................604 27.5.5 Der Standard-Font ...........................................................604 27.6 Zusammenfassung...................................................................607 28 Event-Handling ...................................................................... 609 28.1 Das Event-Handling im JDK 1.1 ....................................................609 28.1.1 Grundlagen...................................................................609 28.1.2 Ereignistypen.................................................................611 28.1.3 Ereignisempfänger ...........................................................612 28.1.4 Ereignisquellen...............................................................613 28.1.5 Adapterklassen...............................................................614 28.1.6 Zusammenfassung ...........................................................614 28.2 Entwurfsmuster für den Nachrichtenverkehr ......................................619 28.2.1 Variante 1: Implementierung eines EventListener-Interface ...............620 28.2.2 Variante 2: lokale und anonyme Klassen ...................................622 28.2.3 Variante 3: Trennung von GUI- und Anwendungscode ...................625 28.2.4 Variante 4: Überlagern der Event-Handler in den Komponenten.........627 28.2.5 Ausblick ......................................................................630 28.3 Zusammenfassung...................................................................630 29 Low-Level-Events .....................................................................633 29.1 Window-Events ......................................................................633 29.2 Component-Events ...................................................................635 29.3 Mouse-Events ........................................................................ 638 29.4 MouseMotion-Events ................................................................643 29.5 Focus-Events ......................................................................... 646 29.6 Key-Events ...........................................................................649 29.7 Zusammenfassung...................................................................655 30 Menüs ................................................................................657 30.1 Grundlagen...........................................................................657 30.2 Menüleiste............................................................................658 30.3 Menüs ................................................................................659 30.4 Menüeinträge ........................................................................660 30.4.1 Einfache Menüeinträge ......................................................660 30.4.2 CheckboxMenuItem .........................................................660 30.4.3 Beschleunigertasten ..........................................................663 30.4.4 Untermenüs ..................................................................666 30.5 Action-Events ........................................................................668 30.6 Kontextmenüs .......................................................................673 30.7 Datenaustausch mit der Zwischenablage...........................................676 30.7.1 Überblick .....................................................................676 30.7.2 Kommunikation mit der Zwischenablage ..................................676 30.8 Zusammenfassung...................................................................679 31 GUI-Dialoge...........................................................................681 31.1 Erstellen eines Dialogs...............................................................681 31.1.1 Anlegen eines Dialogfensters................................................681 31.1.2 Zuordnen eines Layoutmanagers ...........................................682 31.1.3 Einfügen von Dialogelementen .............................................682 31.1.4 Anzeigen des Dialogfensters ................................................683 31.2 Die Layoutmanager..................................................................684 31.2.1 FlowLayout...................................................................685 31.2.2 GridLayout ...................................................................687 31.2.3 BorderLayout.................................................................689 31.2.4 GridBagLayout...............................................................692 31.2.5 Null-Layout ..................................................................697 31.2.6 Schachteln von Layoutmanagern ...........................................699 31.3 Modale Dialoge ......................................................................701 31.4 Zusammenfassung...................................................................710 32 AWT-Dialogelemente................................................................. 711 32.1 Rahmenprogramm...................................................................711 32.2 Label ..................................................................................714 32.3 Button ................................................................................715 32.4 Checkbox .............................................................................716 32.5 CheckboxGroup......................................................................718 32.6 TextField..............................................................................720 32.7 TextArea..............................................................................723 32.8 Choice ................................................................................725 32.9 List....................................................................................728 32.10 Scrollbar ..............................................................................731 32.11 ScrollPane ............................................................................734 32.12 Zusammenfassung...................................................................740 33 Eigene Dialogelemente............................................................... 741 33.1 Die Klasse Canvas ...................................................................741 33.2 Entwicklung einer 7-Segment-Anzeige .............................................742 33.2.1 Anforderungen...............................................................742 33.2.2 Bildschirmanzeige ...........................................................742 33.2.3 Ereignisbehandlung..........................................................744 33.3 Einbinden der Komponente .........................................................749 33.4 Zusammenfassung...................................................................752 34 Bitmaps und Animationen ...........................................................753 34.1 Bitmaps ...............................................................................753 34.1.1 Laden und Anzeigen einer Bitmap..........................................753 34.1.2 Entwicklung einer eigenen Bitmap-Komponente ..........................757 34.2 Animation ............................................................................759 34.2.1 Prinzipielle Vorgehensweise ................................................759 34.2.2 Abspielen einer Folge von Bitmaps .........................................763 34.2.3 Animation mit Grafikprimitiven ............................................766 34.2.4 Reduktion des Bildschirmflackerns .........................................772 34.3 Zusammenfassung...................................................................781 Teil VI Grafikprogrammierung mit Swing .............................783 35 Swing: Grundlagen ...................................................................785 35.1 Eigenschaften und Architektur von Swing .........................................785 35.1.1 Einleitung.....................................................................785 35.1.2 Eigenschaften von Swing ....................................................786 35.1.3 Wie geht es weiter? ..........................................................789 35.2 Ein einführendes Beispiel ...........................................................789 35.2.1 Das Beispielprogramm ......................................................789 35.2.2 Beschreibung des Beispielprogramms ......................................791 35.3 Zusammenfassung...................................................................797 36 Swing: Container und Menüs ....................................................... 799 36.1 Hauptfenster .........................................................................799 36.1.1 JFrame ........................................................................799 36.1.2 JWindow......................................................................803 36.1.3 JDialog........................................................................805 36.1.4 JOptionPane ..................................................................806 36.1.5 JApplet .......................................................................811 36.1.6 JInternalFrame ...............................................................812 36.2 Menüs ................................................................................817 36.2.1 Einfache Menüs ..............................................................817 36.2.2 Grundlagen von Swing-Menüs..............................................817 36.2.3 Weitere Möglichkeiten.......................................................821 36.2.4 Kontextmenüs ...............................................................826 36.3 Weitere Swing-Container............................................................829 36.3.1 JComponent ..................................................................829 36.3.2 JPanel und JLayeredPane....................................................839 36.4 Zusammenfassung...................................................................840 37 Swing: Komponenten I ...............................................................841 37.1 Label und Textfelder.................................................................841 37.1.1 JLabel .........................................................................841 37.1.2 JTextField .....................................................................843 37.1.3 JPasswordField ...............................................................847 37.1.4 JTextArea .....................................................................847 37.1.5 JSpinner .......................................................................849 37.2 Buttons ...............................................................................851 37.2.1 JButton ........................................................................851 37.2.2 JCheckBox ....................................................................855 37.2.3 JRadioButton .................................................................857 37.3 Listen und Comboboxen ............................................................859 37.3.1 JList ...........................................................................859 37.3.2 JComboBox ...................................................................863 37.4 Quasi-analoge Komponenten .......................................................865 37.4.1 JScrollBar .....................................................................865 37.4.2 JSlider .........................................................................868 37.4.3 JProgressBar ..................................................................872 37.5 Zusammenfassung...................................................................875 38 Swing: Komponenten II ..............................................................877 38.1 Spezielle Panels ......................................................................877 38.1.1 JScrollPane ....................................................................877 38.1.2 JSplitPane .....................................................................881 38.1.3 JTabbedPane ..................................................................885 38.2 JTable .................................................................................888 38.2.1 Erzeugen von Tabellen ......................................................888 38.2.2 Konfiguration der Tabelle ...................................................891 38.2.3 Selektieren von Elementen ..................................................892 38.2.4 Zugriff auf den Inhalt der Tabelle...........................................894 38.2.5 Das Tabellenmodell..........................................................896 38.2.6 Das Spaltenmodell ...........................................................900 38.2.7 Rendering der Zellen ........................................................903 38.2.8 Reaktion auf Ereignisse......................................................906 38.3 JTree ..................................................................................907 38.3.1 Erzeugen eines Baums .......................................................907 38.3.2 Selektieren von Knoten ......................................................911 38.3.3 Öffnen und Schließen der Knoten...........................................914 38.3.4 Verändern der Baumstruktur ...............................................915 38.4 Zusammenfassung ...................................................................919 Teil VII Applets.......................................................... 921 39 Applets I ..............................................................................923 39.1 Die Architektur eines Applets.......................................................923 39.1.1 Grundlagen...................................................................923 39.1.2 Die Klasse java.applet.Applet ...............................................924 39.1.3 Initialisierung und Endebehandlung .......................................925 39.1.4 Weitere Methoden der Klasse Applet.......................................926 39.2 Einbinden eines Applets.............................................................928 39.2.1 Das APPLET-Tag.............................................................928 39.2.2 Die Parameter des Applet-Tags .............................................929 39.2.3 Parameterübergabe an Applets .............................................930 39.3 Die Ausgabe von Sound.............................................................933 39.3.1 Soundausgabe in Applets ...................................................933 39.3.2 Soundausgabe in Applikationen ............................................935 39.4 Animation in Applets................................................................936 39.5 Zusammenfassung...................................................................942 40 Applets II ............................................................................ 943 40.1 Verweise auf andere Seiten..........................................................943 40.1.1 Die Klasse URL ..............................................................943 40.1.2 Der Applet-Kontext ..........................................................944 40.1.3 Die Methode showDocument ...............................................945 40.2 Kommunikation zwischen Applets .................................................949 40.3 Umwandlung einer Applikation in ein Applet.....................................952 40.3.1 Die Beispielapplikation ......................................................952 40.3.2 Variante 1: Das Programm als Popup-Fenster..............................954 40.3.3 Variante 2: Erstellen eines gleichwertigen Applets.........................955 40.4 Das Java-Plug-in .....................................................................957 40.4.1 Funktionsweise...............................................................957 40.4.2 Verwendung des Plug-in ....................................................958 40.5 Zusammenfassung...................................................................959 Teil VIII Spezielle APIs ...................................................961 41 Serialisierung ........................................................................ 963 41.1 Grundlagen...........................................................................963 41.1.1 Begriffsbestimmung..........................................................963 41.1.2 Schreiben von Objekten......................................................963 41.1.3 Lesen von Objekten ..........................................................967 41.2 Weitere Aspekte der Serialisierung .................................................971 41.2.1 Versionierung ................................................................971 41.2.2 Nichtserialisierte Membervariablen.........................................974 41.2.3 Objektreferenzen .............................................................974 41.2.4 Serialisieren von Collections .................................................978 41.3 Anwendungen .......................................................................978 41.3.1 Ein einfacher Objektspeicher ................................................978 41.3.2 Kopieren von Objekten ......................................................983 41.4 Zusammenfassung...................................................................986 42 Datenbankzugriffe mit JDBC ........................................................ 987 42.1 Einleitung ............................................................................987 42.1.1 Grundsätzliche Arbeitsweise ................................................988 42.1.2 Die Architektur von JDBC ...................................................988 42.2 Grundlagen von JDBC ...............................................................990 42.2.1 Öffnen einer Verbindung ....................................................990 42.2.2 Erzeugen von Anweisungsobjekten.........................................992 42.2.3 Datenbankabfragen ..........................................................993 42.2.4 Datenbankänderungen ......................................................995 42.2.5 Die Klasse SQLException....................................................995 42.2.6 Die Klasse SQLWarning .....................................................996 42.3 Die DirDB-Beispieldatenbank .......................................................996 42.3.1 Anforderungen und Design .................................................996 42.3.2 Das Rahmenprogramm ......................................................998 42.3.3 Die Verbindung zur Datenbank herstellen ............................... 1000 42.3.4 Anlegen und Füllen der Tabellen ......................................... 1002 42.3.5 Zählen der Verzeichnisse und Dateien ................................... 1006 42.3.6 Suchen von Dateien und Verzeichnissen ................................. 1006 42.3.7 Die zehn größten Dateien.................................................. 1009 42.3.8 Speicherverschwendung durch Clustering ............................... 1010 42.4 Weiterführende Themen........................................................... 1011 42.4.1 Metadaten .................................................................. 1011 42.4.2 Escape-Kommandos ....................................................... 1012 42.4.3 Transaktionen .............................................................. 1012 42.4.4 JDBC-Datentypen .......................................................... 1013 42.4.5 Umgang mit JDBC-Objekten .............................................. 1014 42.4.6 Prepared Statements ....................................................... 1015 42.4.7 SQL-Kurzreferenz.......................................................... 1017 42.5 Zusammenfassung................................................................. 1022 43 Reflection ............................................................................1023 43.1 Einleitung .......................................................................... 1023 43.2 Die Klassen Object und Class ..................................................... 1024 43.2.1 Die Klasse Object ........................................................... 1024 43.2.2 Die Klasse Class ............................................................ 1024 43.3 Methoden- und Konstruktorenaufrufe............................................ 1027 43.3.1 Parameterlose Methoden .................................................. 1027 43.3.2 Parametrisierte Methoden ................................................. 1033 43.3.3 Parametrisierte Konstruktoren ............................................ 1036 43.4 Zugriff auf Membervariablen ..................................................... 1038 43.5 Arrays .............................................................................. 1042 43.5.1 Erzeugen von Arrays ...................................................... 1042 43.5.2 Zugriff auf Array-Elemente ............................................... 1044 43.6 Annotationen oder Metainformationen im Javacode ............................ 1047 43.6.1 Metainformationen......................................................... 1047 43.6.2 Eine einfache Annotation.................................................. 1048 43.6.3 Annotationen mit einem Wert............................................. 1049 43.6.4 Beliebige Schlüssel-Wert-Paare in Annotationen......................... 1050 43.6.5 Standardwerte für Attribute............................................... 1051 43.6.6 Einschränken von Annotationen .......................................... 1052 43.6.7 Auslesen von Annotationen ............................................... 1054 43.7 Zusammenfassung................................................................. 1055 44 Beans ................................................................................ 1057 44.1 Grundlagen und Begriffe .......................................................... 1057 44.2 Entwurf einer einfachen Bean ..................................................... 1059 44.2.1 Grundsätzliche Architektur ............................................... 1059 44.2.2 Grafische Darstellung...................................................... 1060 44.2.3 Eigenschaften............................................................... 1061 44.2.4 Implementierung........................................................... 1062 44.2.5 Verwendung der Bean ..................................................... 1065 44.3 Die Beanbox ........................................................................ 1066 44.3.1 Beschreibung und Installation............................................. 1066 44.3.2 Grundlagen der Bedienung ............................................... 1067 44.3.3 Integration eigener Beans .................................................. 1070 44.3.4 Serialisierte Beans .......................................................... 1072 44.4 Bean-Ereignisse .................................................................... 1074 44.4.1 Bound Properties........................................................... 1074 44.4.2 Constrained Properties .................................................... 1079 44.4.3 Anwendungsbeispiel ...................................................... 1084 44.5 Panel-Beans ........................................................................ 1086 44.6 Beanlnfo-Klassen und Property-Editoren......................................... 1090 44.6.1 Beanlnfo-Klassen ........................................................... 1090 44.6.2 Property-Editoren .......................................................... 1094 44.7 Zusammenfassung................................................................. 1101 45 Objektorientierte Persistenz......................................................... 1103 45.1 Einleitung .......................................................................... 1103 45.1.1 Bezug und Installation..................................................... 1104 45.2 Datenbank-Tabellen und Javaobjekte ............................................. 1105 45.2.1 Eine einfache Javaklasse für Tabellen..................................... 1105 45.2.2 Verknüpfen der Java-Klasse mit der Datenbank ......................... 1107 45.2.3 Konfiguration des Datenbankzugriffs .................................... 1111 45.3 Verwendung des Java Persistenz API ............................................ 1113 45.3.1 Der EntityManager......................................................... 1113 45.3.2 Transaktionen mit dem EntityManager................................... 1114 45.3.3 Anlegen eines neuen Datensatzes......................................... 1115 45.3.4 Laden eines Datensatzes................................................... 1116 45.3.5 Löschen eines Datensatzes................................................. 1117 45.4 Zusammenfassung................................................................. 1119 46 Netzwerkprogrammierung ...........................................................1121 46.1 Grundlagen der Netzwerkprogrammierung ..................................... 1121 46.1.1 Was ist ein Netzwerk? ..................................................... 1121 46.1.2 Protokolle................................................................... 1122 46.1.3 Adressierung von Daten................................................... 1123 46.1.4 Ports und Applikationen .................................................. 1125 46.1.5 Request for Comments ..................................................... 1126 46.1.6 Firewalls und Proxys ...................................................... 1128 46.2 Client-Sockets ...................................................................... 1128 46.2.1 Adressierung ............................................................... 1128 46.2.2 Aufbau einer einfachen Socket-Verbindung.............................. 1130 46.2.3 Lesen und Schreiben von Daten........................................... 1133 46.2.4 Zugriff auf einen Web-Server ............................................. 1136 46.3 Server-Sockets ...................................................................... 1138 46.3.1 Die Klasse ServerSocket ................................................... 1138 46.3.2 Verbindungen zu mehreren Clients....................................... 1140 46.3.3 Entwicklung eines einfachen Web-Servers ............................... 1142 46.4 Daten mit Hilfe der Klasse URL lesen ............................................ 1150 46.5 Zusammenfassung ................................................................. 1152 47 Remote Method Invocation ......................................................... 1153 47.1 Einleitung .......................................................................... 1153 47.1.1 Prinzipielle Arbeitsweise .................................................. 1153 47.1.2 Einzelheiten der Kommunikation ......................................... 1154 47.2 Aufbau eines einfachen Uhrzeit-Services ......................................... 1156 47.2.1 Vorgehensweise ............................................................ 1156 47.2.2 Das Remote-Interface ...................................................... 1157 47.2.3 Implementierung des Remote-Interface .................................. 1158 47.2.4 Registrieren der Objekte ................................................... 1160 47.2.5 Zugriff auf den Uhrzeit-Service ........................................... 1163 47.2.6 Ausblick .................................................................... 1166 47.3 Zusammenfassung................................................................. 1167 48 Sicherheit und Kryptografie ......................................................... 1169 48.1 Kryptografische Grundlagen ...................................................... 1169 48.1.1 Wichtige Begriffe........................................................... 1169 48.1.2 Einfache Verschlüsselungen............................................... 1170 48.1.3 Message Digests............................................................ 1173 48.1.4 Kryptographische Zufallszahlen .......................................... 1177 48.1.5 Public-Key- Verschlüsselung............................................... 1179 48.1.6 Digitale Unterschriften..................................................... 1180 48.1.7 Zertifikate .................................................................. 1187 48.2 Sicherheitsmechanismen in Java .................................................. 1189 48.2.1 Sprachsicherheit............................................................ 1189 48.2.2 Das Sandbox-Konzept ..................................................... 1189 48.2.3 Veränderungen im JDK 1.1 und 1.2 ....................................... 1190 48.3 Signierte Applets................................................................... 1191 48.3.1 Ein unerlaubtes Applet .................................................... 1191 48.3.2 Signieren des Applets...................................................... 1193 48.3.3 Ex- und Import von Zertifikaten .......................................... 1195 48.3.4 Anpassen der Policy-Datei ................................................ 1196 48.3.5 Die Klasse SecurityManager............................................... 1199 48.4 Zusammenfassung................................................................. 1201 49 Sound................................................................................ 1203 49.1 Grundlagen und Konzepte ........................................................ 1203 49.2 Gesampelter Sound ................................................................ 1204 49.2.1 Was ist Sampling? .......................................................... 1204 49.2.2 Das Sampling-API ......................................................... 1205 49.2.3 Abspielen einer Sample-Datei............................................. 1209 49.3 Midi ................................................................................. 1211 49.3.1 Was ist Midi?............................................................... 1211 49.3.2 Grundlegende Klassen des Midi-API ..................................... 1212 49.3.3 Alle meine Entchen - erster Versuch ..................................... 1213 49.3.4 Alle meine Entchen mit dem Sequencer .................................. 1217 49.3.5 Zugriff auf Midi-Dateien .................................................. 1221 49.4 Zusammenfassung................................................................. 1223 Teil IX Verschiedenes.................................................. 1225 50 Performance-Tuning................................................................. 1227 50.1 Einleitung .......................................................................... 1227 50.2 Tuning-Tipps....................................................................... 1229 50.2.1 String und StringBuilder................................................... 1229 50.2.2 Methodenaufrufe........................................................... 1233 50.2.3 Vektoren und Listen ....................................................... 1235 50.2.4 Dateizugriffe ............................................................... 1237 50.2.5 Speicheroptimierung....................................................... 1240 50.3 Einsatz eines Profilers ............................................................. 1241 50.3.1 Grundlagen................................................................. 1241 50.3.2 Eine Beispielsitzung mit dem Profiler .................................... 1242 50.3.3 Ausblick .................................................................... 1249 50.4 Zusammenfassung................................................................. 1250 51 Hilfsprogramme des JDK ............................................................ 1251 51.1 javac - der Compiler............................................................... 1251 51.1.1 Aufruf ...................................................................... 1252 51.1.2 Beschreibung ............................................................... 1252 51.1.3 Optionen.................................................................... 1252 51.2 java - der Interpreter .............................................................. 1253 51.2.1 Aufruf ...................................................................... 1253 51.2.2 Beschreibung ............................................................... 1253 51.2.3 Optionen.................................................................... 1254 51.3 appletviewer - der Appletviewer ................................................. 1255 51.3.1 Aufruf ...................................................................... 1255 51.3.2 Beschreibung ............................................................... 1255 51.3.3 Optionen.................................................................... 1256 51.4 jdb - der Debugger ................................................................ 1256 51.4.1 Aufruf ...................................................................... 1256 51.4.2 Beschreibung ............................................................... 1256 51.4.3 Vorbereitungen............................................................. 1257 51.5 javadoc - der Dokumentationsgenerator ......................................... 1259 51.5.1 Aufruf ...................................................................... 1259 51.5.2 Beschreibung ............................................................... 1259 51.5.3 Dokumentationskommentare ............................................. 1259 51.5.4 Aufruf von javadoc ........................................................ 1261 51.5.5 Optionen.................................................................... 1262 51.6 jar - das Archivierungswerkzeug ................................................ 1263 51.6.1 Aufruf..................................................................... 1263 51.6.2 Beschreibung ............................................................. 1263 51.6.3 Kommandos .............................................................. 1263 51.6.4 Verwendung von jar-Dateien in Applets................................ 1264 51.7 javap - der Disassembler .......................................................... 1265 51.7.1 Aufruf..................................................................... 1265 51.7.2 Beschreibung ............................................................. 1265 51.7.3 Optionen .................................................................. 1265 51.8 serialver - Zugriff auf die serialVersionUID ..................................... 1266 51.8.1 Aufruf..................................................................... 1266 51.8.2 Beschreibung ............................................................. 1266 51.8.3 Optionen .................................................................. 1266 51.9 keytool - Verwaltung von kryptografischen Schlüsseln ......................... 1266 51.9.1 Aufruf..................................................................... 1266 51.9.2 Beschreibung ............................................................. 1266 51.10 policytool - Bearbeiten von Policy-Dateien....................................... 1266 51.10.1 Aufruf..................................................................... 1266 51.10.2 Beschreibung ............................................................. 1267 51.11 jarsigner - Signieren von Archiven ............................................... 1267 51.11.1 Aufruf..................................................................... 1267 51.11.2 Beschreibung ............................................................. 1267 51.11.3 Optionen .................................................................. 1267 51.12 rmic - Erzeugen von RMI-Stubs und -Skeletons ................................. 1268 51.12.1 Aufruf..................................................................... 1268 51.12.2 Beschreibung ............................................................. 1268 51.12.3 Optionen .................................................................. 1268 51.13 rmiregistry - der RMI-Namensservice............................................ 1268 51.13.1 Aufruf..................................................................... 1268 51.13.2 Beschreibung ............................................................. 1268 51.14 Zusammenfassung................................................................. 1269 J2SE Software License ...................................................................1271 Abbildungsverzeichnis ..................................................................1277 Tabellenverzeichnis ......................................................................1283 Listingverzeichnis ........................................................................1287 Stichwortverzeichnis .....................................................................1299
any_adam_object	1
author	Krüger, Guido Stark, Thomas
author_GND	(DE-588)112915019 (DE-588)132250470
author_facet	Krüger, Guido Stark, Thomas
author_role	aut aut
author_sort	Krüger, Guido
author_variant	g k gk t s ts
building	Verbundindex
bvnumber	BV022253794
classification_rvk	ST 250
classification_tum	DAT 362f
ctrlnum	(OCoLC)229922481 (DE-599)BVBBV022253794
dewey-full	005.133
dewey-hundreds	000 - Computer science, information, general works
dewey-ones	005 - Computer programming, programs, data, security
dewey-raw	005.133
dewey-search	005.133
dewey-sort	15.133
dewey-tens	000 - Computer science, information, general works
discipline	Informatik
edition	5. Aufl.
format	Book
fullrecord	<?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>02949nam a2200661 c 4500</leader><controlfield tag="001">BV022253794</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20221214 </controlfield><controlfield tag="007">t\|</controlfield><controlfield tag="008">070202s2008 gw a\|\|\| \|\|\|\| 00\|\|\| ger d</controlfield><datafield tag="015" ind1=" " ind2=" "><subfield code="a">07,N05,0016</subfield><subfield code="2">dnb</subfield></datafield><datafield tag="016" ind1="7" ind2=" "><subfield code="a">982473540</subfield><subfield code="2">DE-101</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9783827323736</subfield><subfield code="c">Gb. : EUR 59.95, EUR 61.70 (AT), sfr 99.50</subfield><subfield code="9">978-3-8273-2373-6</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">3827323738</subfield><subfield code="c">Gb. : EUR 59.95, EUR 61.70 (AT), sfr 99.50</subfield><subfield code="9">3-8273-2373-8</subfield></datafield><datafield tag="024" ind1="3" ind2=" "><subfield code="a">9783827323736</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)229922481</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)BVBBV022253794</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rakddb</subfield></datafield><datafield tag="041" ind1="0" ind2=" "><subfield code="a">ger</subfield></datafield><datafield tag="044" ind1=" " ind2=" "><subfield code="a">gw</subfield><subfield code="c">XA-DE-BY</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-859</subfield><subfield code="a">DE-29</subfield><subfield code="a">DE-91</subfield><subfield code="a">DE-1051</subfield><subfield code="a">DE-91G</subfield><subfield code="a">DE-12</subfield><subfield code="a">DE-M347</subfield><subfield code="a">DE-739</subfield><subfield code="a">DE-523</subfield><subfield code="a">DE-83</subfield><subfield code="a">DE-11</subfield></datafield><datafield tag="082" ind1="0" ind2=" "><subfield code="a">005.133</subfield><subfield code="2">22/ger</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 250</subfield><subfield code="0">(DE-625)143626:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">DAT 362f</subfield><subfield code="2">stub</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">68N15</subfield><subfield code="2">msc</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">004</subfield><subfield code="2">sdnb</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Krüger, Guido</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)112915019</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Handbuch der Java-Programmierung</subfield><subfield code="b">Standard-Edition Version 6</subfield><subfield code="c">Guido Krüger ; Thomas Stark</subfield></datafield><datafield tag="250" ind1=" " ind2=" "><subfield code="a">5. Aufl.</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">München</subfield><subfield code="b">Addison Wesley</subfield><subfield code="c">2008</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">1327 S.</subfield><subfield code="b">Ill.</subfield><subfield code="e">1 DVD (12 cm)</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="b">n</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="b">nc</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="490" ind1="0" ind2=" "><subfield code="a">Programmer's Choice</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">auf DVD: [alle Beispiele aus dem Buch, die HTML-Ausgabe ; Java 6 SDK und Eclipse 3.3 ; ausgewählte Video-Trainings ; eBook "Masterclass Java EE 5"]</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Java Standard Edition 7</subfield><subfield code="0">(DE-588)7751205-4</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Java Standard Edition 6</subfield><subfield code="0">(DE-588)7554591-3</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Java</subfield><subfield code="g">Programmiersprache</subfield><subfield code="0">(DE-588)4401313-9</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Java 2 Standard Edition 5.0</subfield><subfield code="0">(DE-588)4799436-8</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">JDK 1.4</subfield><subfield code="0">(DE-588)4669316-6</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="689" ind1="0" ind2="0"><subfield code="a">Java Standard Edition 6</subfield><subfield code="0">(DE-588)7554591-3</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="689" ind1="1" ind2="0"><subfield code="a">Java</subfield><subfield code="g">Programmiersprache</subfield><subfield code="0">(DE-588)4401313-9</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="1" ind2=" "><subfield code="8">1\p</subfield><subfield code="5">DE-604</subfield></datafield><datafield tag="689" ind1="2" ind2="0"><subfield code="a">Java 2 Standard Edition 5.0</subfield><subfield code="0">(DE-588)4799436-8</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="2" ind2=" "><subfield code="8">2\p</subfield><subfield code="5">DE-604</subfield></datafield><datafield tag="689" ind1="3" ind2="0"><subfield code="a">JDK 1.4</subfield><subfield code="0">(DE-588)4669316-6</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="3" ind2=" "><subfield code="8">3\p</subfield><subfield code="5">DE-604</subfield></datafield><datafield tag="689" ind1="4" ind2="0"><subfield code="a">Java Standard Edition 7</subfield><subfield code="0">(DE-588)7751205-4</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="4" ind2=" "><subfield code="8">4\p</subfield><subfield code="5">DE-604</subfield></datafield><datafield tag="700" ind1="1" ind2=" "><subfield code="a">Stark, Thomas</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)132250470</subfield><subfield code="4">aut</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">Digitalisierung UB Passau</subfield><subfield code="q">application/pdf</subfield><subfield code="u">http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=015464546&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA</subfield><subfield code="3">Inhaltsverzeichnis</subfield></datafield><datafield tag="883" ind1="1" ind2=" "><subfield code="8">1\p</subfield><subfield code="a">cgwrk</subfield><subfield code="d">20201028</subfield><subfield code="q">DE-101</subfield><subfield code="u">https://d-nb.info/provenance/plan#cgwrk</subfield></datafield><datafield tag="883" ind1="1" ind2=" "><subfield code="8">2\p</subfield><subfield code="a">cgwrk</subfield><subfield code="d">20201028</subfield><subfield code="q">DE-101</subfield><subfield code="u">https://d-nb.info/provenance/plan#cgwrk</subfield></datafield><datafield tag="883" ind1="1" ind2=" "><subfield code="8">3\p</subfield><subfield code="a">cgwrk</subfield><subfield code="d">20201028</subfield><subfield code="q">DE-101</subfield><subfield code="u">https://d-nb.info/provenance/plan#cgwrk</subfield></datafield><datafield tag="883" ind1="1" ind2=" "><subfield code="8">4\p</subfield><subfield code="a">cgwrk</subfield><subfield code="d">20201028</subfield><subfield code="q">DE-101</subfield><subfield code="u">https://d-nb.info/provenance/plan#cgwrk</subfield></datafield><datafield tag="943" ind1="1" ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-015464546</subfield></datafield></record></collection>
id	DE-604.BV022253794
illustrated	Illustrated
indexdate	2024-12-20T12:51:10Z
institution	BVB
isbn	9783827323736 3827323738
language	German
oai_aleph_id	oai:aleph.bib-bvb.de:BVB01-015464546
oclc_num	229922481
open_access_boolean
owner	DE-859 DE-29 DE-91 DE-BY-TUM DE-1051 DE-91G DE-BY-TUM DE-12 DE-M347 DE-739 DE-523 DE-83 DE-11
owner_facet	DE-859 DE-29 DE-91 DE-BY-TUM DE-1051 DE-91G DE-BY-TUM DE-12 DE-M347 DE-739 DE-523 DE-83 DE-11
physical	1327 S. Ill. 1 DVD (12 cm)
publishDate	2008
publishDateSearch	2008
publishDateSort	2008
publisher	Addison Wesley
record_format	marc
series2	Programmer's Choice
spellingShingle	Krüger, Guido Stark, Thomas Handbuch der Java-Programmierung Standard-Edition Version 6 Java Standard Edition 7 (DE-588)7751205-4 gnd Java Standard Edition 6 (DE-588)7554591-3 gnd Java Programmiersprache (DE-588)4401313-9 gnd Java 2 Standard Edition 5.0 (DE-588)4799436-8 gnd JDK 1.4 (DE-588)4669316-6 gnd
subject_GND	(DE-588)7751205-4 (DE-588)7554591-3 (DE-588)4401313-9 (DE-588)4799436-8 (DE-588)4669316-6
title	Handbuch der Java-Programmierung Standard-Edition Version 6
title_auth	Handbuch der Java-Programmierung Standard-Edition Version 6
title_exact_search	Handbuch der Java-Programmierung Standard-Edition Version 6
title_full	Handbuch der Java-Programmierung Standard-Edition Version 6 Guido Krüger ; Thomas Stark
title_fullStr	Handbuch der Java-Programmierung Standard-Edition Version 6 Guido Krüger ; Thomas Stark
title_full_unstemmed	Handbuch der Java-Programmierung Standard-Edition Version 6 Guido Krüger ; Thomas Stark
title_short	Handbuch der Java-Programmierung
title_sort	handbuch der java programmierung standard edition version 6
title_sub	Standard-Edition Version 6
topic	Java Standard Edition 7 (DE-588)7751205-4 gnd Java Standard Edition 6 (DE-588)7554591-3 gnd Java Programmiersprache (DE-588)4401313-9 gnd Java 2 Standard Edition 5.0 (DE-588)4799436-8 gnd JDK 1.4 (DE-588)4669316-6 gnd
topic_facet	Java Standard Edition 7 Java Standard Edition 6 Java Programmiersprache Java 2 Standard Edition 5.0 JDK 1.4
url	http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=015464546&sequence=000002&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
work_keys_str_mv	AT krugerguido handbuchderjavaprogrammierungstandardeditionversion6 AT starkthomas handbuchderjavaprogrammierungstandardeditionversion6

Verfügbarkeit

Bestellen (Login erforderlich)

Inhaltsverzeichnis
Paper/Kapitel scannen lassen

Teilbibliothek Stammgelände

Bestandsangaben von Teilbibliothek Stammgelände
Signatur:	0002 DAT 362f 2006 B 618(5) Lageplan
Exemplar 1	Ausleihbar Am Standort