Verfügbarkeit: Java ist auch eine Insel | Technische Universität München

Java ist auch eine Insel: Einführung, Ausbildung, Praxis

Gespeichert in:

Bibliographische Detailangaben
Beteilige Person:	Ullenboom, Christian (VerfasserIn)
Format:	Buch
Sprache:	Deutsch
Veröffentlicht:	Bonn Rheinwerk Verlag 2019
Ausgabe:	14., aktualisierte und überarbeitete Auflage
Schriftenreihe:	Rheinwerk computing
Schlagwörter:	Java > Programmiersprache Java Standard Edition 8 Java Standard Edition 11 Java Standard Edition 9 Hand-Buch Anleitung Einführung Tutorial Grundlagen lernen Ideen Tipps Workshop Ausbildung Rheinwerk-Verlag Galileo Computing Eclipse NetBeans xml Performanz Lambda Expressions JDK Oracle Objektorientiert programmieren lernen OOP Referenz Datenbanken Lehrbuch
Links:	http://deposit.dnb.de/cgi-bin/dokserv?id=94c422f160934eeeab134debc0e58690&prov=M&dok_var=1&dok_ext=htm http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=030759701&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
Beschreibung:	Auf dem Umschlag: "Aktuell zu Java 11" Auf dem Umschlag: "Programmieren mit der Java Platform, Standard Edition 11; Java von A bis Z: Einführung, Praxis, Referenz; Von Ausdrücken und Anweisungen zu Klassen und Objekten"
Umfang:	1278 Seiten Diagramme, Illustrationen 24 cm x 19 cm
ISBN:	9783836267212 3836267217

Internformat

MARC


LEADER	00000nam a2200000 c 4500
001	BV045373256
003	DE-604
005	20190917
007	t\|
008	181217s2019 gw a\|\|\| \|\|\|\| 00\|\|\| ger d
015			\|a 18,N48 \|2 dnb
016	7		\|a 1172148783 \|2 DE-101
020			\|a 9783836267212 \|c Hbk.: EUR 49.90 (DE), EUR 51.30 (AT), CHF 63.90 (freier Preis) \|9 978-3-8362-6721-2
020			\|a 3836267217 \|c Hbk. \|9 3-8362-6721-7
035			\|a (OCoLC)1082328546
035			\|a (DE-599)DNB1172148783
040			\|a DE-604 \|b ger \|e rda
041	0		\|a ger
044			\|a gw \|c DE
049			\|a DE-703 \|a DE-860 \|a DE-1050 \|a DE-384 \|a DE-739 \|a DE-11 \|a DE-1049 \|a DE-29T \|a DE-862 \|a DE-859 \|a DE-91G \|a DE-20 \|a DE-19 \|a DE-Aug4 \|a DE-523 \|a DE-573 \|a DE-91 \|a DE-824 \|a DE-83 \|a DE-29 \|a DE-M347 \|a DE-634 \|a DE-12 \|a DE-150 \|a DE-706 \|a DE-1046 \|a DE-1102 \|a DE-1051 \|a DE-B768 \|a DE-861
084			\|a ST 250 \|0 (DE-625)143626: \|2 rvk
084			\|a DAT 362f \|2 stub
084			\|a 004 \|2 sdnb
100	1		\|a Ullenboom, Christian \|e Verfasser \|0 (DE-588)123404738 \|4 aut
245	1	0	\|a Java ist auch eine Insel \|b Einführung, Ausbildung, Praxis \|c Christian Ullenboom
250			\|a 14., aktualisierte und überarbeitete Auflage
264		1	\|a Bonn \|b Rheinwerk Verlag \|c 2019
300			\|a 1278 Seiten \|b Diagramme, Illustrationen \|c 24 cm x 19 cm
336			\|b txt \|2 rdacontent
337			\|b n \|2 rdamedia
338			\|b nc \|2 rdacarrier
490	0		\|a Rheinwerk computing
500			\|a Auf dem Umschlag: "Aktuell zu Java 11"
500			\|a Auf dem Umschlag: "Programmieren mit der Java Platform, Standard Edition 11; Java von A bis Z: Einführung, Praxis, Referenz; Von Ausdrücken und Anweisungen zu Klassen und Objekten"
650	0	7	\|a Java \|g Programmiersprache \|0 (DE-588)4401313-9 \|2 gnd \|9 rswk-swf
650	0	7	\|a Java Standard Edition 8 \|0 (DE-588)1049861094 \|2 gnd \|9 rswk-swf
650	0	7	\|a Java Standard Edition 11 \|0 (DE-588)1176042394 \|2 gnd \|9 rswk-swf
650	0	7	\|a Java Standard Edition 9 \|0 (DE-588)113696553X \|2 gnd \|9 rswk-swf
653			\|a Hand-Buch Anleitung Einführung Tutorial Grundlagen lernen Ideen Tipps Workshop Ausbildung Rheinwerk-Verlag Galileo Computing
653			\|a Eclipse
653			\|a NetBeans
653			\|a xml
653			\|a Performanz
653			\|a Lambda Expressions
653			\|a JDK
653			\|a Oracle
653			\|a Objektorientiert programmieren lernen OOP
653			\|a Referenz
653			\|a Datenbanken
655		7	\|0 (DE-588)4123623-3 \|a Lehrbuch \|2 gnd-content
689	0	0	\|a Java \|g Programmiersprache \|0 (DE-588)4401313-9 \|D s
689	0	1	\|a Java Standard Edition 11 \|0 (DE-588)1176042394 \|D s
689	0		\|5 DE-604
689	1	0	\|a Java Standard Edition 8 \|0 (DE-588)1049861094 \|D s
689	1		\|5 DE-604
689	2	0	\|a Java Standard Edition 11 \|0 (DE-588)1176042394 \|D s
689	2		\|5 DE-604
689	3	0	\|a Java Standard Edition 9 \|0 (DE-588)113696553X \|D s
689	3		\|5 DE-604
710	2		\|a Galileo Press \|0 (DE-588)1065964404 \|4 pbl
856	4	2	\|m X:MVB \|q text/html \|u http://deposit.dnb.de/cgi-bin/dokserv?id=94c422f160934eeeab134debc0e58690&prov=M&dok_var=1&dok_ext=htm \|3 Inhaltstext
856	4	2	\|m DNB Datenaustausch \|q application/pdf \|u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=030759701&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA \|3 Inhaltsverzeichnis
943	1		\|a oai:aleph.bib-bvb.de:BVB01-030759701

Datensatz im Suchindex

DE-BY-TUM_call_number	0003 DAT 362f 2008 L 985(14) 0004 DAT 362f 2008 A 7856(14) 0104 DAT 362f 2006 A 5010(14) 0303 DAT 362f 2006 L 325(14)
DE-BY-TUM_katkey	2394331
DE-BY-TUM_location	00 01 03
DE-BY-TUM_media_number	040009201532 040009201543 040009201554 040009201565 040009201576 040009201521 040008853776 040008853834 040008853845 040008853743 040008853856 040008853798 040008853801 040008853867 040008853765 040008853823 040008853812 040008853721 040008853732 040008853787 040008853889 040008853878
_version_	1824985749564424192
adam_text	INHALT V O RW O RT....................................................................................................................................... 31 1 JAVA IST AUCH EINE SPRACHE 49 1.1 HISTORISCHER HINTERGRUND ............................................................................................. 49 1.2 WARUM JAVA GUT IST - DIE ZENTRALEN EIGENSCHAFTEN .................................................. 51 1.2.1 BYTECODE........................................................................................................... 52 1.2.2 AUSFUEHRUNG DES BYTECODES DURCH EINE VIRTUELLE MASCHINE.............................. 52 1.2.3 PLATTFORMUNABHAENGIGKEIT................................................................................ 53 1.2.4 JAVA ALS SPRACHE, LAUFZEITUMGEBUNG UND STANDARDBIBLIOTHEK....................... 53 1.2.5 OBJEKTORIENTIERUNG IN JAVA............................................................................... 54 1.2.6 JAVA IST VERBREITET UND BEKANNT....................................................................... 55 1.2.7 JAVA IST SCHNELL - OPTIMIERUNG UND JUST-IN-TIME-COMPILATION....................... 55 1.2.8 DAS JAVA-SECURITY-MODELL................................................................................. 57 1.2.9 ZEIGER UND REFERENZEN..................................................................................... 58 1.2.10 BRING DEN MUELL RAUS, GARBAGE-COLLECTOR!......................................................... 59 1.2.11 AUSNAHMEBEHANDLUNG .................................................................................... 60 1.2.12 ANGEBOT AN BIBLIOTHEKEN UND WERKZEUGEN..................................................... 61 1.2.13 EINFACHE SYNTAX DER PROGRAMMIERSPRACHE JAVA.............................................. 61 1.2.14 JAVA IST OPEN SOURCE......................................................................................... 63 1.2.15 WOFUER SICH JAVA WENIGER EIGNET....................................................................... 64 1.3 JAVA IM VERGLEICH ZU ANDEREN SPRACHEN * .................................................................. 65 1.3.1 JAVA UND C(++)................................................................................................... 65 1.3.2 JAVA UND JAVASCRIPT.......................................................................................... 66 1.3.3 EIN WORT ZU MICROSOFT, JAVA UND ZU J++, J# ...................................................... 66 1.3.4 JAVA UND C#/.NET.............................................................................................. 67 1.4 WEITERENTWICKLUNG UND VERLUSTE ............................................................................... 68 1.4.1 DIE ENTWICKLUNG VON JAVA UND SEINE ZUKUNFTSAUSSICHTEN .............................. 68 1.4.2 FEATURES, ENHANCEMENTS (ERWEITERUNGEN) UND EIN JSR................................... 69 1.4.3 APPLETS ............................................................................................................. 70 1.4.4 JAVAFX............................................................................................................... 71 1.5 JAVA-PLATTFORMEN: JAVA SE, JAKARTA EE, JAVA ME, JAVA CARD...................................... 72 1.5.1 DIE JAVA SE-PLATTFORM....................................................................................... 72 1.5.2 JAVA ME: JAVA FUER DIE KLEINEN.................................. .... .................................... 74 1.5.3 JAVA FUER DIE GANZ, GANZ KLEINEN........................................................................ 75 1.5.4 JAVA FUER DIE GROSSEN: JAVA EE/JAKARTA EE ........................................................... 75 1.5.5 ECHTZEIT-JAVA (REAL-TIME JAVA)........................................................................... 76 1.6 JAVA SE-IMPLEMENTIERUNGEN........................................................................................ 77 1.6.1 OPENJDK............................................................................................................ 77 1.6.2 ORACLE JDK.......................................................................................................... 78 1.7 DIE INSTALLATION DES ORACLE OPENJDK........................................................................... 81 1.7.1 OPENJDK UNTER WINDOWS INSTALLIEREN...................................................... 81 1.8 DAS ERSTE PROGRAMM COMPILIEREN UND TESTEN ............................................................ 83 1.8.1 EIN QUADRATZAHLEN-PROGRAMM ......................................................................... 84 1.8.2 DER COM PILERLAUF............................................................................................... 85 1.8.3 DIE LAUFZEITUMGEBUNG...................................................................................... 85 1.8.4 HAEUFIGE COMPILER- UND INTERPRETER-PROBLEME.................................................. 86 1.9 ENTWICKLUNGSUMGEBUNGEN IM ALLGEMEINEN ............................................................. 87 1.9.1 ECLIPSE IDE.......................................................................................................... 87 1.9.2 INTELLIJ IDEA........................................................................................................ 88 1.9.3 NETBEANS........................................................................................................... 89 1.10 ECLIPSE IDE IM SPEZIELLEN............................................................................................... 89 1.10.1 ECLIPSE IDE ENTPACKEN UND STARTEN................................................................... 91 1.10.2 DAS ERSTE PROJEKT ANLEGEN ................................................................................. 96 1.10.3 VERZEICHNISSTRUKTUR FUER JAVA-PROJEKTE * ............................................................ 98 1.10.4 EINE KLASSE HINZUFUEGEN..................................................................................... 99 1.10.5 UEBERSETZEN UND AUSFUEHREN............................................................................... 100 1.10.6 PROJEKT EINFUEGEN, WORKSPACE FUER DIE PROGRAMME WECHSELN ........................... 100 1.10.7 PLUGINS FUER ECLIPSE............................................................................................. 101 1.11 ZUM WEITERLESEN........................................................................................................... 101 2 IMPERATIVE SPRACHKONZEPTE 103 2.1 ELEMENTE DER PROGRAMMIERSPRACHE JAVA.................................................................... 103 2.1.1 TOKEN................................................................................................................. 103 2.1.2 TEXTKODIERUNG DURCH UNICODE-ZEICHEN............................................................ 104 2.1.3 BEZEICHNER......................................................................................................... 104 2.1.4 LITERALE............................................................................................................... 107 2.1.5 (RESERVIERTE) SCHLUESSELWOERTER........................................................................... 107 2.1.6 ZUSAMMENFASSUNG DER LEXIKALISCHEN ANALYSE............................................ 108 2.1.7 KOMMENTARE..................................................................................................... 109 2.2 VON DER KLASSE ZUR ANWEISUNG..................................................................................... 111 2.2.1 WAS SIND ANWEISUNGEN?.................................................................................... 111 2.2.2 KLASSENDEKLARATION........................................................................................... 112 2.2.3 DIE REISE BEGINNT AM MAIN(STRING[]) ............................................................... 113 2.2.4 DER ERSTE METHODENAUFRUF: PRINTLN(...)............................................................. 113 2.2.5 ATOMARE ANWEISUNGEN UND ANWEISUNGSSEQUENZEN ...................................... 114 2.2.6 MEHR ZU PRINT(...), PRINTLN(...) UND PRINTF(...) FUER BILDSCHIRMAUSGABEN .............. 115 2.2.7 DIE API-DOKUMENTATION ................................................................................... 117 2.2.8 AUSDRUECKE......................................................................................................... 118 2.2.9 AUSDRUCKSANWEISUNG....................................................................................... 119 2.2.10 ERSTE IDEE DER OBJEKTORIENTIERUNG.................................................................... 120 2.2.11 M ODIFIZIERER...................................................................................................... 121 2.2.12 GRUPPIEREN VON ANWEISUNGEN M IT BLOECKEN..................................................... 121 2.3 DATENTYPEN, TYPISIERUNG, VARIABLEN UND ZUW EISUNGEN.......................................... 122 2.3.1 PRIMITIVE DATENTYPEN IM UEBERBLICK ................................................................. 125 2.3.2 VARIABLENDEKLARATIONEN.................................................................................... 127 2.3.3 AUTOMATISCHES FESTSTELLEN DER TYPEN M IT VA R ................................................. 130 2.3.4 KONSOLENEINGABEN............................................................................................ 131 2.3.5 FLIESSKOMMAZAHLEN MIT DEN DATENTYPEN FLOAT UND DOUBLE ............................ 133 2.3.6 GANZZAHLIGE DATENTYPEN ................................................................................. 135 2.3.7 W AHRHEITSWERTE............................................................................................... 137 2.3.8 UNTERSTRICHE IN ZAHLEN * ................................................................................... 137 2.3.9 ALPHANUMERISCHE ZEICHEN ............................................................................... 138 2.3.10 GUTE NAMEN, SCHLECHTE NAMEN....................................................................... 138 2.3.11 INITIALISIERUNG VON LOKALEN VARIABLEN............................................................... 139 2.4 AUSDRUECKE, OPERANDEN UND O P ERATOREN.................................................................... 140 2.4.1 ZUWEISUNGSOPERATOR........................................................................................ 141 2.4.2 ARITHMETISCHE OPERATOREN ............................................................................... 142 2.4.3 UNAERES MINUS UND PLUS .................................................................................... 146 2.4.4 PRAEFIX- ODER POSTFIX-INKREMENT UND -DEKREMENT ............................................ 147 2.4.5 ZUWEISUNG MIT OPERATION (VERBUNDOPERATOR)................................................ 149 2.4.6 DIE RELATIONALEN OPERATOREN UND DIE GLEICHHEITSOPERATOREN ......................... 150 2.4.7 LOGISCHE OPERATOREN: NICHT, UND, ODER, XOR .................................................. 152 2.4.8 KURZSCHLUSS-OPERATOREN................................................................................... 153 2.4.9 DER RANG DER OPERATOREN IN DER AUSWERTUNGSREIHENFOLGE ............................. 155 2.4.10 DIE TYPUMWANDLUNG (DAS CASTING) ................................................................. 158 2.4.11 UEBERLADENES PLUS FUER STRINGS ........................................................................... 164 2.4.12 OPERATOR VE RM ISST.......................................................................................... 165 2.5 BEDINGTE ANWEISUNGEN ODER FALLUNTERSCHEIDUNGEN................................................ 166 2.5.1 VERZWEIGUNG M IT DER IF-ANWEISUNG ................................................................ 166 2.5.2 DIE ALTERNATIVE MIT EINER IF-ELSE-ANWEISUNG W AE H LE N ...................................... 169 2.5.3 DER BEDINGUNGSOPERATOR.................................................................................. 173 2.5.4 DIE SWITCH-ANWEISUNG BIETET DIE ALTERNATIVE ................................................. 175 2.6 IMMER DAS GLEICHE MIT DEN SCHLEIFEN ......................................................................... 182 2.6.1 DIE WHILE-SCHLEIFE............................................................................................. 182 2.6.2 DIE DO-WHILE-SCHLEIFE........................................................................................ 184 2.6.3 DIEFOR-SCHLEIFE.................................................................................................. 186 2.6.4 SCHLEIFENBEDINGUNGEN UND VERGLEICHE MIT == .............................................. 190 2.6.5 SCHLEIFENABBRUCH MIT BREAK UND ZURUECK ZUM TEST M IT CONTINUE .................... 192 2.6.6 BREAK UND CONTINUE MIT MARKEN * .................................................................... 195 2.7 METHODEN EINER KLASSE................................................................................................. 199 2.7.1 BESTANDTEIL EINER M ETHODE............................................................................... 200 2.7.2 SIGNATUR-BESCHREIBUNG IN DER JAVA-API ............................................................ 201 2.7.3 AUFRUF EINER M ETHODE....................................................................................... 203 2.7.4 METHODEN OHNE PARAMETER DEKLARIEREN........................................................... 203 2.7.5 STATISCHE METHODEN (KLASSENMETHODEN) ........................................................ 204 2.7.6 PARAMETER, ARGUMENT UND WERTUEBERGABE....................................................... 205 2.7.7 METHODEN VORZEITIG MIT RETURN BEENDEN......................................................... 207 2.7.8 NICHT ERREICHBARER QUELLCODE BEI METHODEN * ................................................. 208 2.7.9 METHODEN MIT RUECKGABEN ................................................................................ 209 2.7.10 METHODEN UEBERLADEN........................................................................................ 214 2.7.11 GUELTIGKEITSBEREICH............................................................................................. 216 2.7.12 VORGEGEBENER WERT FUER NICHT AUFGEFUEHRTE ARGUMENTE * ................................. 217 2.7.13 FINALE LOKALE VARIABLEN . ..................................................................................... 218 2.7.14 REKURSIVE METHODEN * ....................................................................................... 219 2.7.15 DIE TUERME VON HANOI * ..................................................................................... 224 2.8 ZUM WEITERLESEN........................................................................................................... 226 3 KLASSEN UND OBJEKTE 227 3.1 OBJEKTORIENTIERTE PROGRAMMIERUNG (OOP)................................................................. 227 3.1.1 WARUM UEBERHAUPT OOP?.................................................................................. 227 3.1.2 DENK ICH AN JAVA, DENK ICH AN WIEDERVERWENDBARKEIT.................................... 228 3.2 EIGENSCHAFTEN EINER KLASSE........................................................................................... 229 3.2.1 KLASSENARBEIT M IT POINT..................................................................................... 230 3.3 NATUERLICH MODELLIEREN MIT DER UML (UNIFIED MODELING LANGUAGE) * ....................... 230 3.3.1 HINTERGRUND UND GESCHICHTE DER UML * . .......................................................... 231 3.3.2 WICHTIGE DIAGRAMMTYPEN DER UML * ............................................................... 232 3.3.3 UML-WERKZEUGE * ............................................................................................. 233 3.4 NEUE OBJEKTE ERZEUGEN................................................................................................ 234 3.4.1 EIN EXEMPLAR EINER KLASSE M IT DEM SCHLUESSELWORT NEW ANLEGEN ..................... 235 3.4.2 DER ZUSAMMENHANG VON NEW, HEAP UND GARBAGE-COLLECTOR ........................ 235 3.4.3 DEKLARIEREN VON REFERENZVARIABLEN ................................................................. 236 3.4.4 JETZT MACH MAL NEN PUNKT: ZUGRIFF AUF OBJEKTATTRIBUTE UND -METHODEN ...... 238 3.4.5 UEBERBLICK UEBER POINT-METHODEN ...................................................................... 242 3.4.6 KONSTRUKTOREN NUTZEN...................................................................................... 245 3.5 ZZZZZNAKE..................................................................................................................... 246 3.6 PAKETE SCHNUEREN, IMPORTE UND KOMPILATIONSEINHEITEN........................................... 249 3.6.1 JAVA-PAKETE....................................................................................................... 249 3.6.2 PAKETE DER STANDARDBIBLIOTHEK ........................................................................ 249 3.6.3 VOLLE QUALIFIZIERUNG UND IMPORT-DEKLARATION ................................................. 249 3.6.4 M IT IMPORT PL.P2.* ALLE TYPEN EINES PAKETS ERREICHEN..................................... 251 3.6.5 HIERARCHISCHE STRUKTUREN UEBER PAKETE ............................................................ 251 3.6.6 DIE PACKAGE-DEKLARATION.................................................................................. 252 3.6.7 UNBENANNTES PAKET (DEFAULT PACKAGE)............................................................ 253 3.6.8 KLASSEN MIT GLEICHEN NAMEN IN UNTERSCHIEDLICHEN PAKETEN * ........................ 254 3.6.9 KOMPILATIONSEINHEIT (COMPILATION U N IT)......................................................... 254 3.6.10 STATISCHER IMPORT * ........................................................................................... 255 3.7 M IT REFERENZEN ARBEITEN, IDENTITAET UND GLEICHHEIT (GLEICHWERTIGKEIT).................. 256 3.7.1 NULL-REFERENZ UND DIE FRAGE DER PHILOSOPHIE................................................... 256 3.7.2 ALLES AUF NULL? REFERENZEN TE STEN .................................................................... 259 3.7.3 ZUWEISUNGEN BEI REFERENZEN .......................................................................... 260 3.7.4 METHODEN MIT REFERENZTYPEN ALS PARAMETERN................................................ 261 3.7.5 IDENTITAET VON OBJEKTEN..................................................................................... 265 3.7.6 GLEICHHEIT (GLEICHWERTIGKEIT) UND DIE METHODE EQUALS(...) ............................. 266 3.8 ZUM WEITERLESEN........................................................................................................... 268 4 ARRAYS UND IHRE ANWENDUNGEN 269 4.1 ARRAYS............................................................................................................................. 269 4.1.1 GRUNDBESTANDTEILE........................................................................................... 269 4.1.2 DEKLARATION VON ARRAY-VARIABLEN ..................................................................... 270 4.1.3 ARRAY-OBJEKTE M IT NEW ERZEUGEN .................................................................... 271 4.1.4 ARRAYS MIT IN H A LT.............................................................................................. 272 4.1.5 DIE LAENGE EINES ARRAYS UEBER DAS ATTRIBUT LENGTH AUSLESEN ............................. 273 4.1.6 ZUGRIFF AUF DIE ELEMENTE UEBER DEN INDEX......................................................... 274 4.1.7 TYPISCHE ARRAY-FEHLER....................................................................................... 276 4.1.8 ARRAYS ALS METHODENPARAMETER....................................................................... 277 4.1.9 VORINITIALISIERTE ARRAYS..................................................................................... 278 4.1.10 DIE ERWEITERTE FOR-SCHLEIFE .............................................................................. 279 4.1.11 ARRAYS M IT NICHTPRIMITIVEN ELEMENTEN ............................................................ 281 4.1.12 METHODE M IT VARIABLER ARGUMENTANZAHL (VARARGS) ......................................... 283 4.1.13 MEHRDIMENSIONALE ARRAYS * .............................................................................. 285 4.1.14 NICHTRECHTECKIGE A RRAYS* ................................................................................. 289 4.1.15 DIE WAHRHEIT UEBER DIE ARRAY-INITIALISIERUNG * .................................................. 291 4.1.16 MEHRERE RUECKGABEWERTE * ................................................................................. 292 4.1.17 KLONEN KANN SICH LOHNEN - ARRAYS VERMEHREN * ............................................... 293 4.1.18 ARRAY-INHALTE KOPIEREN * .................................................................................... 294 4.1.19 DIE KLASSE ARRAYS ZUM VERGLEICHEN, FUELLEN, SUCHEN, SORTIEREN NUTZEN ........... 295 4.1.20 EINE LANGE SCHLANGE.......................................................................................... 308 4.2 DER EINSTIEGSPUNKT FUER DAS LAUFZEITSYSTEM: M AIN(...)............................................... 311 4.2.1 KORREKTE DEKLARATION DER STARTMETHODE .......................................................... 311 4.2.2 KOMMANDOZEILENARGUMENTE VERARBEITEN ....................................................... 312 4.2.3 DER RUECKGABETYP VON MAIN(...) UND SYSTEM.EXIT(INT) * ..................................... 313 4.3 ZUM WEITERLESEN........................................................................................................... 315 5 DER UMGANG MIT ZEICHENKETTEN 317 5.1 VON ASCII UEBER ISO-8859-1 ZU UNICODE ...................................................................... 317 5.1.1 ASCII................................................................................................................... 317 5.1.2 ISO/IEC 8859-1 .................................................................................................. 318 5.1.3 UNICODE.............................................................................................................. 319 5.1.4 UNICODE-ZEICHENKODIERUNG.............................................................................. 321 5.1.5 ESCAPE-SEQUENZEN/FLUCHTSYMBOLE .................................................................. 322 5.1.6 SCHREIBWEISE FUER UNICODE-ZEICHEN UND UNICODE-ESCAPES .............................. 323 5.1.7 JAVA-VERSIONEN GEHEN M IT UNICODE-STANDARD HAND IN HAND * ....................... 325 5.2 DIE CHARACTER-KLASSE...................................................................................................... 326 5.2.1 IST DAS SO?.......................................................................................................... 326 5.2.2 ZEICHEN IN GROSSBUCHSTABEN/KLEINBUCHSTABEN KONVERTIEREN .......................... 329 5.2.3 VOM ZEICHEN ZUM S TRIN G .................................................................................. 330 5.2.4 VON CHAR IN INT: VOM ZEICHEN ZUR ZAHL * ............................................................ 330 5.3 ZEICHENFOLGEN................................................................................................................ 332 5.4 DIE KLASSE STRING UND IHRE METHODEN .......................................................................... 334 5.4.1 STRING-LITERALE ALS STRING-OBJEKTE FUER KONSTANTE ZEICHENKETTEN ..................... 334 5.4.2 KONKATENATION M IT + ......................................................................................... 334 5.4.3 STRING-LAENGE UND TEST AUF LEER-STRING ............................................................. 335 5.4.4 ZUGRIFF AUF EIN BESTIMMTES ZEICHEN M IT CHARAT(INT) ....................................... 336 5.4.5 NACH ENTHALTENEN ZEICHEN UND ZEICHENFOLGEN SUCHEN .................................. 337 5.4.6 DAS HANGMAN-SPIEL......................................................................................... 340 5.4.7 GUT, DASS W IR VERGLICHEN HABEN........................................................................ 342 5.4.8 STRING-TEILE EXTRAHIEREN.................................................................................... 346 5.4.9 STRINGS ANHAENGEN, ZUSAMMENFUEGEN, GROSS-/KLEINSCHREIBUNG UND WEISSRAUM 350 5.4.10 GESUCHT, GEFUNDEN, ERSETZT.............................................................................. 354 5.4.11 STRING-OBJEKTE MIT KONSTRUKTOREN UND AUS WIEDERHOLUNGEN ERZEUGEN * ...... 356 5.5 VERAENDERBARE ZEICHENKETTEN MIT STRINGBUILDER UND STRINGBUFFER ......................... 360 5.5.1 ANLEGEN VON STRINGBUILDER-OBJEKTEN............................................................... 361 5.5.2 STRINGBUILDER IN ANDERE ZEICHENKETTENFORMATE KONVERTIEREN ........................ 362 5.5.3 ZEICHEN(FOLGEN) ERFRAGEN ................................................................................. 362 5.5.4 DATEN ANHAENGEN.............................................................................................. 362 5.5.5 ZEICHEN(FOLGEN) SETZEN, LOESCHEN UND UMDREHEN ............................................. 364 5.5.6 LAENGE UND KAPAZITAET EINES STRINGBUILDER-OBJEKTS * ........................................ 367 5.5.7 VERGLEICH VON STRINGBUILDER-EXEMPLAREN UND STRING M IT STRINGBUILDER ......... 368 5.5.8 HASHCODE() BEI STRINGBUILDER * ......................................................................... 370 5.6 CHARSEQUENCE ALS BASISTYP.......................................................................................... 370 5.7 KONVERTIEREN ZWISCHEN PRIMITIVEN UND STRINGS......................................................... 373 5.7.1 UNTERSCHIEDLICHE TYPEN IN STRING-REPRAESENTATIONEN KONVERTIEREN ................ 373 5.7.2 STRING-INHALT IN EINEN PRIMITIVEN WERT KONVERTIEREN ...................................... 375 5.7.3 STRING-REPRAESENTATION IM FORMAT BINAER, HEX, OKTAL * ..................................... 377 5.7.4 PARSEXXX(...)- UND PRINTXXX()-METHODEN IN DATATYPECONVERTER * .................. 381 5.8 STRINGS ZUSAMMENHAENGEN (KONKATENIEREN).............................................................. 382 5.8.1 STRINGS M IT STRINGJOINER ZUSAMMENHAENGEN.................................................... 383 5.9 ZERLEGEN VON ZEICHENKETTEN........................................................................................ 384 5.9.1 SPLITTEN VON ZEICHENKETTEN M IT SPLIT(...) .......................................................... 385 5.9.2 YES WE CAN, YES WE SCAN - DIE KLASSE SCANNER ................................................ 386 5.10 AUSGABEN FORM ATIEREN................................................................................................. 390 5.10.1 FORMATIEREN UND AUSGEBEN M ITFORM ATQ ......................................................... 390 5.11 ZUM WEITERLESEN........................................................................................................... 396 6 EIGENE KLASSEN SCHREIBEN 397 6.1 EIGENE KLASSEN MIT EIGENSCHAFTEN DEKLARIEREN......................................................... 397 6.1.1 ATTRIBUTE DEKLARIEREN........................................................................................ 398 6.1.2 METHODEN DEKLARIEREN ..................................................................................... 400 6.1.3 VERDECKTE (SHADOWED) VARIABLEN .............................. 404 6.1.4 DIE THIS-REFERENZ ............................................................................................. 405 6.2 PRIVATSPHAERE UND S ICHTBARKEIT...................................................................................... 409 6.2.1 FUER DIE OEFFENTLICHKEIT: P U B LIC ............................................................................ 409 6.2.2 KEIN PUBLIC VIEWING - PASSWOERTER SIND P RIV A T.................................................. 410 6.2.B WIESO NICHT FREIE METHODEN UND VARIABLEN FUER ALLE?........................................ 411 6.2.4 PRIVAT IST NICHT GANZ PRIVAT: ES KOMMT DARAUF AN, WER S SIEHT * ....................... 412 6.2.5 ZUGRIFFSMETHODEN FUER ATTRIBUTE DEKLARIEREN ................................................... 412 6.2.6 SETTER UND GETTER NACH DER JAVABEANS-SPEZIFIKATION ...................................... 413 6.2.7 PAKETSICHTBAR..................................................................................................... 415 6.2.8 ZUSAMMENFASSUNG ZUR SICHTBARKEIT................................................................. 417 6 3 EINE FUE R ALLE - STATISCHE METHODEN UND STATISCHE A TTRIB U TE ..................................... 419 6.3.1 WARUM STATISCHE EIGENSCHAFTEN SINNVOLL S IN D ................................................. 420 6.3.2 STATISCHE EIGENSCHAFTEN M IT STA TIC................................................................... 421 6.3.3 STATISCHE EIGENSCHAFTEN UEBER REFERENZEN NUTZEN? * ....................................... 422 6.3.4 WARUM DIE GROSS- UND KLEINSCHREIBUNG WICHTIG IST * ....................................... 423 6.3.5 STATISCHE VARIABLEN ZUM DATENAUSTAUSCH * ..................................................... 423 6.3.6 STATISCHE EIGENSCHAFTEN UND OBJEKTEIGENSCHAFTEN * ....................................... 425 6.4 KONSTANTEN UND A UFZAEHLUNGEN.................................................................................... 426 6.4.1 KONSTANTEN UEBER STATISCHE FINALE VARIABLEN .................................................... 426 6.4.2 TYPUNSICHERE AUFZAEHLUNGEN ............................................................................ 427 6.4.3 AUFZAEHLUNGSTYPEN: TYPSICHERE AUFZAEHLUNGEN M IT E N U M ................................ 429 6.5 OBJEKTE ANLEGEN UND ZE RSTOE REN ................................................................................... 434 6.5.1 KONSTRUKTOREN SCHREIBEN.................................................................................. 434 6.5.2 VERWANDTSCHAFT VON METHODE UND KONSTRUKTOR ............................................. 436 6.5.3 DER STANDARD-KONSTRUKTOR (DEFAULT CONSTRUCTOR) ............................................ 436 6.5.4 PARAMETRISIERTE UND UEBERLADENE KONSTRUKTOREN ............................................. 438 6.5.5 COPY-KONSTRUKTOR.............................................................................................. 440 6.5.6 EINEN ANDEREN KONSTRUKTOR DER GLEICHEN KLASSE M IT THIS(...) A U FRU FE N ............ 441 6.5.7 IHR FEHLT UNS N IC H T-D E R GARBAGE-COLLECTOR..................................................... 444 6.6 KLASSEN- UND O BJEKTINITIALISIERUNG * ........................................................................... 446 6.6.1 INITIALISIERUNG VON OBJEKTVARIABLEN ................................................................. 446 6.6.2 STATISCHE BLOECKE ALS KLASSENINITIALISIERER.......................................................... 448 6.6.3 INITIALISIERUNG VON KLASSENVARIABLEN................................................................. 449 6.6.4 EINCOMPILIERTE BELEGUNGEN DER KLASSENVARIABLEN ........................................... 450 6.6.5 EXEMPLARINITIALISIERER (INSTANZINITIALISIERER) .................................................... 451 6.6.6 FINALE WERTE IM KONSTRUKTOR UND IN STATISCHEN BLOECKEN SETZEN ..................... 454 6.7 ZUM W E ITE RLESE N ........................................................................................................... 456 7 OBJEKTORIENTIERTE BEZIEHUNGSFRAGEN 457 7.1 ASSOZIATIONEN ZWISCHEN OBJEKTEN.............................................................................. 457 7.1.1 UNIDIREKTIONALE L:L-B EZIE HU NG ........................................................................ 458 7.1.2 ZWEI FREUNDE MUESST IHR WERDEN - BIDIREKTIONALE L:L-B EZIEHUNGEN .............. 459 7.1.3 UNIDIREKTIONALE L:N-BEZIEHUNG........................................................................ 460 7.2 VERERBUNG...................................................................................................................... 464 7.2.1 VERERBUNG IN JAVA............................................................................................. 464 7.2.2 SPIELOBJEKTE MODELLIEREN ................................................................................. 465 7.2.3 DIE IMPLIZITE BASISKLASSE JAVA.LANG.OBJECT ...................................................... 467 7.2.4 EINFACH-UND MEHRFACHVERERBUNG * ................................................................. 467 7.2.5 SEHEN KINDER ALLES? DIE SICHTBARKEIT PROTECTED ....... 468 7.2.6 KONSTRUKTOREN IN DER VERERBUNG UND SUPER(...)................................................ 469 7.3 TYPEN IN HIERARCHIEN.................................................................................................... 475 7.3.1 AUTOMATISCHE UND EXPLIZITE TYPUMWANDLUNG................................................ 475 7.3.2 DAS SUBSTITUTIONSPRINZIP.................................................................................. 478 7.3.3 TYPEN MIT DEM INSTANCEOF-OPERATOR TESTEN.................................................... 480 7.4 METHODEN UEBERSCHREIBEN............................................................................................. 482 7.4.1 METHODEN IN UNTERKLASSEN M IT NEUEM VERHALTEN AUSSTATTEN ....................... 482 7.4.2 M IT SUPER AN DIE ELTERN..................................................................................... 487 7.4.3 FINALE KLASSEN UND FINALE METHODEN ............................................................... 489 7.4.4 KOVARIANTE RUECKGABETYPEN .............................................................................. 491 7.4.5 ARRAY-TYPEN UND KOVARIANZ * ........................................................................... 492 7.5 DRUM PRUEFE, WER SICH DYNAMISCH B IN D ET.................................................................... 493 7.5.1 GEBUNDEN AN TOSTRING().................................................................................... 494 7.5.2 IMPLEMENTIERUNG VON SYSTEM.OUT.PRINTLN(OBJECT).......................................... 496 7.5.3 NICHT DYNAMISCH GEBUNDEN BEI PRIVATEN, STATISCHEN UND FINALEN M ETHODEN..................................................................................... 497 7.5.4 DYNAMISCH GEBUNDEN AUCH BEI KONSTRUKTORAUFRUFEN * .................................. 498 7.5.5 EINE LETZTE SPIELEREI MIT JAVAS DYNAMISCHER BINDUNG UND UEBERDECKTEN ATTRIBUTEN * .......................................................................... 500 7.6 ABSTRAKTE KLASSEN UND ABSTRAKTE M ETHODEN............................................................ 502 7.6.1 ABSTRAKTE KLASSEN............................................................................................. 502 7.6.2 ABSTRAKTE METHODEN ........................................................................................ 504 7.7 SCHNITTSTELLEN................................................................................................................. 510 7.7.1 SCHNITTSTELLEN SIND NEUE TYPEN........................................................................ 510 7.7.2 SCHNITTSTELLEN DEKLARIEREN................................................................................ 510 7.7.3 ABSTAKTE METHODEN IN SCHNITTSTELLEN.............................................................. 511 7.7.4 IMPLEMENTIEREN VON SCHNITTSTELLEN ................................................................. 512 7.7.5 EIN POLYMORPHIE-BEISPIEL MIT SCHNITTSTELLEN ................................................... 514 7.7.6 DIE MEHRFACHVERERBUNG BEI SCHNITTSTELLEN...................................................... 515 7.7.7 KEINE KOLLISIONSGEFAHR BEI MEHRFACHVERERBUNG * ............................................ 520 7.7.8 ERWEITERN VON INTERFACES-SUBINTERFACES ........................................................ 521 7.7.9 KONSTANTENDEKLARATIONEN BEI SCHNITTSTELLEN ................................................... 522 7.7.10 NACHTRAEGLICHES IMPLEMENTIEREN VON SCHNITTSTELLEN * ...................................... 524 7.7.11 STATISCHE AUSPROGRAMMIERTE METHODEN IN SCHNITTSTELLEN ............................. 525 7.7.12 ERWEITERN UND AENDERN VON SCHNITTSTELLEN ....................................................... 527 7.7.13 DEFAULT-METHODEN............................................................................................ 529 7.7.14 ERWEITERTE SCHNITTSTELLEN DEKLARIEREN UND NUTZEN........................................... 530 7.7.15 OEFFENTLICHE UND PRIVATE SCHNITTSTELLENMETHODEN ........................................... 533 7.7.16 ERWEITERTE SCHNITTSTELLEN, MEHRFACHVERERBUNG UND MEHRDEUTIGKEITEN * ....... 533 7.7.17 BAUSTEINE BILDEN MIT DEFAULT-METHODEN * ........................................................ 537 7.7.18 INITIALISIERUNG VON SCHNITTSTELLENKONSTANTEN * ................................................ 543 7.7.19 MARKIERUNGSSCHNITTSTELLEN............................................................................. 547 7.7.20 (ABSTRAKTE) KLASSEN UND SCHNITTSTELLEN IM VERGLEICH....................................... 548 7.8 SOLIDE MODELLIERUNG..................................................................................................... 549 7.8.1 DRY, KISS UND YAG N I......................................................................................... 549 7.8.2 SOLID................................................................................................................. 549 7.8.3 SEI NICHT STUPID................................................................................................ 551 7.9 ZUM W EITERLESEN........................................................................................................... 552 8 AUSNAHMEN MUESSEN SEIN 553 8.1 PROBLEMBEREICHE EINZAEUNEN........................................................................................ 553 8.1.1 EXCEPTIONS IN JAVA M IT TRY UND CA TCH ................................................................ 554 8.1.2 EINE NUMBERFORMATEXCEPTION AUFFANGEN ....................................................... 554 8.1.3 BITTE NICHT SCHLUCKEN - LEERE CATCH-BLOECKE ...................................................... 558 8.1.4 WIEDERHOLUNG ABGEBROCHENER BEREICHE ........................................................ 558 8.1.5 MEHRERE AUSNAHMEN AUFFANGEN ...................................................................... 559 8.1.6 ABLAUF EINER AUSNAHMESITUATION ..................................................................... 562 8.1.7 THROWS IM METHODENKOPF ANGEBEN ................................................................. 562 8.1.8 ABSCHLUSSBEHANDLUNG M IT FIN A LLY ..................................................................... 564 8.2 DIE KLASSENHIERARCHIE DER AUSNAHMEN....................................................................... 569 8.2.1 EIGENSCHAFTEN DES EXCEPTION-OBJEKTS.............................................................. 569 8.2.2 BASISTYP THROWABLE........................................................................................... 570 8.2.3 DIE EXCEPTION-HIERARCHIE................................................................................. 571 8.2.4 OBERAUSNAHMEN AUFFANGEN ............................................................................ 572 8.2.5 SCHON GEFANGEN?.............................................................................................. 574 8.2.6 ALLES GEHT ALS EXCEPTION DURCH ......................................................................... 574 8.2.7 ZUSAMMENFASSEN GLEICHER CATCH-BLOECKE MIT DEM MULTI-CATCH ...................... 576 8.3 RUNTIMEEXCEPTION MUSS NICHT AUFGEFANGEN W E RD E N ............................................... 579 8.3.1 BEISPIELE FUER RUNTIMEEXCEPTION-KLASSEN......................................................... 580 8.3.2 KANN MAN ABFANGEN, MUSS MAN ABER N IC H T.................................................... 581 8.4 HARTE FEHLER - ERROR * .................................................................................................... 581 8.5 AUSLOESEN EIGENER EXCEPTIONS....................................................................................... 582 8.5.1 M IT THROW AUSNAHMEN AUSLOESEN ..................................................................... 582 8.5.2 VORHANDENE RUNTIME-AUSNAHMETYPEN KENNEN UND NUTZEN ......................... 584 8.5.3 PARAMETER TESTEN UND GUTE FEHLERMELDUNGEN................................................ 587 8.5.4 NEUE EXCEPTION-KLASSEN DEKLARIEREN ............................................................... 589 8.5.5 EIGENE AUSNAHMEN ALS UNTERKLASSEN VON EXCEPTION ODER RUNTIMEEXCEPTION?.................................................................................. 590 8.5.6 AUSNAHMEN ABFANGEN UND WEITERLEITEN * ....................................................... 593 8.5.7 AUFRUF-STACK VON AUSNAHMEN VERAENDERN * ..................................................... 594 8.5.8 PRAEZISES RE TH RO W ............................................................................................. 595 8.5.9 GESCHACHTELTE AUSNAHMEN ........................................................................... 599 8.6 AUTOMATISCHES RESSOURCEN-MANAGEMENT (TRY M IT RESSOURCEN) ............................ 602 8.6.1 TRY MIT RESSOURCEN............................................................................................ 602 8.6.2 DIE SCHNITTSTELLE AUTOCLOSEABLE...................................................................... 605 8.6.3 MEHRERE RESSOURCEN NUTZEN............................................................................ 607 8.6.4 TRY MIT RESSOURCEN AUF NULL-RESSOURCEN .......................................................... 608 8.6.5 UNTERDRUECKTE AUSNAHMEN * ............................................................................. 608 8.7 BESONDERHEITEN BEI DER AUSNAHMEBEHANDLUNG * ..................................................... 611 8.7.1 RUECKGABEWERTE BEI AUSGELOESTEN AUSNAHMEN ................................................. 612 8.7.2 AUSNAHMEN UND RUECKGABEN VERSCHWINDEN - DAS DUO RETURN UND FIN A LLY ..... 612 8.7.3 THROWS BEI UEBERSCHRIEBENEN METHODEN .......................................................... 613 8.7.4 NICHT ERREICHBARE CATCH-KLAUSELN .................................................................... 615 8.8 ASSERTIONS * .................................................................................................................... 617 8.8.1 ASSERTIONS IN EIGENEN PROGRAMMEN NUTZEN.................................................... 617 8.8.2 ASSERTIONS AKTIVIEREN UND LAUFZEIT-ERRORS ....................................................... 617 8.8.3 ASSERTIONS FEINER AKTIVIEREN ODER DEAKTIVIEREN................................................ 620 8.9 ZUM W EITERLESEN........................................................................................................... 621 9.1 GESCHACHTELTE KLASSEN, SCHNITTSTELLEN, AUFZAEHLUNGEN ............................................. 623 9.2 STATISCHE GESCHACHTELTE TYPEN..................................................................................... 624 9.3 NICHTSTATISCHE GESCHACHTELTE TYPEN............................................................................ 626 9.3.1 EXEMPLARE INNERER KLASSEN ERZEUGEN............................................................... 626 9.3.2 DIETHIS-REFERENZ............................................................................................... 627 9.3.3 VOM COMPILER GENERIERTE KLASSENDATEIEN * .............................................. 628 9.3.4 ERLAUBTE MODIFIZIERER BEI AEUSSEREN UND INNEREN KLASSEN................................. 629 9.4 LOKALE KLASSEN ................................................................................................................ 629 9.4.1 BEISPIEL M IT EIGENER KLASSENDEKLARATION.......................................................... 630 9.4.2 LOKALE KLASSE FUER EINEN TIMER NUTZEN .............................................................. 631 9.5 ANONYME INNERE KLASSEN.............................................................................................. 631 9.5.1 NUTZUNG EINER ANONYMEN INNEREN KLASSE FUER DEN T IM E R ................................ 632 9.5.2 UMSETZUNG INNERER ANONYMER KLASSEN......................................................... 633 9.5.3 KONSTRUKTOREN INNERER ANONYMER KLASSEN ...................................................... 634 9.6 ZUGRIFF AUF LOKALE VARIABLEN AUS LOKALEN UND ANONYMEN KLASSEN ........................ 636 9.7 THIS IN UNTERKLASSEN * .................................................................................................... 637 9.7.1 GESCHACHTELTE KLASSEN GREIFEN AUF PRIVATE EIGENSCHAFTEN Z U ........................... 638 9.8 N ESTER.............................................................................................................................. 640 9.9 ZUM WEITERLESEN........................................................................................................... 641 10 BESONDERE TYPEN DER JAVA SE 643 10.1 OBJECT IST DIE MUTTER ALLER KLASSEN.............................................................................. 644 10.1.1 KLASSENOBJEKTE.................................................................................................. 644 10.1.2 OBJEKTIDENTIFIKATION M ITTOS TRINGO .................................................................. 645 10.1.3 OBJEKTGLEICHHEIT M IT EQUALS(...) UND ID E N TITAE T ................................................. 647 10.1.4 KLONEN EINES OBJEKTS M IT CLONE() * ................................................................... 653 10.1.5 HASHWERTE UEBER HASHCODE() LIEFERN * ............................................................... 658 10.1.6 SYSTEM.IDENTITYHASHCODE(...) UND DAS PROBLEM DER NICHT EINDEUTIGEN OBJEKTVERWEISE............................................................................................... 665 10.1.7 AUFRAEUMEN M IT FINALIZE() ................................................................................ 666 10.1.8 SYNCHRONISATION * .............................................................................................. 668 10.2 SCHWACHE REFERENZEN UND CLEANER............................................................................. 669 1 0 3 DIE UTILITY-KLASSE JAVA .U TIL.O BJE CTS ............................................................................ 670 10.3.1 EINGEBAUTE NULL-TESTS FUER EQUALS(...)/HASHCODE() ........................................... 670 10.3.2 OBJECTS.TOSTRING(...)........................................................................................... 671 10.3.3 NULL-PRUEFUNGEN MIT EINGEBAUTER AUSNAHMEBEHANDLUNG ............................... 672 10.3.4 TESTS AUF N U LL.................................................................................................... 673 10.3.5 INDEXBEZOGENE PROGRAMMARGUMENTE AUF KORREKTHEIT PRUEFEN....................... 673 10.4 VERGLEICHEN VON OBJEKTEN UND ORDNUNG H ERSTEILE N ................................................ 674 10.4.1 NATUERLICH GEORDNET ODER NICHT?........................................................................ 674 10.4.2 COMPAREXXX()-METHODE DER SCHNITTSTELLEN COMPARABLE UND COMPARATOR ... 675 10.4.3 RUECKGABEWERTE KODIEREN DIE ORDNUNG............................................................ 676 10.4.4 BEISPIEL-COMPARATOR: DEN KLEINSTEN RAUM EINER SAMMLUNG FINDEN ............. 677 10.4.5 TIPPS FUER COMPARATOR UND COMPARABLE-IMPLEMENTIERUNGEN ........................ 679 10.4.6 STATISCHE UND DEFAULT-METHODEN IN COM PARATOR........................................... 680 10.5 WRAPPER-KLASSEN UND A U TO B O X IN G ............................................................................. 683 10.5.1 WRAPPER-OBJEKTE ERZEUGEN.............................................................................. 685 10.5.2 KONVERTIERUNGEN IN EINE STRING-REPRAESENTATION ............................................. 687 10.5.3 VON EINER STRING-REPRAESENTATION PARSEN......................................................... 688 10.5.4 DIE BASISKLASSE NUMBER FUER NUMERISCHE WRAPPER-OBJEKTE............................ 688 10.5.5 VERGLEICHE DURCHFUEHREN MIT COMPAREXXX(...), COMPARETO(...), EQUALS(...) UND HASHWERTEN.............................................................................................. 690 10.5.6 STATISCHE REDUZIERUNGSMETHODEN IN WRAPPER-KLASSEN ................................. 693 10.5.7 KONSTANTEN FUER DIE GROESSE EINES PRIMITIVEN TYPS ............................................ 694 10.5.8 BEHANDELN VON VORZEICHENLOSEN ZAHLEN * ....................................................... 694 10.5.9 DIE KLASSE INTEGER............................................................................................. 696 10.5.10 DIE KLASSEN DOUBLE UND FLOATFUER FLIESSKOMMAZAHLEN .................................... 697 10.5.11 DIE LONG-KLASSE................................................................................................ 697 10.5.12 DIE BOOLEAN-KLASSE........................................................................................... 697 10.5.13 AUTOBOXING: BOXING UND UNBOXING................................................................. 699 10.6 ITERATOR, ITERABLE * ......................................................................................................... 703 10.6.1 DIE SCHNITTSTELLE ITERATOR.................................................................................. 703 10.6.2 WER DEN ITERATOR LIE FE RT.................................................................................... 706 10.6.3 DIE SCHNITTSTELLE ITERABLE.................................................................................. 707 10.6.4 ERWEITERTES FOR UND ITERABLE............................................................................. 708 10.6.5 INTERNE ITERATION............................................................................................... 708 10.6.6 EINEN EIGENEN ITERABLE IMPLEMENTIEREN * ....................................................... 709 10.7 DIE SPEZIAL-OBERKLASSE E NUM ...................................................................................... 710 10.7.1 METHODEN AUF ENUM-OBJEKTEN........................................................................ 711 10.7.2 AUFZAEHLUNGEN MIT EIGENEN METHODEN UND INITIALISIERERN * ............................ 714 10.7.3 ENUM MIT EIGENEN KONSTRUKTOREN * ........................... 717 10.8 ANNOTATIONEN IN DER JAVA SE......................................................................................... 720 10.8.1 ORTE FUER ANNOTATIONEN ...................................................................................... 721 10.8.2 ANNOTATIONSTYPEN AUS JAVA.LANG ...................................................................... 721 10.8.3 @DEPRECATED..................................................................................................... 722 10.8.4 ANNOTATIONEN M IT ZUSAETZLICHEN INFORM ATIONEN ............................................... 722 10.8.5 @SUPPRESSWARNINGS........................................................................................ 723 10.9 ZUM W EITERLESEN........................................................................................................... 726 11 GENERICS T 727 11.1 EINFUEHRUNG IN JAVA GENERICS......................................................................................... 727 11.1.1 MENSCH VERSUS MASCHINE - TYPPRUEFUNG DES COMPILERS UND DER LAUFZEITUMGEBUNG.............................................................................. 727 11.1.2 RAKETEN.............................................................................................................. 728 11.1.3 GENERISCHE TYPEN DEKLARIEREN . ......................................................................... 730 11.1.4 GENERICS NUTZEN................................................................................................ 731 11.1.5 DIAMONDS AREFOREVER....................................................................................... 734 11.1.6 GENERISCHE SCHNITTSTELLEN................................................................................. 737 11.1.7 GENERISCHE METHODEN/KONSTRUKTOREN UND TYP-INFERENZ................................ 739 11.2 UMSETZEN DER GENERICS, TYPIOESCHUNG UND RAW-TYPES ............................................. 743 11.2.1 REALISIERUNGSMOEGLICHKEITEN............................................................................. 743 11.2.2 TYPLOESCHUNG (TYPE ERASURE).............................................................................. 743 11.2.3 PROBLEME DER TYPLOESCHUNG............................................................................... 745 11.2.4 RAW-TYPE ........................................................................................................... 750 11.3 EINSCHRAENKEN DER TYPEN UEBER BOUNDS......................................................................... 752 11.3.1 EINFACHE EINSCHRAENKUNGEN MIT EXTENDS........................................................... 753 11.3.2 WEITERE OBERTYPEN MIT & ................................................................................. 755 11.4 TYPPARAMETER IN DER THROWS-KLAUSEL * ........................................................................ 756 11.4.1 DEKLARATION EINER KLASSE M IT TYPVARIABLE E EXTENDS EXCEPTION .................. 756 11.4.2 PARAMETRISIERTER TYP BEI TYPVARIABLE E EXTENDS EXCEPTION ......................... 756 11.5 GENERICS UND VERERBUNG, INVARIANZ............................................................................. 759 11.5.1 ARRAYS SIND KOVARIANT........................................................................................ 759 11.5.2 GENERICS SIND NICHT KOVARIANT, SONDERN INVA RIA NT............................................ 760 11.5.3 WILDCARDS M IT ? ................................................................................................. 761 11.5.4 BOUNDED W ILDCARDS........................................................................................... 763 11.5.5 BOUNDED-WILDCARD-TYPEN UND BOUNDED-TYPVARIABLEN ................................... 767 11.5.6 DAS LESS-PRINZIP ................................................................................................ 769 11.5.7 ENUM E EXTENDS ENUM E * .......................................................................... 771 11.6 KONSEQUENZEN DER TYPLOESCHUNG: TYP-TOKEN, ARRAYS UND BRUECKEN * ...................... 773 11.6.1 TYP-TOKEN......................................................................................................... 773 11.6.2 SUPER-TYPE-TOKEN............................................................................................. 775 11.6.3 GENERICS UND ARRAYS ......................................................................................... 776 11.6.4 BRUECKENMETHODEN............................................................................................ 777 11.7 ZUM WEITERLESEN........................................................................................................... 783 12 LAMBDA-AUSDRUECKE UND FUNKTIONALE PROGRAMMIERUNG 785 12.1 CODE = DATEN ............................................................................. 785 12.2 FUNKTIONALE SCHNITTSTELLEN UND LAMBDA-AUSDRUECKE IM D E TA IL ................................ 788 12.2.1 FUNKTIONALE SCHNITTSTELLEN .............................................................................. 789 12.2.2 TYP EINES LAMBDA-AUSDRUCKS ERGIBT SICH DURCH Z IE LTY P ................................. 790 12.2.3 ANNOTATION @FUNCTIONALLNTERFACE .................................................................. 794 12.2.4 SYNTAX FUER LAMBDA-AUSDRUECKE......................................................................... 795 12.2.5 DIE UMGEBUNG DER LAMBDA-AUSDRUECKE UND VARIABLENZUGRIFFE ..................... 800 12.2.6 AUSNAHMEN IN LAMBDA-AUSDRUECKEN................................................................ 804 12.2.7 KLASSEN M IT EINER ABSTRAKTEN METHODE ALS FUNKTIONALE SCHNITTSTELLE? * ........ 808 12.3 METHODENREFERENZ........................................................................................................ 809 12.3.1 VARIANTEN VON METHODENREFERENZEN............................................................... 811 12.4 KONSTRUKTORREFERENZ..................................................................................................... 813 12.4.1 PARAMETERLOSE UND PARAMETRISIERTE KONSTRUKTOREN ....................................... 815 12.4.2 NUETZLICHE VORDEFINIERTE SCHNITTSTELLEN FUER KONSTRUKTORREFERENZEN ................ 815 12.5 IMPLEMENTIERUNG VON LAMBDA-AUSDRUECKEN * ........................................................... 816 12.6 FUNKTIONALE PROGRAMMIERUNG MIT JAVA ..................................................................... 817 12.6.1 PROGRAMMIERPARADIGMEN: IMPERATIV ODER DEKLARATIV..................................... 817 12.6.2 FUNKTIONALE PROGRAMMIERUNG UND FUNKTIONALE PROGRAMMIERSPRACHEN ........ 818 12.6.3 FUNKTIONALE PROGRAMMIERUNG IN JAVA AM BEISPIEL VOM COMPARATOR............. 819 12.6.4 LAMBDA-AUSDRUECKE ALS FUNKTIONEN SEHEN ...................................................... 820 12.7 FUNKTIONALE SCHNITTSTELLE AUS DEM JAVA.UTIL.FUNCTION-PAKET .................................. 821 12.7.1 BLOECKE MIT CODE UND DIE FUNKTIONALE SCHNITTSTELLE CONSUMER ....................... 822 12.7.2 SUPPLIER............................................................................................................. 824 12.7.3 PRAEDIKATE UND JAVA.UTIL.FUNCTION.PREDICATE ...................................................... 824 12.7.4 FUNKTIONEN UEBER DIE FUNKTIONALE SCHNITTSTELLE JAVA.UTIL.FUNCTION.FUNCTION ... 826 12.7.5 EIN BISSCHEN B I ............................................................ 830 12.7.6 FUNKTIONALE SCHNITTSTELLEN M IT PRIM ITIVEN ...................................................... 833 12.8 OPTIONAL IST KEINE NULLNUMMER................................................................................... 836 12.8.1 OPTIONAL-TYP..................................................................................................... 838 12.8.2 PRIMITIVE OPTIONALE TYPEN ................................................................................ 841 12.8.3 ERSTMAL FUNKTIONAL M IT O PTIONAL ...................................................................... 842 12.9 WAS IST JETZT SO FUNKTIONAL?.......................................................................................... 847 12.10 ZUM WEITERLESEN........................................................................................................... 849 13 ARCHITEKTUR, DESIGN UND ANGEWANDTE OBJEKTORIENTIERUNG SSI 13.1 ARCHITEKTUR, DESIGN UND IMPLEMENTIERUNG................................................................ 851 13.2 DESIGN-PATTERNS (ENTWURFSMUSTER)............................................................................. 852 13.2.1 MOTIVATION FUER DESIGN-PATTERNS ....................................................................... 852 13.2.2 SINGLETON........................................................................................................... 853 13.2.3 FABRIKMETHODEN................................................................................................ 854 13.2.4 DAS BEOBACHTER-PATTERN M IT LISTENER REALISIEREN ............................................ 856 13.3 ZUM W EITERLESEN........................................................................................................... 860 14 KOMPONENTEN, JAVABEANS UND MODULE SEI 14.1 JAVABEANS....................................................................................................................... 861 14.1.1 PROPERTIES (EIGENSCHAFTEN)................................................................................ 862 14.1.2 EINFACHE EIGENSCHAFTEN..................................................................................... 863 14.1.3 INDIZIERTE EIGENSCHAFTEN................................................................................... 863 14.1.4 GEBUNDENE EIGENSCHAFTEN UND PROPERTYCHANGELISTENER ............................... 863 14.1.5 VETO-EIGENSCHAFTEN-DAGEGEN!....................................................................... 867 14.2 KLASSENLADER (DASS LOADER) UND MODUL-/KLASSENPFAD ............................................. 870 14.2.1 KLASSENLADEN AUF A B RU F..................................................................................... 871 14.2.2 KLASSENLADER BEI DER ARBEIT ZUSEHEN ................................................................ 871 14.2.3 JMOD-DATEIEN UND JAR-DATEIEN ...................................................................... 872 14.2.4 WOHER DIE KLEINEN KLASSEN KOMMEN. DIE SUCHORTE UND SPEZIELLE KLASSENLADER.......................................................... 873 14.2.5 SETZEN DES MODULPFADES .................................................................................. 874 14.3 MODULE ENTWICKELN UND EINBINDEN............................................................................. 876 14.3.1 WER SIEHT W E N ................................................................................................... 876 14.3.2 PLATTFORM-MOD ULE UND JMOD-BEISPIEL ............................................................ 878 14.3.3 INTERNE PLATTFORMEIGENSCHAFTEN NUTZEN, --ADD-EXPORTS.................................. 878 14.3.4 NEUE MODULE EINBINDEN,--ADD-MODULES UND--ADD-OPENS.............................. 881 14.3.5 PROJEKTABHAENGIGKEITEN IN ECLIPSE..................................................................... 882 14.3.6 BENANNTE MODULE UND MODULE-INFO.JAVA ............................................. 884 14.3.7 AUTOMATISCHE M OD ULE ..................................................................................... 887 14.3.8 UNBENANNTES M ODUL........................................... ......... ................................... 888 14.3.9 LESBARKEIT UND ZUGREIFBARKEIT.......................................................................... 889 14.3.10 M ODUL-M IGRATION.............................................................................................. 890 14.4 ZUM WEITERLESEN.......................................................................................................... 891 15 DIE KLASSENBIBLIOTHEK 893 15.1 DIE JAVA-KLASSENPHILOSOPHIE....................................................................................... 893 15.1.1 MODUL, PAKET, T Y P ............................................................................................. 893 15.1.2 UEBERSICHT UEBER DIE PAKETE DER STANDARDBIBLIOTHEK......................................... 896 15.2 EINFACHE ZEITMESSUNG UND PROFILING ........................................................................ 901 15.3 DIE KLASSE CLASS............................................................................................................. 904 15.3.1 AN EIN CLASS-OBJEKT KOM M EN........................................................... 904 15.3.2 EINE CLASS IST EIN T YPE...................................................................................... 906 15.4 KLASSENLADER.................................................................................................................. 907 15.4.1 DIE KLASSE JAVA.LANG.CLASSLOADER ..................................................................... 908 15.5 DIE UTILITY-KLASSEN SYSTEM UND PROPERTIES ............................................................... 908 15.5.1 SPEICHER DER JVM.............................................................................................. 910 15.5.2 ANZAHL CPUS/KERNE.......................................................................................... 911 15.5.3 SYSTEMEIGENSCHAFTEN DER JAVA-UMGEBUNG..................................................... 911 15.5.4 EIGENE PROPERTIES VON DER KONSOLE AUS SETZEN * .............................................. 913 15.5.5 ZEILENUMBRUCHZEICHEN, LINE.SEPARATOR ............................................................ 915 15.5.6 UMGEBUNGSVARIABLEN DES BETRIEBSSYSTEMS..................................................... 916 15.6 SPRACHEN DER LAENDER..................................................................................................... 917 15.6.1 SPRACHEN IN REGIONEN UEBER LOCALE-OBJEKTE..................................................... 917 15.7 WICHTIGE DATUM-KLASSEN IM UEBERBLICK...................................................................... 922 15.7.1 DER 1.1.1970 ..................................................................................................... 922 15.7.2 SYSTEM.CURRENTTIMEMILLISO.............................................................................. 923 15.7.3 EINFACHE ZEITUMRECHNUNGEN DURCH TIM EU NIT ................................................ 923 15.8 DATE-TIME-API............................................................................................................... 924 15.8.1 MENSCHENZEIT UND MASCHINENZEIT .............................. 926 15.8.2 DATUMSKLASSE LOCALDATE.................................................................................. 929 15.9 LOGGING MIT JAVA............................................................................................................ 930 15.9.1 LOGGING-APIS...................................................................................................... 930 15.9.2 LOGGING M IT JAVA.UTIL.LOGGING ............................................................................ 931 15.10 MAVEN: BUILD-MANAGEMENT UND ABHAENGIGKEITEN AUFLOESEN................................... 933 15.10.1 BEISPIELPROJEKT IN ECLIPSE M IT M AVEN................................................................ 934 15.10.2 PROPERTIES HINZUNEHMEN.................................................................................. 934 15.10.3 DEPENDENCY HINZUNEHMEN .............................................................................. 935 15.10.4 LOKALES UND REMOTE-REPOSITORY ....................................................................... 936 15.10.5 LEBENSZYLUS, PHASEN UND MAVEN-PLUGINS ........................................................ 936 15.10.6 ARCHETYPES......................................................................................................... 937 15.11 ZUM WEITERLESEN........................................................................................................... 937 16 EINFUEHRUNG IN DIE NEBENLAEUFIGE PROGRAMMIERUNG 939 16.1 NEBENLAEUFIGKEIT UND PARALLELITAET ................................................................................ 939 16.1.1 MULTITASKING, PROZESSE, THREADS....................................................................... 940 16.1.2 THREADS UND PROZESSE....................................................................................... 940 16.1.3 WIE NEBENLAEUFIGE PROGRAMME DIE GESCHWINDIGKEIT STEIGERN KOENNEN ........... 941 16.1.4 WAS JAVA FUER NEBENLAEUFIGKEIT ALLES B IE TE T ....................................................... 943 16.2 LAUFENDE THREADS, NEUE THREADS ERZEUGEN................................................................ 943 16.2.1 MAIN-THREAD..................................................................................................... 944 16.2.2 WER BIN ICH? ...................................................................................................... 944 16.2.3 DIE SCHNITTSTELLE RUNNABLE IMPLEMENTIEREN ................................................... 944 16.2.4 THREAD M IT RUNNABLE STARTEN ........................................................................... 946 16.2.5 RUNNABLE PARAMETRISIEREN................................................................................ 947 16.2.6 DIE KLASSE THREAD ERW EITERN............................................................................. 948 16.3 THREAD-EIGENSCHAFTEN UND ZUSTAENDE.......................................................................... 950 16.3.1 DER NAME EINES THREADS................................................................................... 951 16.3.2 DIE ZUSTAENDE EINES THREADS * ........................................................................... 951 16.3.3 SCHLAEFER GESUCHT................................................................................................ 952 16.3.4 M IT YIELD() UND ONSPINWAIT() AUF RECHENZEIT VERZICHTEN................................. 954 16.3.5 WANN THREADS FERTIG S IN D ................................................................................. 955 16.3.6 EINEN THREAD HOEFLICH M IT INTERRUPT BEENDEN ................................................... 955 16.3.7 UNBEHANDELTE AUSNAHMEN, THREAD-ENDE UND UNCAUGHTEXCEPTIONHANDLER...................................................................... 958 16.3.8 DER STOP() VON AUSSEN UND DIE RETTUNG MIT THREADDEATH * ............................. 959 16.3.9 EIN RENDEZVOUS M IT JOIN(...) * ............................................................................ 960 16.3.10 ARBEIT NIEDERLEGEN UND WIEDER AUFNEHMEN * .................................................. 962 16.3.11 PRIORITAET * ........................................................................................................... 963 16.4 DER AUSFUEHRER (EXECUTOR) K O M M T............................................................................... 964 16.4.1 DIE SCHNITTSTELLE EXECUTOR................................................................................ 965 16.4.2 GLUECKLICH IN DER GRUPPE - DIE THREAD-POOLS..................................................... 966 16.4.3 THREADS MIT RUECKGABE UEBER CALLABLE ............................................................... 968 16.4.4 ERINNERUNGEN AN DIE ZUKUNFT - DIE FUTURE-RUECKGABE..................................... 970 16.4.5 MEHRERE CALLABLE-OBJEKTE ABARBEITEN............................................................. 973 16.4.6 COMPLETIONSERVICE UND EXECUTORCOMPLETIONSERVICE...................................... 975 16.4.7 SCHEDULEDEXECUTORSERVICE FUER WIEDERHOLENDE AUFGABEN UND ZEITSTEUERUNGEN NUTZEN........................................................................... 976 16.5 ZUM WEITERLESEN........................................................................................................... 977 17 EINFUEHRUNG IN DATENSTRUKTUREN UND ALGORITHMEN 979 17.1 LISTEN.............................................................................................................................. 979 17.1.1 ERSTES LISTEN-BEISPIEL........................................................................................ 980 17.1.2 AUSWAHLKRITERIUM ARRAYUEST ODER LINKEDUEST.................................................... 981 17.1.3 DIE SCHNITTSTELLE L IS T ........................................................................................ 981 17.1.4 ARRAYLIST............................................................................................................ 988 17.1.5 LINKEDLIST.......................................................................................................... 989 17.1.6 DER ARRAY-ADAPTER ARRAYS.ASLIST(...).................................................................. 991 17.1.7 LISTLTERATOR * ...................................................................................................... 993 17.1.8 TOARRAY(...) VON COLLECTION VERSTEHEN - DIE GEFAHR EINER FALLE ERKENNEN ......... 994 17.1.9 PRIMITIVE ELEMENTE IN DATENSTRUKTUREN VERWALTEN .......................................... 998 17.2 MENGEN (SETS)................................................................................................................ 998 17.2.1 EIN ERSTES MENGEN-BEISPIEL.............................................................................. 999 17.2.2 METHODEN DER SCHNITTSTELLE S E T....................................................................... 1001 17.2.3 HASHSET............................................................................................................ 1003 17.2.4 TREESET-DIE SORTIERTE M ENGE ......................................................................... 1003 17.2.5 DIE SCHNITTSTELLEN NAVIGABLESET UND SORTEDSET ............................................... 1005 17.2.6 LINKEDHASHSET.................................................................................................. 1008 17.3 JAVA STREAM A P I............................................................................................................ 1009 17.3.1 DEKLARATIVES PROGRAMMIEREN........................................................................... 1009 17.3.2 INTERNE VERSUS EXTERNE ITERATION...................................................................... 1009 17.3.3 WAS IST EIN STREAM? ......................................................................................... 1010 17.4 STREAM ERZEUGEN ......................... 1012 17.4.1 PARALLELE ODER SEQUENZIELLE STREAMS................................................................ 1015 17.5 TERMINALE STREAM-OPERATIONEN ............................................. 1016 17.5.1 ANZAHL ELEMENTE.............................................................................................. 1016 17.5.2 UND JETZT ALLE-FOREACHXXX(...)......................................................................... 1017 17.5.3 EINZELNE ELEMENTE AUS DEM STROM H OLEN ........................................................ 1017 17.5.4 EXISTENZTESTS M IT PRAEDIKATEN ............................................................................ 1018 17.5.5 STROM REDUZIEREN AUF KLEINSTES/GROESSTES ELEMENT............................................ 1018 17.5.6 STROM MIT EIGENEN FUNKTIONEN REDUZIEREN ..................................................... 1019 17.5.7 ERGEBNISSE IN EINEN CONTAINER SCHREIBEN, TEIL L:CO LLE CT(...) ............................. 1021 17.5.8 ERGEBNISSE IN EINEN CONTAINER SCHREIBEN, TEIL 2: COLLECTOR UND COLLECTORS ....... 1022 17.5.9 ERGEBNISSE IN EINEN CONTAINER SCHREIBEN, TEIL 3: GRUPPIERUNGEN ................... 1024 17.5.10 STREAM-ELEMENTE IN ARRAY ODER ITERATOR UEBERTRAGEN ....................................... 1026 17.6 INTERMEDIAERE STREAM-OPERATIONEN............................................................................. 1027 17.6.1 ELEMENT-VORSCHAU ............................................................................................ 1028 17.6.2 FILTERN VON ELEMENTEN ...................................................................................... 1028 17.6.3 STATUS BEHAFTETE INTERMEDIAERE OPERATIONEN.................................................... 1028 17.6.4 PRAEFIX-OPERATION................................................................................................ 1030 17.6.5 ABBILDUNGEN ...................................................................................................... 1031 17.7 ZUM WEITERLESEN........................................................................................................... 1033 18 EINFUEHRUNG IN GRAFISCHE OBERFLAECHEN 1035 18.1 GUI-FRAMEWORKS............................................................................................................ 1035 18.1.1 KOMMANDOZEILE................................................................................................ 1035 18.1.2 GRAFISCHE BENUTZEROBERFLAECHE.......................................................................... 1035 18.1.3 ABSTRACT WINDOW TOOLKIT (AWT) .................................................................... 1036 18.1.4 JAVA FOUNDATION CLASSES UND S W ING................................................................. 1036 18.1.5 JAVAFX................................................................................................................ 1036 18.1.6 SWT (STANDARD WIDGET TOOLKIT) * ...................................................................... 1038 18.2 DEKLARATIVE UND PROGRAMMIERTE OBERFLAECHEN........................................................... 1039 18.2.1 GUI-BESCHREIBUNGEN IN JAVAFX......................................................................... 1040 18.2.2 DEKLARATIVE GUI-BESCHREIBUNGEN FUER SWING? ................................................... 1040 18.3 GUI-BUILDER..................................................................................................................... 1041 18.3.1 GUI-BUILDER FUER JAVAFX...................................................................................... 1041 18.3.2 GUI-BUILDER FUER SWING....................................................................................... 1042 18.4 M IT DEM ECLIPSE WINDOWBUILDER ZUR ERSTEN SWING-OBERFLAECHE .............................. 1042 18.4.1 WINDOWBUILDER INSTALLIEREN.............................................................................. 1042 18.4.2 M IT WINDOWBUILDER EINE GUI-KLASSE HINZUFUEGEN............................................ 1044 18.4.3 LAYOUTPROGRAMM STA RTEN ................................................................................. 1046 18.4.4 GRAFISCHE OBERFLAECHE AUFBAUEN ....................................................................... 1047 18.4.5 SWING-KOMPONENTEN-KLASSEN.......................................................................... 1049 18.4.6 FUNKTIONALITAET GEBEN ........................................................................................ 1051 18.5 GRUNDLEGENDES ZUM ZEICHNEN..................................................................................... 1054 18.5.1 DIE PAINT(GRAPHICS)-METHODE FUER DAS AWT-FRAME......................................... 1054 18.5.2 DIE EREIGNISORIENTIERTE PROGRAMMIERUNG AENDERT FENSTERINHALTE ................... 1056 18.5.3 ZEICHNEN VON INHALTEN AUF EINEN JFRAME ........................................................ 1057 18.5.4 AUFFORDERN ZUM NEUZEICHNEN MIT REPAINT(...) ................................................. 1058 18.5.5 JAVA 2D-API ...................................................................................................... 1059 18.6 ZUM WEITERLESEN........................................................................................................... 1060 19 EINFUEHRUNG IN DATEIEN UND DATENSTROEME 1061 19.1 ALTE UND NEUE WELT IN JAVA.IO UND JAVA.NIO ............................................................... 1061 19.1.1 JAVA.IO-PAKET M IT FILE-KLASSE............................................................................ 1061 19.1.2 NIO.2 UND JAVA.NIO-PAKET................................................................................. 1062 19.1.3 JAVA.IO.FILE ODER JAVA.NIO.? ............................................................................... 1062 19.2 DATEISYSTEME UND PFADE.............................................................................................. 1063 19.2.1 FILESYSTEM UND P ATH......................................................................................... 1063 19.2.2 DIE UTILITY-KLASSE FILES...................................................................................... 1069 19.3 DATEIEN MIT WAHLFREIEM ZUGRIFF.................................................................................. 1072 19.3.1 EIN RANDOMACCESSFILE ZUM LESEN UND SCHREIBEN OE FFN E N ............................... 1072 19.3.2 AUS DEM RANDOMACCESSFILE LESEN................................................................... 1073 19.3.3 SCHREIBEN MIT RANDOMACCESSFILE.................................................................... 1076 19.3.4 DIE LAENGE DES RANDOMACCESSFILE .................................................................... 1076 19.3.5 HIN UND HER IN DER D ATEI................................................................................... 1077 19.4 BASISKLASSEN FUER DIE EIN-/AUSGABE.............................................................................. 1078 19.4.1 DIE VIER ABSTRAKTEN BASISKLASSEN ..................................................................... 1078 19.4.2 DIE ABSTRAKTE BASISKLASSE OUTPUTSTREAM ........................................................ 1079 19.4.3 DIE ABSTRAKTE BASISKLASSE INPUTSTREAM ........................................................... 1081 19.4.4 DIE ABSTRAKTE BASISKLASSE W RITE R ..................................................................... 1084 19.4.5 DIE SCHNITTSTELLE APPENDABLE ........................................................................ 1086 19.4.6 DIE ABSTRAKTE BASISKLASSE READER .................................................................... 1087 19.4.7 DIE SCHNITTSTELLEN CLOSEABLE, AUTOCLOSEABLE UND FLUSHABLE........................... 1090 19.5 LESEN AUS DATEIEN UND SCHREIBEN IN D ATEIEN............................................................ 1092 19.5.1 BYTEORIENTIERTE DATENSTROEME UEBER FILES BEZIEHEN .......................................... 1092 19.5.2 ZEICHENORIENTIERTE DATENSTROEME UEBER FILES BEZIEHEN..................................... 1093 19.5.3 FUNKTION VON OPENOPTION BEI DEN FILES.NEWXXX(...)-METHODEN .................... 1095 19.5.4 RESSOURCEN AUS DEM MODULPFAD UND AUS JAR-DATEIEN LADEN.......................... 1096 19.6 ZUM WEITERLESEN........................................................................................................... 1098 20 EINFUEHRUNG INS DATENBANKMANAGEMENT MIT JDBC 1099 20.1 RELATIONALE DATENBANKEN UND DATENBANKMANAGEMENTSYSTEME .......................... 1099 20.1.1 DAS RELATIONALE M O D E LL...................................................................................... 1099 20.1.2 H2-DATENBANK................................................................................................... 1100 20.1.3 WEITERE DATENBANK-MANAGEMENT-SYSTEME * ................................................. 1100 20.2 JDBC UND DATENBANKTREIBER......................................................................................... 1102 20.2.1 H2-DATENBANK UND JDBC-TREIBER..................................................................... 1103 20.2.2 JDBC-VERSIONEN * ............................................................................................... 1103 20.3 EINE BEISPIELABFRAGE..................................................................................................... 1104 20.3.1 SCHRITTE ZUR DATENBANKABFRAGE........................................................................ 1104 20.3.2 M IT JAVA AUF DIE RELATIONALE DATENBANKZUGREIFEN........................................... 1105 20.4 ZUM WEITERLESEN........................................................................................................... 1106 21 EINFUEHRUNG IN XML 1107 21.1 AUSZEICHNUNGSSPRACHEN ................................................................... 1107 21.1.1 EXTENSIBLE MARKUP LANGUAGE (XML)................................................................. 1108 21.2 EIGENSCHAFTEN VON XML-DOKUMENTEN........................................................................ 1108 21.2.1 ELEMENTE UND A TTRIB U TE .................................................................................... 1108 21.2.2 BESCHREIBUNGSSPRACHE FUER DEN AUFBAU VON XML-DOKUMENTEN ...................... 1111 21.2.3 SCHEMA - DIE MODERNE ALTERNATIVE ZU D TD ..................................................... 1115 21.2.4 NAMENSRAUM (NAMESPACE).............................................................................. 1118 21.2.5 XML-APPLIKATIONEN * ......................................................................................... 1119 21.3 DIE JAVA-APIS FUER XM L .................................................................................................... 1120 21.3.1 DAS DOCUMENT OBJECT MODEL (DOM)................................................................ 1121 21.3.2 PULL-API STAX.................................... 1121 21.3.3 SIMPLE API FOR XML PARSING (SAX)..................................................................... 1121 21.3.4 JAVA DOCUMENT OBJECT MODEL (JDOM) ............................................................. 1122 21.3.5 JAXP ALS JAVA-SCHNITTSTELLE ZU XM L................................................................... 1122 21.3.6 DOM-BAEUME EINIESEN MIT JAXP * ..................................................................... 1123 21.4 JAVA ARCHITECTURE FOR XML BINDING (JAXB) ................................................................. 1124 21.4.1 JAXB RAUS AUS DER JAVA SE, ABHAENGIGKEIT REIN IN DIE POM ............................... 1124 21.4.2 BEAN FUER JAXB AUFBAUEN ................................................................................... 1125 21.4.3 UTILITY-KLASSE JAXB............................................................................................ 1126 21.4.4 GANZE OBJEKTGRAPHEN SCHREIBEN UND LESEN..................................................... 1127 21.4.5 JAXBCONTEXT UND MARSHALLER/UNMARSHALLER NUTZEN ...................................... 1129 21.5 ZUM WEITERLESEN........................................................................................................... 1131 22 BITS UND BYTES, MATHEMATISCHES UND GELD 1133 22.1 BITS UND B YTES................................................................................................................ 1133 22.1.1 DIE BIT-OPERATOREN KOMPLEMENT, UND, ODER UND XOR ................................... 1134 22.1.2 REPRAESENTATION GANZER ZAHLEN IN JAVA - DAS ZWEIERKOMPLEMENT.................. 1135 22.1.3 DAS BINAERE (BASIS 2), OKTALE (BASIS 8), HEXADEZIMALE (BASIS 16) STELLENWERTSYSTEM ........................................................................................... 1137 22.1.4 AUSWIRKUNG DER TYPUMWANDLUNG AUF DIE BIT-M USTER .................................... 1138 22.1.5 VORZEICHENLOS ARBEITEN........................................................... 1140 22.1.6 DIE VERSCHIEBEOPERATOREN............................................................................... 1143 22.1.7 EIN BIT SETZEN, LOESCHEN, UMDREHEN UND TESTEN ................................................ 1146 22.1.8 BIT-METHODEN DER INTEGER- UND LONG-KLASSE................................................... 1146 22.2 FLIESSKOM M A-ARITHM ETIK IN JAVA ................................................................................. 1148 22.2.1 SPEZIALWERTE FUER UNENDLICH, NULL, NAN............................................................ 1148 22.2.2 STANDARDNOTATION UND WISSENSCHAFTLICHE NOTATION BEI FLIESSKOMMAZAHLEN * ................................................................................... 1152 22.2.3 MANTISSE UND EXPONENT * ................................................................................. 1152 22.5 DIE EIGENSCHAFTEN DER KLASSE M A TH ............................................................................ 1154 22.3.1 A TTRIB U TE ........................................................................................................... 1154 22.3.2 ABSOLUTWERTE UND VORZEICHEN ......................................................................... 1154 22.3.3 M AXIM UM /M INIM UM ....................................................................................... 1155 22.3.4 RUNDEN VON W ERTEN......................................................................................... 1156 22.3.5 REST DER GANZZAHLIGEN DIVISION * ..................................................................... 1158 22.3.6 DIVISION MIT RUNDUNG RICHTUNG NEGATIV UNENDLICH, ALTERNATIVER RESTWERT * ..................................................................................... 1159 22.3.7 MULTIPLY-ACCUMULATE........................................................................................ 1161 22.3.8 WURZEL- UND EXPONENTIALMETHODEN ............................................................... 1161 22.3.9 DER LOGARITHMUS * ............................................................................................. 1162 22.3.10 WINKELMETHODEN * ........................................................................................... 1163 22.3.11 ZUFALLSZAHLEN.................................................................................................... 1165 22.4 GENAUIGKEIT, WERTEBEREICH EINES TYPS UND UEBERLAUFKONTROLLE * ........................... 1165 22.4.1 DER GROESSTE UND DER KLEINSTE W E RT.................................................................... 1165 22.4.2 UEBERLAUF UND ALLES GANZ EXAKT ..................................... 1166 22.4.3 WAS BITTE MACHT EINE ULP? ............................................................................... 1169 22.5 ZUFALLSZAHLEN: RANDOM, SECURERANDOM, SPLITTABLERANDOM ................................... 1170 22.5.1 DIE KLASSE RANDOM ........................................................................................... 1171 22.5.2 RANDOM-OBJEKTE M IT DEM SAMEN AUFBAUEN ................................................... 1171 22.5.3 EINZELNE ZUFALLSZAHLEN ERZEUGEN...................................................................... 1172 22.5.4 PSEUDO-ZUFALLSZAHLEN IN DER NORMALVERTEILUNG * ............................................ 1172 22.5.5 STROM VON ZUFALLSZAHLEN GENERIEREN * .............................................................. 1173 22.5.6 DIE KLASSE SECURERANDOM * .............................................................................. 1174 22.5.7 SPLITTABLERANDOM* ........................................................................................... 1175 22.6 GROSSE Z AH LE N ............................................................................................................... 1175 22.6.1 DIE KLASSE BIGLNTEGER........................................................................................ 1176 22.6.2 BEISPIEL: GANZ LANGE FAKULTAETEN M IT BIGLNTEGER............................................... 1183 22.6.3 GROSSE FLIESSKOMMAZAHLEN M IT BIGDECIMAL ...................................................... 1184 22.6.4 M IT MATHCONTEXT KOMFORTABEL DIE RECHENGENAUIGKEIT SETZEN........................ 1187 22.6.5 NOCH SCHNELLER RECHNEN DURCH MUTABLE IMPLEMENTIERUNGEN ........................ 1188 22.7 MATHE BITTE STRIKT ........................................................................................................ 1188 22.7.1 STRIKTE FLIESSKOMMABERECHNUNGEN M IT S TRIC TFP ............................................... 1189 22.7.2 DIE KLASSEN MATH UND S TRICTM ATH.................................................................... 1189 22.8 GELD UND W AEHRUNG........................................................................................................ 1190 22.8.1 GELDBETRAEGE REPRAESENTIEREN............................................................................. 1190 22.8.2 ISO 4 2 1 7 ............................................................................................................ 1190 22.8.3 WAEHRUNGEN IN JAVA REPRAESENTIEREN ................................................... 1191 22.9 ZUM WEITERLESEN........................................................................................................... 1192 23 TESTEN MIT JUNIT 1193 23.1 SOFTWARETESTS................................................................................................................. 1193 23.1.1 VORGEHEN BEIM SCHREIBEN VON TESTFAELLEN ........................................................ 1194 23.2 DAS TEST-FRAMEWORK JU N IT........................................................................................... 1194 23.2.1 TEST-DRIVEN DEVELOPMENT UND TEST-FIRST......................................................... 1195 23.2.2 TESTEN, IMPLEMENTIEREN, TESTEN, IMPLEMENTIEREN, TESTEN, FRE U E N .................. 1196 23.2.3 JUNIT-TESTS AUSFUEHREN ...................................................................................... 1198 23.2.4 ASSERTXXX(...)-METHODEN DER KLASSE ASSERT ...................................................... 1198 23.2.5 HAMCREST........................................................................................................... 1201 23.2.6 EXCEPTIONS TE STE N .............................................................................................. 1205 23.2.7 TESTS IGNORIEREN................................................................................................ 1207 23.2.8 GRENZEN FUER AUSFUEHRUNGSZEITEN FESTLEGEN ...................................................... 1207 23.2.9 M IT METHODEN DER ASSUMPTIONS-KLASSE TESTS ABBRECHEN .............................. 1208 23.3 WIE GUTES DESIGN DAS TESTEN ERMOEGLICHT................................................................... 1208 23.4 AUFBAU GROESSERER TESTFAELLE..................................................................................... 1210 23.4.1 FIXTURES............................................................................................................. 1211 23.4.2 SAMMLUNGEN VON TESTKLASSEN UND KLASSENORGANISATION ............................... 1213 23.5 DUMMY, FAKE, STUB UND M OCK .................................................................................... 1214 23.6 JUNIT-ERWEITERUNGEN, TESTZUSAETZE.............................................................................. 1215 23.7 ZUM WEITERLESEN........................................................................................................... 1216 24 DIE WERKZEUGE DES JDK 1217 24.1 UEBERSICHT........................................................................................................................ 1217 24.1.1 AUFBAU UND GEMEINSAME SCHALTER.................................................................. 1218 24.2 JAVA-QUELLEN UEBERSETZEN.............................................................................................. 1218 24.2.1 JAVA-COMPILER VOM JD K ................................................................................... 1218 24.2.2 ALTERNATIVE COM PILER........................................................................................ 1219 24.2.3 NATIVE COM PILER............................................................................................... 1220 24.2.4 JAVA-PROGRAMME IN EIN NATIVES AUSFUEHRBARES PROGRAMM EINPACKEN ............ 1220 24.3 DIE JAVA-LAUFZEITUMGEBUNG........................................................................................ 1221 24.3.1 SCHALTER DER JVM .............................................................................................. 1221 24.3.2 DER UNTERSCHIED ZWISCHENJAVA.EXE UNDJAVAW.EXE ........................................ 1224 24.4 JLINK: DER JAVA LINKER..................................................................................................... 1224 24.5 DOKUMENTATIONSKOMMENTARE MIT JAVADOC............................................................... 1225 24.5.1 EINEN DOKUMENTATIONSKOMMENTAR SETZEN ..................................................... 1226 24.5.2 M IT DEM WERKZEUG JAVADOC EINE DOKUMENTATION ERSTELLEN........................... 1228 24.5.3 HTML-TAGS IN DOKUMENTATIONSKOMMENTAREN * ............................................. 1229 24.5.4 GENERIERTE DATEIEN........................................................................................... 1229 24.5.5 DOKUMENTATIONSKOMMENTARE IM UE BERBLICK* ................................................ 1229 24.5.6 JAVADOC UND DOCLETS * ....................................................................................... 1231 24.5.7 VERALTETE (DEPRECATED) TYPEN UND EIGENSCHAFTEN........................................... 1231 24.5.8 JAVADOC-UEBERPRUEFUNG M IT DOCLINT................................................................... 1234 24.6 DAS ARCHIVFORMAT JAR................................................................................................... 1235 24.6.1 DAS DIENSTPROGRAMM JAR BENUTZEN................................................................. 1236 24.6.2 DAS M ANIFEST.................................................................................................... 1238 24.6.3 APPLIKATIONEN IN JAR-ARCHIVEN STARTEN ............................................................ 1239 24.7 ZUM WEITERLESEN........................................................................................................... 1240 ANHANG....................................................................................................................................... 1241 IN D E X........................................................................................................................................... 1261
any_adam_object	1
author	Ullenboom, Christian
author_GND	(DE-588)123404738
author_facet	Ullenboom, Christian
author_role	aut
author_sort	Ullenboom, Christian
author_variant	c u cu
building	Verbundindex
bvnumber	BV045373256
classification_rvk	ST 250
classification_tum	DAT 362f
ctrlnum	(OCoLC)1082328546 (DE-599)DNB1172148783
discipline	Informatik
edition	14., aktualisierte und überarbeitete Auflage
format	Book
fullrecord	<?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>03318nam a2200721 c 4500</leader><controlfield tag="001">BV045373256</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20190917 </controlfield><controlfield tag="007">t\|</controlfield><controlfield tag="008">181217s2019 gw a\|\|\| \|\|\|\| 00\|\|\| ger d</controlfield><datafield tag="015" ind1=" " ind2=" "><subfield code="a">18,N48</subfield><subfield code="2">dnb</subfield></datafield><datafield tag="016" ind1="7" ind2=" "><subfield code="a">1172148783</subfield><subfield code="2">DE-101</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9783836267212</subfield><subfield code="c">Hbk.: EUR 49.90 (DE), EUR 51.30 (AT), CHF 63.90 (freier Preis)</subfield><subfield code="9">978-3-8362-6721-2</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">3836267217</subfield><subfield code="c">Hbk.</subfield><subfield code="9">3-8362-6721-7</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)1082328546</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)DNB1172148783</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rda</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">DE</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-703</subfield><subfield code="a">DE-860</subfield><subfield code="a">DE-1050</subfield><subfield code="a">DE-384</subfield><subfield code="a">DE-739</subfield><subfield code="a">DE-11</subfield><subfield code="a">DE-1049</subfield><subfield code="a">DE-29T</subfield><subfield code="a">DE-862</subfield><subfield code="a">DE-859</subfield><subfield code="a">DE-91G</subfield><subfield code="a">DE-20</subfield><subfield code="a">DE-19</subfield><subfield code="a">DE-Aug4</subfield><subfield code="a">DE-523</subfield><subfield code="a">DE-573</subfield><subfield code="a">DE-91</subfield><subfield code="a">DE-824</subfield><subfield code="a">DE-83</subfield><subfield code="a">DE-29</subfield><subfield code="a">DE-M347</subfield><subfield code="a">DE-634</subfield><subfield code="a">DE-12</subfield><subfield code="a">DE-150</subfield><subfield code="a">DE-706</subfield><subfield code="a">DE-1046</subfield><subfield code="a">DE-1102</subfield><subfield code="a">DE-1051</subfield><subfield code="a">DE-B768</subfield><subfield code="a">DE-861</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">004</subfield><subfield code="2">sdnb</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Ullenboom, Christian</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)123404738</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Java ist auch eine Insel</subfield><subfield code="b">Einführung, Ausbildung, Praxis</subfield><subfield code="c">Christian Ullenboom</subfield></datafield><datafield tag="250" ind1=" " ind2=" "><subfield code="a">14., aktualisierte und überarbeitete Auflage</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Bonn</subfield><subfield code="b">Rheinwerk Verlag</subfield><subfield code="c">2019</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">1278 Seiten</subfield><subfield code="b">Diagramme, Illustrationen</subfield><subfield code="c">24 cm x 19 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">Rheinwerk computing</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">Auf dem Umschlag: "Aktuell zu Java 11"</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">Auf dem Umschlag: "Programmieren mit der Java Platform, Standard Edition 11; Java von A bis Z: Einführung, Praxis, Referenz; Von Ausdrücken und Anweisungen zu Klassen und Objekten"</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 Standard Edition 8</subfield><subfield code="0">(DE-588)1049861094</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 11</subfield><subfield code="0">(DE-588)1176042394</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 9</subfield><subfield code="0">(DE-588)113696553X</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Hand-Buch Anleitung Einführung Tutorial Grundlagen lernen Ideen Tipps Workshop Ausbildung Rheinwerk-Verlag Galileo Computing</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Eclipse</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">NetBeans</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">xml</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Performanz</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Lambda Expressions</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">JDK</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Oracle</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Objektorientiert programmieren lernen OOP</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Referenz</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Datenbanken</subfield></datafield><datafield tag="655" ind1=" " ind2="7"><subfield code="0">(DE-588)4123623-3</subfield><subfield code="a">Lehrbuch</subfield><subfield code="2">gnd-content</subfield></datafield><datafield tag="689" ind1="0" 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="0" ind2="1"><subfield code="a">Java Standard Edition 11</subfield><subfield code="0">(DE-588)1176042394</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 Standard Edition 8</subfield><subfield code="0">(DE-588)1049861094</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="1" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="689" ind1="2" ind2="0"><subfield code="a">Java Standard Edition 11</subfield><subfield code="0">(DE-588)1176042394</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="2" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="689" ind1="3" ind2="0"><subfield code="a">Java Standard Edition 9</subfield><subfield code="0">(DE-588)113696553X</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="3" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="710" ind1="2" ind2=" "><subfield code="a">Galileo Press</subfield><subfield code="0">(DE-588)1065964404</subfield><subfield code="4">pbl</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">X:MVB</subfield><subfield code="q">text/html</subfield><subfield code="u">http://deposit.dnb.de/cgi-bin/dokserv?id=94c422f160934eeeab134debc0e58690&prov=M&dok_var=1&dok_ext=htm</subfield><subfield code="3">Inhaltstext</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">DNB Datenaustausch</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=030759701&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA</subfield><subfield code="3">Inhaltsverzeichnis</subfield></datafield><datafield tag="943" ind1="1" ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-030759701</subfield></datafield></record></collection>
genre	(DE-588)4123623-3 Lehrbuch gnd-content
genre_facet	Lehrbuch
id	DE-604.BV045373256
illustrated	Illustrated
indexdate	2024-12-20T18:25:29Z
institution	BVB
institution_GND	(DE-588)1065964404
isbn	9783836267212 3836267217
language	German
oai_aleph_id	oai:aleph.bib-bvb.de:BVB01-030759701
oclc_num	1082328546
open_access_boolean
owner	DE-703 DE-860 DE-1050 DE-384 DE-739 DE-11 DE-1049 DE-29T DE-862 DE-BY-FWS DE-859 DE-91G DE-BY-TUM DE-20 DE-19 DE-BY-UBM DE-Aug4 DE-523 DE-573 DE-91 DE-BY-TUM DE-824 DE-83 DE-29 DE-M347 DE-634 DE-12 DE-150 DE-706 DE-1046 DE-1102 DE-1051 DE-B768 DE-861
owner_facet	DE-703 DE-860 DE-1050 DE-384 DE-739 DE-11 DE-1049 DE-29T DE-862 DE-BY-FWS DE-859 DE-91G DE-BY-TUM DE-20 DE-19 DE-BY-UBM DE-Aug4 DE-523 DE-573 DE-91 DE-BY-TUM DE-824 DE-83 DE-29 DE-M347 DE-634 DE-12 DE-150 DE-706 DE-1046 DE-1102 DE-1051 DE-B768 DE-861
physical	1278 Seiten Diagramme, Illustrationen 24 cm x 19 cm
publishDate	2019
publishDateSearch	2019
publishDateSort	2019
publisher	Rheinwerk Verlag
record_format	marc
series2	Rheinwerk computing
spellingShingle	Ullenboom, Christian Java ist auch eine Insel Einführung, Ausbildung, Praxis Java Programmiersprache (DE-588)4401313-9 gnd Java Standard Edition 8 (DE-588)1049861094 gnd Java Standard Edition 11 (DE-588)1176042394 gnd Java Standard Edition 9 (DE-588)113696553X gnd
subject_GND	(DE-588)4401313-9 (DE-588)1049861094 (DE-588)1176042394 (DE-588)113696553X (DE-588)4123623-3
title	Java ist auch eine Insel Einführung, Ausbildung, Praxis
title_auth	Java ist auch eine Insel Einführung, Ausbildung, Praxis
title_exact_search	Java ist auch eine Insel Einführung, Ausbildung, Praxis
title_full	Java ist auch eine Insel Einführung, Ausbildung, Praxis Christian Ullenboom
title_fullStr	Java ist auch eine Insel Einführung, Ausbildung, Praxis Christian Ullenboom
title_full_unstemmed	Java ist auch eine Insel Einführung, Ausbildung, Praxis Christian Ullenboom
title_short	Java ist auch eine Insel
title_sort	java ist auch eine insel einfuhrung ausbildung praxis
title_sub	Einführung, Ausbildung, Praxis
topic	Java Programmiersprache (DE-588)4401313-9 gnd Java Standard Edition 8 (DE-588)1049861094 gnd Java Standard Edition 11 (DE-588)1176042394 gnd Java Standard Edition 9 (DE-588)113696553X gnd
topic_facet	Java Programmiersprache Java Standard Edition 8 Java Standard Edition 11 Java Standard Edition 9 Lehrbuch
url	http://deposit.dnb.de/cgi-bin/dokserv?id=94c422f160934eeeab134debc0e58690&prov=M&dok_var=1&dok_ext=htm http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=030759701&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
work_keys_str_mv	AT ullenboomchristian javaistaucheineinseleinfuhrungausbildungpraxis AT galileopress javaistaucheineinseleinfuhrungausbildungpraxis

Verfügbarkeit

Bestellen (Login erforderlich)

Inhaltsverzeichnis
Paper/Kapitel scannen lassen

Teilbibliothek Stammgelände, Lehrbuchsammlung

Bestandsangaben von Teilbibliothek Stammgelände, Lehrbuchsammlung
Signatur:	0003 DAT 362f 2008 L 985(14) Lageplan
Exemplar 1	Ausleihbar Am Standort
Exemplar 2	Ausleihbar Am Standort
Exemplar 3	Ausleihbar Am Standort
Exemplar 4	Ausleihbar Am Standort
Exemplar 5	Ausleihbar Am Standort

Teilbibliothek Stammgelände

Bestandsangaben von Teilbibliothek Stammgelände
Signatur:	0004 DAT 362f 2008 A 7856(14) Lageplan
Exemplar 1	Nicht ausleihbar Am Standort

Teilbibliothek Mathematik & Informatik

Bestandsangaben von Teilbibliothek Mathematik & Informatik
Signatur:	0104 DAT 362f 2006 A 5010(14) Lageplan
Exemplar 1	Nicht ausleihbar Am Standort

Teilbibliothek Chemie, Lehrbuchsammlung

Bestandsangaben von Teilbibliothek Chemie, Lehrbuchsammlung
Signatur:	0303 DAT 362f 2006 L 325(14) Lageplan
Exemplar 1	Ausleihbar Am Standort
Exemplar 2	Ausleihbar Am Standort
Exemplar 3	Ausleihbar Am Standort
Exemplar 4	Ausleihbar Am Standort
Exemplar 5	Ausleihbar Am Standort
Exemplar 6	Ausleihbar Am Standort
Exemplar 7	Ausleihbar Am Standort
Exemplar 8	Ausleihbar Am Standort
Exemplar 9	Ausleihbar Am Standort
Exemplar 10	Ausleihbar Am Standort
Exemplar 11	Ausleihbar Am Standort
Exemplar 12	Ausleihbar Am Standort
Exemplar 13	Ausleihbar Am Standort
Exemplar 14	Ausleihbar Am Standort
Exemplar 15	Ausleihbar Am Standort