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 2022
Ausgabe:	16., aktualisierte und überarbeitete Auflage
Schriftenreihe:	Rheinwerk Computing
Schlagwörter:	Java Standard Edition 17 Java > Programmiersprache Standard Edition 17 Hand-Buch Bücher Grundlagen Kurse Tipps Workshops Tutorials Anleitung Training Ausbildung Informatik Eclipse NetBeans xml Performanz Lambda-Expressions JDBC JDK JSON Oracle Objektorientiert programmieren OOP Referenz Datenbanken Programmierung Software-Entwicklung Java-17 Lehrbuch
Links:	http://deposit.dnb.de/cgi-bin/dokserv?id=4393074fa45844a39f89095b23200cdb&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=032936087&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
Beschreibung:	Auf dem Cover: Programmieren mit der Java Platform, Standard Edition 17 ; Java von A bis Z: Einführung, Praxis, Referenz ; von Ausdrücken und Anweisungen zu Klassen und Objekten ; das Standardwerk
Umfang:	1258 Seiten Illustrationen 24 cm x 19 cm
ISBN:	9783836287456 3836287455

Internformat

MARC


LEADER	00000nam a22000008c 4500
001	BV047560644
003	DE-604
005	20230417
007	t\|
008	211027s2022 gw a\|\|\| \|\|\|\| 00\|\|\| ger d
016	7		\|a 1241344973 \|2 DE-101
020			\|a 9783836287456 \|c Festeinband : EUR 49.90 (DE), EUR 51.30 (AT), CHF 63.90 (freier Preis) \|9 978-3-8362-8745-6
020			\|a 3836287455 \|9 3-8362-8745-5
035			\|a (OCoLC)1284785486
035			\|a (DE-599)BVBBV047560644
040			\|a DE-604 \|b ger \|e rda
041	0		\|a ger
044			\|a gw \|c XA-DE-NW
049			\|a DE-188 \|a DE-1050 \|a DE-858 \|a DE-739 \|a DE-Aug4 \|a DE-29T \|a DE-19 \|a DE-M347 \|a DE-706 \|a DE-1049 \|a DE-1102 \|a DE-B768 \|a DE-573 \|a DE-573n \|a DE-355 \|a DE-861 \|a DE-1028 \|a DE-860 \|a DE-824 \|a DE-523 \|a DE-83
082	0		\|a 005.133 \|2 23/ger
084			\|a ST 250 \|0 (DE-625)143626: \|2 rvk
084			\|a 004 \|2 sdnb
084			\|a DAT 362 \|2 stub
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 16., aktualisierte und überarbeitete Auflage
264		1	\|a Bonn \|b Rheinwerk \|c 2022
300			\|a 1258 Seiten \|b 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 Cover: Programmieren mit der Java Platform, Standard Edition 17 ; Java von A bis Z: Einführung, Praxis, Referenz ; von Ausdrücken und Anweisungen zu Klassen und Objekten ; das Standardwerk
650	0	7	\|a Java Standard Edition 17 \|0 (DE-588)1286419034 \|2 gnd \|9 rswk-swf
650	0	7	\|a Java \|g Programmiersprache \|0 (DE-588)4401313-9 \|2 gnd \|9 rswk-swf
653			\|a Standard Edition 17
653			\|a Hand-Buch Bücher Grundlagen Kurse Tipps Workshops Tutorials Anleitung Training Ausbildung Informatik
653			\|a Eclipse
653			\|a NetBeans
653			\|a xml
653			\|a Performanz
653			\|a Lambda-Expressions
653			\|a JDBC
653			\|a JDK
653			\|a JSON
653			\|a Oracle
653			\|a Objektorientiert programmieren OOP
653			\|a Referenz
653			\|a Datenbanken
653			\|a Programmierung
653			\|a Software-Entwicklung
653			\|a Java-17
655		7	\|0 (DE-588)4123623-3 \|a Lehrbuch \|2 gnd-content
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 17 \|0 (DE-588)1286419034 \|D s
689	0		\|5 DE-604
710	2		\|a Rheinwerk Verlag \|0 (DE-588)1081738405 \|4 pbl
780	0	0	\|i Vorangegangen ist \|z 978-3-8362-7737-2
856	4	2	\|q text/html \|u http://deposit.dnb.de/cgi-bin/dokserv?id=4393074fa45844a39f89095b23200cdb&prov=M&dok_var=1&dok_ext=htm \|3 Inhaltstext
856	4	2	\|m Digitalisierung UB Passau - ADAM Catalogue Enrichment \|q application/pdf \|u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=032936087&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA \|3 Inhaltsverzeichnis
943	1		\|a oai:aleph.bib-bvb.de:BVB01-032936087

Datensatz im Suchindex

_version_	1819334618157940736
adam_text	Auf einen Blick Auf einen Blick 1 Java ist auch eine Sprache.................................................................................... 49 2 Imperative Sprachkonzepte................................................................................. 97 3 Klassen und Objekte............................................................................................. 225 4 Arrays und ihre Anwendungen ........................................................................... 267 5 Der Umgang mit Zeichen und Zeichenketten................................................... 315 6 Eigene Klassen schreiben ..................................................................................... 399 7 Objektorientierte Beziehungsfragen.................................................................. 461 8 Schnittstellen, Aufzählungen, versiegelte Klassen, Records............................ 519 9 Ausnahmen müssen sein ..................................................................................... 577 10 Geschachtelte Typen............................................................................................. 643 11 Besondere Typen der Java SE............................................................................... 663 12 Generics T ........................................................................................................... 737 13 Lambda-Ausdrücke und funktionale Programmierung................................... 793 14 Architektur, Design und angewandte Objektorientierung............................. 865 15 Java Platform Module System........................................................................ 879 16 Die Klassenbibliothek........................................................................................... 903 17 Einführung in die nebenläufige Programmierung........................................... 949 18 Einführung in Datenstrukturen und Algorithmen ........................................... 991 19 Einführung in grafische Oberflächen.................................................................. 1051 20 Einführung in Dateien und Datenströme........................................................... 1077 21 Einführung ins Datenbankmanagement mit JDBC........................................... 1113 22 Bits und Bytes, Mathematisches und Geld ........................................................ 1119 23 Testen mit JUnit..................................................................................................... 1177 24 Die Werkzeuge des JDK......................................................................................... 1201 Inhalt Inhalt Materialien zum Buch............................................................................................................... 30 Vorwort...................................................................................................................................... 31 1 Java ist auch eine Sprache 49 1.1 Historischer Hintergrund ............................................................................................ 50 1.2 Warum Java populär ist - die zentralen Eigenschaften.......................................... 52 1.2.1 Bytecode .......................................................................................................... 52 1.2.2 Ausführung des Bytecodes durch eine virtuelle Maschine............................ 53 1.3 1.4 1.5 1.2.3 Plattformunabhängigkeit............................................................................... 53 1.2.4 Java als Sprache, Laufzeitumgebung und Standardbibliothek...................... 54 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...................... 56 1.2.8 Das Java-Security-Modell................................................................................ 57 1.2.9 Zeiger und Referenzen.................................................................................... 58 1.2.10 Bring den Müll raus, Garbage- Collector!........................................................ 59 1.2.11 Ausnahmebehandlung.................................................................................... 60 1.2.12 Das Angebot an Bibliotheken und Werkzeugen............................................. 61 1.2.13 Vergleichbar einfache Syntax.......................................................................... 62 1.2.14 Java ist Open Source........................................................................................ 63 1.2.15 Wofür sich Java weniger eignet...................................................................... 64 Java im Vergleich zu anderen Sprachen ................................................................. 65 1.3.1 Java und C(++).................................................................................................. 66 1.3.2 Java und JavaScript......................................................................................... 66 1.3.3 Ein Wort zu Microsoft, Java und zu J++........................................................... 66 1.3.4 Java und C#/.NET............................................................................................. 67 Weiterentwicklung und Verluste............................................................................... 68 1.4.1 Die Entwicklung von Java und seine Zukunftsaussichten.............................. 68 1.4.2 Features, Enhancements (Erweiterungen) und ein JSR.................................. 70 1.4.3 Applets ............................................................................................................ 70 1.4.4 JavaFX.............................................................................................................. 71 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 für die Kleinen.......................................................................... 75 5 Inhalt 1.6 1.7 1.8 1.9 1.10 2 2.1 2.2 6 1.5.3 Java für die ganz, ganz Kleinen .............................................................. 75 1.5.4 Java für die Großen: Jakarta ЕЕ (ehemals Java ЕЕ)........................................... 76 1.5.5 Echtzeit-Java (Real-time Java).......................................................................... 77 Java SE-Implementierungen ....................................................................................... 77 1.6.1 OpenJDK........................................................................................................... 78 1.6.2 Oracle JDK......................................................................................................... 79 JDK installieren.............................................................................................................. 80 1.7.1 AdoptOpenJDK unter Windows installieren.................................................... 80 Das erste Programm compilierenund testen............................................................. 82 1.8.1 Ein Quadratzahlen-Programm ........................................................................ 83 1.8.2 Der Compilerlauf.............................................................................................. 84 1.8.3 Die Laufzeitumgebung..................................................................................... 85 1.8.4 Häufige Compiler-und Interpreter-Probleme................................................. 85 Entwicklungsumgebungen.......................................................................................... 86 1.9.1 IntelliJ IDEA....................................................................................................... 87 1.9.2 Eclipse IDE......................................................................................................... 88 1.9.3 NetBeans.......................................................................................................... 95 Zum Weiterlesen............................................................................................. Imperative Sprachkonzepte Elemente der Programmiersprache Java................................................................... 96 97 97 2.1.1 Token................................................................................................................ 98 2.1.2 Textkodierung durch Unicode-Zeichen........................................................... 99 2.1.3 Bezeichner....................................................... 99 2.1.4 Literale.............................................................................................................. 101 2.1.5 (Reservierte) Schlüsselwörter .......................................................................... 101 2.1.6 Zusammenfassung der lexikalischen Analyse................................................ 103 2.1.7 Kommentare..................................................................................................... 103 Von der Klasse zur Anweisung.................................................................................... 105 2.2.1 Was sind Anweisungen?.................................................................................. 106 2.2.2 Klassendeklaration........................................................................................... 106 2.2.3 Die Reise beginnt am main(String[])............................................................... 107 2.2.4 Der erste Methodenaufruf: printing.)............................................................. 108 2.2.5 Atomare Anweisungen und Anweisungssequenzen...................................... 109 2.2.6 Mehr zu print(...), printing.) und printf(...) für Bildschirmausgaben............... 110 2.2.7 Die API-Dokumentation................................................................................... 111 2.2.8 Ausdrücke......................................................................................................... 112 Inhalt 2.2.9 2.3 2.4 2.5 2.6 Ausdrucksanweisung...................................................................................... 113 2.2.10 Erster Einblick in die Objektorlentierung........................................................ 114 2.2.11 Modifizierer..................................................................................................... 115 2.2.12 Gruppieren von Anweisungen mit Blöcken.................................................... 115 Datentypen, Typisierung, Variablen und Zuweisungen......................................... 117 2.3.1 Primitive Datentypen im Überblick................................................................. 119 2.3.2 Variablendeklarationen................................................................................... 122 2.3.3 Automatisches Feststellen der Typen mit var................................................. 124 2.3.4 Finale Variablen und der Modifizierer final.................................................... 125 2.3.5 Konsoleneingaben........................................................................................... 126 2.3.6 Fließkommazahlen mit den Datentypen float und double............................ 128 2.3.7 Ganzzahlige Datentypen ................................................................................ 130 2.3.8 Wahrheitswerte.............................................................................................. 132 2.3.9 Unterstriche in Zahlen.................................................................................... 132 2.3.10 Alphanumerische Zeichen............................................................................... 133 2.3.11 Gute Namen, schlechte Namen...................................................................... 134 2.3.12 Keine automatische Initialisierung von lokalen Variablen............................. 135 Ausdrücke, Operanden und Operatoren................................................................... 136 2.4.1 Zuweisungsoperator....................................................................................... 136 2.4.2 Arithmetische Operatoren .............................................................................. 138 2.4.3 Uñares Minus und Plus.................................................................................... 141 2.4.4 Präfix-oder Postfix-Inkrement und-Dekrement............................................ 142 2.4.5 Zuweisung mit Operation (Verbundoperator)............................................... 144 2.4.6 Die relationalen Operatoren und die Gleichheitsoperatoren......................... 145 2.4.7 Logische Operatoren: Nicht, Und, Oder, XOR.................................................. 147 2.4.8 Kurzschluss-Operatoren.................................................................................. 149 2.4.9 Der Rang der Operatoren in der Auswertungsreihenfolge............................. 150 2.4.10 Die Typumwandlung (das Casting)................................................................. 153 2.4.11 Überladenes Plus für Strings........................................................................... 158 2.4.12 Operator vermisst......................................................................................... 160 Bedingte Anweisungen oder Fallunterscheidungen ............................................... 160 2.5.1 Verzweigung mit der if-Anweisung................................................................ 160 2.5.2 Die Alternative mit einer if-else-Anweisung wählen..................................... 163 2.5.3 Der Bedingungsoperator................................................................................. 167 2.5.4 Die switch-Anweisung bietet die Alternative................................................. 170 2.5.5 Switch-Ausdrücke............................................................................................ 176 Immer das Gleiche mit den Schleifen........................................................................ 179 2.6.1 Die while-Schleife............................................................................................ 180 2.6.2 Die do-while-Schleife...................................................................................... 182 2.6.3 Diefor-Schleife................................................................................................ 184 7 Inhalt 2.6.4 Schleifenbedingungen und Vergleiche mit == .............................................. 188 2.6.5 Schleifenabbruch mit break und zurück zum Test mit continue.................... 190 2.6.6 break und continue mit Marken ................................................................... 193 Methoden einer Klasse................................................................................................ 197 2.7.1 Bestandteile einer Methode............................................................................ 198 2.7.2 Signatur-Beschreibung in der Java-API............................................................ 199 2.7.3 Aufruf einer Methode...................................................................................... 200 2.7.4 Methoden ohne Parameter deklarieren.......................................................... 201 2.7.5 Statische Methoden (Klassenmethoden) ........................................................ 202 2.7.6 Parameter, Argument und Wertübergabe...................................................... 203 2.7.7 Methoden vorzeitig mit return beenden......................................................... 205 2.7.8 Nicht erreichbarer Quellcode bei Methoden * ................................................ 206 2.7.9 Methoden mit Rückgaben ............................................................................... 207 2.7.10 Methoden überladen....................................................................................... 212 2.7.11 Gültigkeitsbereich............................................................................................ 214 2.7.12 Vorgegebener Wert für nicht aufgeführte Argumente................................. 215 2.7.13 Rekursive Methoden ...................................................................................... 216 2.7.14 Die Türme von Hanoi ..................................................................................... 221 2.8 Zum Weiterlesen.......................................................................................................... 223 3 Klassen und Objekte 225 3.1 Objektorientierte Programmierung (OOP)................................................................ 225 2.7 3.2 3.3 3.4 3.5 8 3.1.1 Warum überhaupt OOP?................................................................................. 225 3.1.2 Denk ich an Java, denk ich an Wiederverwendbarkeit.................................... 226 Eigenschaften einer Klasse.......................................................................................... 227 3.2.1 Klassenarbeit mit Point.................................................................................... 228 Natürlich modellieren mit der UML (Unified Modeling Language) ...................... 229 3.3.1 Wichtige Diagrammtypen der UML.............................................................. 229 Neue Objekte erzeugen................................................................................................ 231 3.4.1 Ein Exemplar einer Klasse mit dem Schlüsselwort new anlegen ................... 231 3.4.2 Deklarieren von Referenzvariablen.................................................................. 231 3.4.3 Jetzt mach mal’nen Punkt: Zugriff auf Objektvariablen und-methoden ..... 233 3.4.4 Der Zusammenhang von new, Heap und Garbage-Collector......................... 237 3.4.5 Überblick über Point-Methoden ...................................................................... 238 3.4.6 Konstruktoren nutzen...................................................................................... 242 ZZZZZnake..................................................................................................................... 243 Inhalt 3.6 3.7 Pakete schnüren, Importe und Compilationseinheiten.......................................... 245 3.6.1 Java-Pakete...................................................................................................... 246 3.6.2 Pakete der Standardbibliothek ....................................................................... 246 3.6.3 Volle Qualifizierung und import-Deklaration................................................. 246 3.6.4 Mit import pl.p2. alle Typen eines Pakets erreichen.................................... 248 3.6.5 Hierarchische Strukturen über Pakete und die Spiegelung im Dateisystem ... 249 3.6.6 Die package-Deklaration................................................................................. 249 3.6.7 Unbenanntes Paket (default package)............................................................ 251 3.6.8 Compilationseinheit (Compilation Unit)........................................................ 252 3.6.9 Statischer Import .......................................................................................... 252 Mit Referenzen arbeiten, Vielfalt, Identität, Gleichwertigkeit............................... 254 3.7.1 null-Referenz und die Frage der Philosophie.................................................. 254 3.7.2 Alles auf null? Referenzen testen.................................................................... 256 3.7.3 Zuweisungen bei Referenzen.......................................................................... 257 3.7.4 Methoden mit Referenztypen als Parameter.................................................. 259 3.7.5 Identität von Objekten.................................................................................... 263 3.7.6 Gleichwertigkeit und die Methode equals(...)................................................. 263 3.8 Zum Weiterlesen.......................................................................................................... 265 4 Arrays und ihre Anwendungen гы Einfache Feldarbeit...................................................................................................... 267 4.1.1 Grundbestandteile.......................................................................................... 268 4.1.2 Deklaration von Array-Variablen..................................................................... 268 4.1.3 Array-Objekte mit new erzeugen.................................................................... 270 4.1.4 Arrays mit {Inhalt}......................................................................................... 270 4.1.5 Die Länge eines Arrays über die Objektvariablelength auslesen ................... 271 4.1.6 Zugriff auf die Elemente überden Index........................................................ 272 4.1.7 Typische Array-Fehler...................................................................................... 274 4.1 4.1.8 Arrays an Methoden übergeben..................................................................... 275 4.1.9 Mehrere Rückgabewerte ............................................................................... 276 4.1.10 Vorinitialisierte Arrays.................................................................................... 277 4.2 Die erweiterte for-Schleife......................................................................................... 278 4.3 Methode mit variabler Argumentanzahl (Varargs)................................................. 283 4.3.1 System.out.printf(...) nimmt eine beliebige Anzahl von Argumenten an....... 283 4.3.2 Durchschnitt finden von variablen Argumenten............................................ 283 4.3.3 Varargs-Designtipps ..................................................................................... 285 9 Inhalt 4.4 4.5 4.6 4.7 4.8 5 5.1 Mehrdimensionale Arrays ......................................................................................... 285 4.4.1 Nichtrechteckige Arrays ................................................................................. 288 Bibliotheksunterstützung von Arrays........................................................................ 291 4.5.1 Klonen kann sich lohnen-Arrays vermehren................................................. 291 4.5.2 Warum »können« Arrays so wenig?................................................................ 292 4.5.3 Array-Inhalte kopieren ..................................................................................... 292 Die Klasse Arrays zum Vergleichen, Füllen, Suchen und Sortieren nutzen............ 293 4.6.1 Eine lange Schlange ......................................................................................... 307 Der Einstiegspunkt für das Laufzeitsystem: main(...)............................................... 310 310 4.7.1 Korrekte Deklaration der Startmethode......................................................... 4.7.2 Kommandozeilenargumente verarbeiten....................................................... 311 4.7.3 Der Rückgabetyp von main(.„) und System.exit(int) ..................................... 311 Zum Weiterlesen.......................................................................................................... 313 Der Umgang mit Zeichen und Zeichenketten bis Von ASCII über ISO-8859-1 zu Unicode...................................................................... 315 5.1.1 ASCII.................................................................................................................. 315 5.1.2 ISO/IEC 8859-1 ................................................................................................. 316 5.1.3 Unicode............................................................................................................. 317 5.1.4 Unicode-Zeichenkodierung............................................................................. 319 5.1.5 Escape-Sequenzen/Fluchtsymbole.................................................................. 319 5.1.6 Schreibweise für Unicode-Zeichen und Unicode-Escapes.............................. 320 5.1.7 Java-Versionen gehen mit dem Unicode-Standard Hand inHand ................ 322 5.2 Datentypen für Zeichen und Zeichenfolgen.............................................................. 324 5.3 Die Character-Klasse..................................................................................................... 324 5.3.1 Ist das so?.......................................................................................................... 325 5.3.2 Zeichen in Großbuchstaben/Kleinbuchstaben konvertieren.......................... 327 5.3.3 Vom Zeichen zum String.................................................................................. 328 5.3.4 Von char in int: vom Zeichen zur Zahl ........................................................... 328 5.4 Zeichenfolgen............................................................................................................... 330 5.5 Die Klasse String und ihre Methoden ........................................................................ 332 5.5.1 String-Literale als String-Objekte für konstante Zeichenketten..................... 332 5.5.2 Konkatenation mit+........................................................................................ 333 5.5.3 Mehrzeilige Textblöcke mit... .......................................................................... 333 5.5.4 String-Länge und Test auf Leer-String............................................................. 338 5.5.5 Zugriff auf ein bestimmtes Zeichen mit charAt(int)....................................... 339 10 Inhalt 5.5.6 Nach enthaltenen Zeichen und Zeichenfolgen suchen.................................. 540 543 5.5.7 Das Hangman-Spiel........................................................................................ 5.5.8 Gut, dass wir verglichen haben....................................................................... 345 5.5.9 String-Teile extrahieren................................................................................... 349 5.5.10 Strings anhängen, zusammenfügen, Groß-/Kleinschreibung und Weißraum....................................................................................................... 5.6 354 5.5.11 Gesucht, gefunden, ersetzt............................................................................. 357 5.5.12 String-Objekte mit Konstruktoren und aus Wiederholungen erzeugen ...... 359 Veränderbare Zeichenketten mit StringBuilder und StringBuffer......................... 363 5.6.1 Anlegen von StringBuilder-Objekten.............................................................. 364 5.6.2 StringBuilder in andere Zeichenkettenformate konvertieren........................ 365 5.6.3 Zeichen(folgen) erfragen ................................................................................ 365 5.6.4 Daten anhängen.............................................................................................. 365 5.6.5 Zeichen(folgen) setzen, löschen und umdrehen............................................. 367 5.6.6 Länge und Kapazität eines StringBuilder-Objekts ........................................ 370 5.6.7 Vergleich von StrmgBuilder-Exemplaren und Strings mit StringBuilder....... 371 5.6.8 hashCodeO bei StringBuilder ........................................................................ 373 5.7 CharSequence als Basistyp......................................................................................... 373 5.8 Konvertieren zwischen Primitiven und Strings........................................................ 376 5.8.1 Unterschiedliche Typen in String-Repräsentationen konvertieren................ 376 5.8.2 String-Inhalt in einen primitiven Wert konvertieren ..................................... 378 5.8.3 String-Repräsentation im Format Binär, Hex und Oktal .............................. 380 5.8.4 parse(...)- und print()-Methoden in DatatypeConverter ............................ 384 Strings Zusammenhängen (konkatenieren)............................................................. 384 5.9.1 Strings mit StringJoiner Zusammenhängen................................................... 385 Zerlegen von Zeichenketten....................................................................................... 387 5.10.1 Splitten von Zeichenketten mit splitf...).......................................................... 387 5.10.2 Yes we can,yes we scan -die Klasse Scanner................................................ 388 5.9 5.10 5.11 5.12 6 6.1 Ausgaben formatieren................................................................................................ 392 5.11.1 Formatieren und Ausgeben mit formato......................................................... 392 Zum Weiterlesen.......................................................................................................... 398 Eigene Klassen schreiben 399 Eigene Klassen mit Eigenschaften deklarieren......................................................... 399 6.1.1 Objektvariablen deklarieren ........................................................................... 400 6.1.2 Methoden deklarieren.................................................................................... 403 11 Inhalt 6.2 6.3 6.4 6.5 6.6 6.7 12 6.1.3 Verdeckte (shadowed) Variablen..................................................................... 406 6.1.4 Diethis-Referenz.............................................................................................. 407 Privatsphäre und Sichtbarkeit..................................................................................... 411 6.2.1 Für die Öffentlichkeit: public ........................................................................... 411 6.2.2 Kein Public Viewing-Passwörter sind privat................................................. 411 6.2.3 Wieso nicht freie Methoden und Variablen für alle?...................................... 413 6.2.4 Privat ist nicht ganz privat: Es kommt darauf an, wer’s sieht ...................... 413 6.2.5 Zugriffsmethoden für Objektvariablen deklarieren........................................ 414 415 6.2.6 Setter und Getter nach der JavaBeans-Spezifikation ..................................... 6.2.7 Paketsichtbar.................................................................................................... 417 6.2.8 Zusammenfassung zur Sichtbarkeit................................................................ 419 Eine für alle-statische Methodenund Klassenvariablen........................................ 421 6.3.1 Warum statische Eigenschaften sinnvoll sind................................................ 422 6.3.2 Statische Eigenschaften mit static................................................................... 423 6.3.3 Statische Eigenschaften über Referenzen nutzen? ...................................... 424 6.3.4 Warum die Groß-und Kleinschreibung wichtig ist ...................................... 425 6.3.5 Statische Variablen zum Datenaustausch .................................................... 426 6.3.6 Statische Eigenschaften und Objekteigenschaften ...................................... 427 Konstanten und Aufzählungen................................................................................... 428 6.4.1 Konstanten über statische finale Variablen .................................................... 428 6.4.2 Typunsichere Aufzählungen ............................................................................ 429 6.4.3 Aufzählungstypen: typsichere Aufzählungen mit enum................................ 431 Objekte anlegen und zerstören.................................................................................. 436 6.5.1 Konstruktoren schreiben................................................................................. 436 6.5.2 Verwandtschaft von Methode und Konstruktor............................................. 438 439 6.5.3 Der Standard-Konstruktor (default constructor)............................................ 6.5.4 Parametrisierte und überladene Konstruktoren............................................. 440 6.5.5 Copy-Konstruktor............................................................................................. 443 6.5.6 Einen anderen Konstruktor der gleichen Klasse mit this(...) aufrufen............ 444 6.5.7 Immutable-Objekte und Wither- Methoden.................................................... 447 6.5.8 Ihr fehlt uns nicht-der Garbage-Collector.................................................... 449 Klassen- und Objektinitialisierung............................................................................ 451 6.6.1 Initialisierung von Objektvariablen ................................................................. 451 6.6.2 Statische Blöcke als Klasseninitialisierer......................................................... 453 6.6.3 Initialisierung von Klassenvariablen................................................................ 453 6.6.4 Eincompilierte Belegungen der Klassenvariablen ........................................... 454 6.6.5 Exemplarinitialisierer (Instanzinitialisierer) .................................................... 455 6.6.6 Finale Werte im Konstruktor und in statischen Blöcken setzen..................... 458 Zum Weiterlesen.......................................................................................................... 460 Inhalt 7 Objektorientierte Beziehungsfragen 46i 7.1 Assoziationen zwischen Objekten............................................................................. 461 7.1.1 Unidirektionale l:l-Beziehung....................................................................... 462 7.1.2 Zwei Freunde müsst ihr werden-bidirektionale l:l-Beziehungen.............. 463 7.1.3 Unidirektionale l:n-Beziehung....................................................................... 465 Vererbung..................................................................................................................... 471 7.2.1 Vererbung in Java ............................................................................................ 472 7.2 7.3 7.4 7.5 7.6 7.7 7.8 7.2.2 Ereignisse modellieren.................................................................................... 472 7.2.3 Die implizite Basisklasse java.lang.Object ...................................................... 474 7.2.4 Einfach- und Mehrfachvererbung ................................................................. 475 7.2.5 Sehen Kinder alles? Die Sichtbarkeit protected ............................................. 475 7.2.6 Konstruktoren in der Vererbung und super(...)............................................... 476 Typen in Hierarchien................................................................................................... 481 7.3.1 Automatische und explizite Typumwandlung............................................... 481 7.3.2 Das Substitutionsprinzip................................................................................. 485 7.3.3 Typen mit dem instanceof-Operator testen................................................... 487 7.3.4 Pattern-Matching bei instanceof.................................................................... 489 Methoden überschreiben............................................................................................ 491 7.4.1 Methoden in Unterklassen mit neuem Verhalten ausstatten....................... 492 7.4.2 Mit super an die Eltern.................................................................................... 496 Drum prüfe, wer sich dynamisch bindet................................................................... 498 7.5.1 Gebunden an toStringO................................................................................... 498 7.5.2 Implementierung von System.out.println(Object)......................................... 500 Finale Klassen und finale Methoden.......................................................................... 501 7.6.1 Finale Klassen.................................................................................................. 501 7.6.2 Nicht überschreibbare (finale) Methoden....................................................... 501 Abstrakte Klassen und abstrakte Methoden............................................................ 503 7.7.1 Abstrakte Klassen............................................................................................ 503 7.7.2 Abstrakte Methoden ....................................................................................... 505 Weiteres zum Überschreiben und dynamischen Binden......................................... 511 7.8.1 7.9 Nicht dynamisch gebunden bei privaten, statischen und finalen Methoden........................................................................................................ 511 7.8.2 Kovariante Rückgabetypen ............................................................................. 512 7.8.3 Array-Typen und Kovarianz .......................................................................... 513 7.8.4 Dynamisch gebunden auch bei Konstruktoraufrufen .................................. 514 7.8.5 Keine dynamische Bindung bei überdeckten Objektvariablen .................... 516 Zum Weiterlesen und Programmieraufgabe............................................................ 517 13 Inhalt 8 8.1 8.2 8.3 8.4 8.5 14 Schnittstellen, Aufzählungen, versiegelte Klassen, ReCOrds 519 Schnittstellen................................................................................................................ 519 8.1.1 519 Schnittstellen sind neue Typen........................................................................ 8.1.2 Schnittstellen deklarieren................................................................................ 520 8.1.3 Abstrakte Methoden in Schnittstellen............................................................. 520 8.1.4 Implementieren von Schnittstellen................................................................. 521 8.1.5 Ein Polymorphie-Beispiel mit Schnittstellen ................................................... 523 8.1.6 Die Mehrfachvererbung bei Schnittstellen..................................................... 525 8.1.7 Keine Kollisionsgefahr bei Mehrfachvererbung ........................................... 528 8.1.8 Erweitern von Interfaces - Subinterfaces........................................................ 529 8.1.9 Konstantendeklarationen bei Schnittstellen................................................... 530 8.1.10 Nachträgliches Implementieren von Schnittstellen ...................................... 531 8.1.11 Statische ausprogrammierte Methoden in Schnittstellen............................. 531 8.1.12 Erweitern und Ändern von Schnittstellen ....................................................... 533 8.1.13 Default- Methoden........................................................................................... 535 8.1.14 Erweiterte Schnittstellen deklarieren und nutzen.......................................... 536 8.1.15 Öffentliche und private Schnittstellenmethoden .......................................... 540 8.1.16 Erweiterte Schnittstellen, Mehrfachvererbung und Mehrdeutigkeiten ....... 540 8.1.17 Bausteine bilden mit Default-Methoden ...................................................... 545 8.1.18 Markierungsschnittstellen............................................................................ 550 8.1.19 (Abstrakte) Klassen und Schnittstellen im Vergleich...................................... 551 Aufzählungstypen ........................................................................................................ 552 8.2.1 Methoden auf Enum-Objekten........................................................................ 552 8.2.2 Aufzählungen mit eigenen Methoden und Initialisierern ............................ 556 8.2.3 enum mit eigenen Konstruktoren ................................................................. 558 Versiegelte Klassen und Schnittstellen...................................................................... 562 8.3.1 Versiegelte Klassen und Schnittstellen (sealedclasses/interfaces)................ 564 8.3.2 Unterklassen sind final, sealed, non-sealed.................................................... 566 8.3.3 Abkürzende Schreibweisen.............................................................................. 566 Records........................................................................................................................... 567 8.4.1 568 Einfache Records .............................................................................................. 8.4.2 Records mit Methoden..................................................................................... 569 8.4.3 Konstruktoren von Records anpassen.............................................................. 571 8.4.4 Konstruktoren ergänzen.................................................................................. 573 8.4.5 Versiegelte Schnittstellen und Records........................................................... 574 8.4.6 Zusammenfassung........................................................................................... 575 Zum Weiterlesen.......................................................................................................... 576 Inhalt 9 Ausnahmen müssen sein 577 9.1 Problembereiche einzäunen....................................................................................... 578 9.2 9.3 9.1.1 Exceptions in Java mit try und catch............................................................... 578 9.1.2 Geprüfte und ungeprüfte Ausnahmen........................................................... 579 9.1.3 Eine NumberFormatException fliegt (ungeprüfte Ausnahme) ..................... 579 9.1.4 UUID in Textdatei anhängen (geprüfte Ausnahme) ...................................... 581 9.1.5 Wiederholung abgebrochener Bereiche * ....................................................... 584 9.1.6 Bitte nicht schlucken - leere catch-Blöcke...................................................... 584 9.1.7 Mehrere Ausnahmen auffangen..................................................................... 585 9.1.8 Zusammenfassen gleicher catch-Blöcke mit dem multi-catch ...................... 586 Ausnahmen weiterleiten, throws am Kopf von Methoden/Konstruktoren......... 587 9.2.1 throws bei Konstruktoren und Methoden...................................................... 587 Die Klassenhierarchie der Ausnahmen..................................................................... 588 9.3.1 Eigenschaften des Exception-Objekts............................................................ 588 9.3.2 Basistyp Throwable......................................................................................... 589 9.3.3 Die Exception-Hierarchie....................................................................... 590 9.3.4 Oberausnahmen auffangen ........................................................................... 591 9.3.5 Schon gefangen?............................................................................................. 593 9.3.6 Ablauf einer Ausnahmesituation.................................................................... 594 9.3.7 Nicht zu allgemein fangen!............................................................................. 594 9.3.8 Bekannte RuntimeException-Klassen ............................................................ 596 9.3.9 Kann man abfangen, muss man aber nicht................................................... 597 9.4 Abschlussbehandlung mit finally............................................................................... 597 9.5 Auslösen eigener Exceptions...................................................................................... 603 603 9.5.1 Mit throw Ausnahmen auslösen..................................................................... 9.5.2 Vorhandene Runtime-Ausnahmetypen kennen und nutzen......................... 605 9.5.3 Parameter testen und gute Fehlermeldungen............................................... 608 9.5.4 Neue Exception-Klassen deklarieren .............................................................. 609 9.5.5 Eigene Ausnahmen als Unterklassen von Exception oder RuntimeException?......................................................................................... 9.6 611 9.5.6 Ausnahmen abfangen und weiterleiten ....................................................... 614 9.5.7 Aufruf-Stack von Ausnahmen verändern ..................................................... 615 9.5.8 Präzises rethrow ............................................................................................ 616 9.5.9 Geschachtelte Ausnahmen .......................................................................... 619 try mit Ressourcen (automatisches Ressourcen-Management)............................. 623 9.6.1 try mit Ressourcen........................................................................................... 623 9.6.2 Die Schnittstelle AutoCloseable...................................................................... 624 9.6.3 Ausnahmen vom closeQ.................................................................................. 625 15 Inhalt 9.6.4 Typen, die AutoCloseable und Closeable sind................................................. 626 9.6.5 Mehrere Ressourcen nutzen............................................................................. 628 9.6.6 try mit Ressourcen auf null-Ressourcen.......................................................... 629 9.6.7 Unterdrückte Ausnahmen ............................................................................. 629 Besonderheiten bei der Ausnahmebehandlung .................................................... 633 9.7.1 Rückgabewerte bei ausgelösten Ausnahmen................................................. 633 9.7.2 Ausnahmen und Rückgaben verschwinden - das Duo return und finally..... 633 9.7.3 throws bei überschriebenen Methoden.......................................................... 634 9.7.4 Nicht erreichbare catch-Klauseln .................................................................... 637 9.8 Harte Fehler-Error.................................................................................................... 638 9.9 Assertions................................................................................................................... 639 9.9.1 639 9.7 9.10 Assertions in eigenen Programmen nutzen.................................................... 9.9.2 Assertions aktivieren und Laufzeit-Errors........................................................ 639 9.9.3 Assertions feiner aktivieren oder deaktivieren................................................ 641 Zum Weiterlesen.......................................................................................................... 642 10 Geschachtelte Typen 643 10.1 Geschachtelte Klassen, SchnittsteNen und Aufzählungen...................................... 643 10.2 Statische geschachtelte Typen.................................................................................... 645 10.3 Nichtstatische geschachtelte Typen........................................................................... 647 10.3.1 647 10.4 10.5 Exemplare innerer Klassen erzeugen.............................................................. 10.3.2 Diethis-Referenz.............................................................................................. 648 10.3.3 Vom Compiler generierte Klassendateien .................................................... 649 10.3.4 Erlaubte Modifizierer bei äußeren und inneren Klassen................................ 650 Lokale Klassen ............................................................................................................... 650 10.4.1 Beispiel mit eigener Klassendeklaration......................................................... 650 10.4.2 Lokale Klasse für einen Timer nutzen .............................................................. 651 Anonyme innere Klassen............................................................................................. 652 10.5.1 Nutzung einer anonymen inneren Klasse für den Timer................................ 653 10.5.2 Umsetzung innerer anonymer Klassen ........................................................ 654 10.5.3 Konstruktoren innerer anonymer Klassen ...................................................... 654 10.6 Zugriff auf lokale Variablen aus lokalen und anonymen Klassen ....................... 657 10.7 this in Unterklassen ................................................................................................... 658 10.7.1 659 16 Geschachtelte Klassen greifen auf private Eigenschaften zu......................... Inhalt 10.8 Nester............................................................................................................................ 660 10.9 Zum Weiterlesen.......................................................................................................... 662 11 11.1 11.2 11.3 11.4 11.5 Besondere Typen der Java SE ббз Object ist die Mutter aller Klassen............................................................................. 664 11.1.1 Klassenobjekte................................................................................................. 664 11.1.2 Objektidentifikation mit toStringO................................................................. 665 11.1.3 Objektgleichwertigkeit mit equals(...) und Identität...................................... 667 11.1.4 Klonen eines Objekts mit clonej) .................................................................. 673 11.1.5 Hashwerte über hashCodej) liefern .............................................................. 678 11.1.6 System.identityHashCodej...) und das Problem der nicht eindeutigen Objektverweise .............................................................................................. 685 11.1.7 Aufräumen mit fmalizej) ............................................................................... 686 11.1.8 Synchronisation ............................................................................................. 688 Schwache Referenzen und Cleaner........................................................................... 688 Die Utility-Klasse java.util.Objects............................................................................ 690 11.3.1 Eingebaute null-Tests für equals(...)/hashCode() ........................................... 690 11.3.2 Objects.toStringj...).......................................................................................... 691 11.3.3 null-Prüfungen mit eingebauter Ausnahmebehandlung............................... 691 11.3.4 Tests auf null................................................................................................... 692 11.3.5 Indexbezogene Programmargumente auf Korrektheit prüfen...................... 693 Vergleichen von Objekten und Ordnung herstellen................................................ 694 11.4.1 Natürlich geordnet oder nicht?....................................................................... 694 11.4.2 compare()-Methode der Schnittstellen Comparable undComparator......... 695 11.4.3 Rückgabewerte kodieren die Ordnung............................................................ 696 11.4.4 Beispiel-Comparator: den kleinsten Raum einer Sammlung finden............. 696 11.4.5 Tipps für Comparator- und Comparable-Implementierungen...................... 698 11.4.6 Statische und Default-Methoden in Comparator.......................................... 699 Wrapper-Klassen und Autoboxing............................................................................ 703 704 11.5.1 Wrapper-Objekte erzeugen............................................................................. 11.5.2 Konvertierungen in eine String- Repräsentation............................................. 706 11.5.3 Von einer String-Repräsentation parsen........................................................ 707 11.5.4 Die Basisklasse Number für numerische Wrapper-Objekte........................... 707 11.5.5 Vergleiche durchführen mit compare(...), compareToj...), equalsj...) und Hashwerten.............................................................................................. 709 11.5.6 Statische Reduzierungsmethoden in Wrapper-Klassen................................. 712 11.5.7 Konstanten für die Größe eines primitiven Typs............................................ 713 17 Inhalt 11.6 11.7 11.5.8 Behandeln von vorzeichenlosen Zahlen ........................................................ 714 11.5.9 Die Klasse Integer............................................................................................. 715 11.5.10 Die Klassen Double und Float für Fließkommazahlen .................................... 716 11.5.11 Die Long-Klasse................................................................................................ 717 11.5.12 Die Boolean-Klasse........................................................................................... 717 11.5.13 Autoboxing: Boxing undUnboxing.................................................................. 718 Iterator, Iterable ......................................................................................................... 723 11.6.1 Die Schnittstelle Iterator................................................................................. 723 11.6.2 Wer den Iterator liefert.................................................................................... 726 11.6.3 Die Schnittstelle Iterable.................................................................................. 727 11.6.4 Erweitertes for und Iterable ............................................................................ 727 11.6.5 Interne Iteration ............................................................................................... 728 11.6.6 Ein eigenes Iterable implementieren ............................................................. 729 Annotationen in der Java SE........................................................................................ 730 11.7.1 Orte für Annotationen...................................................................................... 730 11.7.2 Annotationstypen aus java.lang...................................................................... 731 11.7.3 @ Deprecated.................................................................................................... 732 11.7.4 Annotationen mit zusätzlichen Informationen............................................... 732 11.7.5 @SuppressWarnings....................................................................................... 733 11.8 Zum Weiterlesen.......................................................................................................... 736 12 GenerÍCS T 737 12.1 Einführung in Java Generics........................................................................................ 737 12.1.1 Mensch versus Maschine-Typprüfung des Compilers und der Laufzeitumgebung........................................................................................... 12.2 18 737 12.1.2 Raketen............................................................................................................. 738 12.1.3 GenerischeTypendeklarieren......................................................................... 740 12.1.4 Generics nutzen................................................................................................ 742 12.1.5 Diamonds are forever...................................................................................... 744 12.1.6 Generische Schnittstellen ................................................................................ 747 12.1.7 Generische Methoden/Konstruktoren und Typ-Inferenz................................ 749 Umsetzen der Generics, Typlöschung und Raw-Types............................................. 753 12.2.1 Realisierungsmöglichkeiten............................................................................. 753 12.2.2 Typlöschung (Type Erasure)............................................................................. 753 12.2.3 Probleme der Typlöschung.............................................................................. 755 12.2.4 Raw-Type .......................................................................................................... 760 Inhalt 12.3 12.4 Die Typen über Bounds einschränken....................................................................... 762 12.3.1 Einfache Einschränkungen mit extends......................................................... 762 12.3.2 Weitere Obertypen mit ................................................................................ 765 Typparameter in der throws-Klausel ......................................... 765 12.4.1 Deklaration einer Klasse mit Typvariable E extendsException»................... 765 12.4.2 Parametrisierter Typ bei Typvariable E extends Exception)........................ 766 Generics und Vererbung, Invarianz........................................................................... 769 12.5.1 Arrays sind kovariant....................................................................................... 769 12.5.2 Generics sind nicht kovariant, sondern invariant........................................... 769 12.5.3 Wildcards mit ?................................................................................................ 770 12.5.4 Bounded Wildcards......................................................................................... 773 12.5.5 Bounded-Wildcard-Typen und Bounded-Typvariablen.................................. 776 12.5.6 Das LESS-Prinzip.............................................................................................. 778 12.5.7 Enum E extends Enum E ......................................................................... 781 Konsequenzen der Typlöschung: Typ-Token, Arrays und Brücken ..................... 783 12.6.1 Typ-Token........................................................................................................ 783 12.6.2 Super-Type-Token............................................................................................ 784 12.6.3 Generics und Arrays......................................................................................... 786 12.6.4 Brückenmethoden........................................................................................... 787 12.7 Zum Weiterlesen.......................................................................................................... 792 13 Lambda-Ausdrücke und funktionale Programmierung 793 Funktionale Schnittstellen und Lambda-Ausdrücke................................................ 793 13.1.1 Klassen implementieren Schnittstellen.......................................................... 793 13.1.2 Lambda-Ausdrücke implementieren Schnittstellen....................................... 795 13.1.3 Funktionale Schnittstellen .............................................................................. 796 13.1.4 Der Typ eines Lambda-Ausdrucks ergibt sich durch den Zieltyp.................... 797 13.1.5 Annotation @Functionallnterface ................................................................. 802 13.1.6 Syntax für Lambda-Ausdrücke........................................................................ 803 13.1.7 Die Umgebung der Lambda-Ausdrücke und Variablenzugriffe..................... 808 13.1.8 Ausnahmen in Lambda-Ausdrücken............................................................... 814 13.1.9 Klassen mit einer abstrakten Methode als funktionale Schnittstelle? ........ 817 Methodenreferenz....................................................................................................... 819 13.2.1 Motivation ....................................................................................................... 819 13.2.2 Methodenreferenzen mit ::............................................................................. 819 13.2.3 Varianten von Methodenreferenzen.............................................................. 820 12.5 12.6 13.1 13.2 19 Inhalt 13.3 13.4 13.5 13.6 Konstruktorreferenz..................................................................................................... 823 13.3.1 Parameterlose und parametrisierte Konstruktoren........................................ 825 13.3.2 Nützliche vordefinierte Schnittstellen für Konstruktorreferenzen................. 825 Funktionale Programmierung..................................................................................... 827 13.4.1 Code = Daten .................................................................................................... 827 13.4.2 Programmierparadigmen: imperativ oder deklarativ..................................... 828 13.4.3 Das Wesen der funktionalen Programmierung............................................... 829 13.4.4 Funktionale Programmierung und funktionale Programmiersprachen........ 831 13.4.5 Funktionen höherer Ordnung am Beispiel von Comparator........................... 834 13.4.6 Lambda-Ausdrücke als Abbildungen bzw. Funktionen betrachten................ 834 Funktionale Schnittstellen aus dem java.util.function-Paket................................ 835 13.5.1 Blöcke mit Code und die funktionale Schnittstelle Consumer....................... 836 13.5.2 Supplier............................................................................................................. 838 13.5.3 Prädikate und java.util.function.Predicate...................................................... 838 13.5.4 Funktionen über die funktionale Schnittstelle java.util.function.Function... 840 13.5.5 Ein bisschen Bi.................................................................................................. 844 13.5.6 Funktionale Schnittstellen mit Primitiven ...................................................... 847 Optional ist keine Nullnummer.................................................................................. 850 13.6.1 Einsatz von null................................................................................................ 850 13.6.2 DerOptional-Typ.............................................................................................. 853 13.6.3 Erst mal funktional mit Optional..................................................................... 855 13.6.4 Primitiv-Optionales mit speziellen Optionaľ-Klassen.................................... 858 13.7 Was ist jetzt so funktional?......................................................................................... 861 13.8 Zum Weiterlesen.......................................................................................................... 863 14 Architektur, Design und angewandte Objektorientierung 865 SOLIDe Modellierung.................................................................................................... 865 14.1.1 DRY. KISS und YAG NI........................................................................................ 866 14.1.2 SOLID................................................................................................................ 866 14.1.3 Sei nicht STUPID ............................................................................................... 868 14.2 Architektur, Design und Implementierung............................................................... 869 14.3 Design-Patterns (Entwurfsmuster)............................................................................. 870 14.1 20 14.3.1 Motivation für Design-Patterns....................................................................... 870 14.3.2 Singleton.......................................................................................................... 871 Inhalt 14.3.3 Fabrikmethoden.............................................................................................. 872 14.3.4 Das Beobachter-Pattern mit Listener realisieren............................................ 873 14.4 Zum Weiterlesen........................................................................................................... 877 15 Java Platform Module System 879 15.1 879 15.2 15.3 16 16.1 Klassenlader (Class Loader) und Modul-/Klassenpfad............................................ 15.1.1 Klassenladen auf Abruf................................................................................... 879 15.1.2 Klassenlader bei der Arbeit Zusehen............................................................... 880 15.1.3 JMOD-Dateien und JAR-Dateien..................................................................... 881 15.1.4 Woher die Klassen kommen: Suchorte und spezielle Klassenlader............... 882 15.1.5 Setzen des Modulpfades................................................................................. 883 Module entwickeln und elnblnden............................................................................ 885 15.2.1 Wer sieht wen?................................................................................................ 885 15.2.2 Plattform-Module und ein JMOD-Beispiel...................................................... 886 15.2.3 Interne Plattformeigenschaften nutzen, -add-exports................................. 887 15.2.4 Neue Module einbinden,-add-modules und-add-opens............................ 889 15.2.5 Projektabhängigkeiten in Eclipse.................................................................... 891 15.2.6 Benannte Module und module-info.java....................................................... 893 15.2.7 Automatische Module .................................................................................... 897 15.2.8 Unbenanntes Modul........................................................................................ 898 15.2.9 Lesbarkeit und Zugreifbarkeit......................................................................... 898 15.2.10 Modul-Migration............................................................................................. 899 Zum Welterlesen.......................................................................................................... 901 Die Klassenbibliothek Die Java-Klassenphilosophie...................................................................................... 903 903 16.1.1 Modul, Paket, Typ............................................................................................ 903 16.1.2 Übersicht über die Pakete der Standardbibliothek........................................ 906 16.2 Einfache Zeitmessung und Profiling ....................................................................... 910 16.3 Die Klasse Class............................................................................................................ 913 16.3.1 An ein Class-Objekt kommen.......................................................................... 914 16.3.2 Eine Class ist ein Type ..................................................................................... 916 Klassenlader................................................................................................................. 917 16.4.1 918 16.4 Die Klasse java.lang.ClassLoader..................................................................... 21 Inhalt 16.5 16.6 16.7 16.8 16.9 Die Utility-Klassen System und Properties................................................................ 918 16.5.1 Speicher der JVM.............................................................................................. 919 16.5.2 Anzahl der CPUs bzw. Kerne............................................................................. 920 16.5.3 Systemeigenschaften der Java-Umgebung..................................................... 921 16.5.4 Eigene Properties von der Konsole aus setzen .............................................. 922 16.5.5 Zeilenumbruchzeichen, line.separator............................................................ 925 16.5.6 Umgebungsvariablen des Betriebssystems..................................................... 925 Sprachen der Länder..................................................................................................... 927 16.6.1 Sprachen in Regionen über Locale-Objekte..................................................... 927 Wichtige Datum-Klassen im Überblick...................................................................... 931 932 16.7.1 Der 1.1.1970 ..................................................................................................... 16.7.2 System.currentTimeMillisO............................................................................. 932 16.7.3 Einfache Zeitumrechnungen durch TimeUnit................................................ 933 Date-Time-API ............................................................................................................... 934 16.8.1 Menschenzeit und Maschinenzeit................................................................... 935 16.8.2 Die Datumsklasse LocalDate............................................................................ 938 Loggingmit Java............................................................................................................ 939 16.9.1 Logging-APIs ..................................................................................................... 939 16.9.2 Logging mit java.util.logging............................................................................ 940 16.10 Maven: Build-Management und Abhängigkeiten auflosen.................................... 942 16.10.1 Beispielprojekt in Eclipse mit Maven............................................................... 943 16.10.2 Properties hinzunehmen.................................................................................. 943 16.10.3 Dependency hinzunehmen ............................................................................. 944 16.10.4 Lokales und das Remote-Repository................................................................ 945 16.10.5 Lebenszylus, Phasen und Maven-Plugins........................................................ 946 16.10.6 Archetypes........................................................................................................ 946 16.11 Zum Weiterlesen.......................................................................................................... 946 17 Einführung in die nebenläufige Programmierung 949 17.1 17.2 22 Neben laufigkeit und Parallelität................................................................................ 949 17.1.1 Multitasking, Prozesse und Threads................................................................ 950 17.1.2 Threads und Prozesse....................................................................................... 950 17.1.3 Wie nebenläufige Programme die Geschwindigkeit steigern können........... 952 17.1.4 Was Java für Nebenläufigkeit alles bietet....................................................... 953 Existierende Threads und neue Threads erzeugen................................................... 954 17.2.1 Main-Thread ...................................................................................................... 954 Inhalt 17.2.2 17.3 17.4 Wer bin ich?..................................................................................................... 954 17.2.3 Die Schnittstelle Runnable implementieren.................................................. 955 17.2.4 Thread mit Runnable starten .......................................................................... 956 17.2.5 Runnable parametrisieren............................................................................... 958 17.2.6 Die Klasse Thread erweitern........................................................................... 958 Thread-Eigenschaften und Zustände......................................................................... 961 17.3.1 Der Name eines Threads................................................................................. 961 17.3.2 Die Zustände eines Threads .......................................................................... 962 17.3.3 Schläfer gesucht.............................................................................................. 962 17.3.4 Wann Threads fertig sind ............................................................................... 964 17.3.5 Einen Thread höflich mit Interrupt beenden .................................................. 964 17.3.6 Unbehandelte Ausnahmen, Thread-Ende und 18 967 17.3.7 Der stopO von außen und die Rettung mit ThreadDeath ............................ 968 17.3.8 Ein Rendezvous mit join(...) ........................................................................... 970 17.3.9 Arbeit niederlegen und wieder aufnehmen ................................................. 972 17.3.10 Priorität .......................................................................................................... 972 Der Ausführer (Executor) kommt............................................................................... 974 17.4.1 Die Schnittstelle Executor............................................................................... 974 17.4.2 Glücklich in der Gruppe - die Thread-Pools.................................................... 976 17.4.3 Threads mit Rückgabe über Callable............................................................... 978 17.4.4 Erinnerungen an die Zukunft - die Future-Rückgabe.................................... 980 17.4.5 Mehrere Callable-Objekte abarbeiten............................................................ 983 17.4.6 CompletionService und ExecutorCompletionService..................................... 984 17.4.7 ScheduledExecutorService: wiederholende Aufgaben und Zeitsteuerungen.............................................................................................. 986 Asynchrones Programmieren mit CompletableFuture (CompletionStage) .... 986 Zum Weiterlesen.......................................................................................................... 989 17.4.8 17.5 UncaughtExceptionHandler........................................................................... Einführung in Datenstrukturenund Algorithmen 991 18.1 Listen ............................................................................................................................. 991 18.1.1 Erstes Listen-Beispiel....................................................................................... 992 18.1.2 Auswahlkriterium ArrayList oder LinkedList................................................... 993 18.1.3 Die Schnittstelle List........................................................................................ 993 18.1.4 ArrayList........................................................................................................... 1000 18.1.5 Linkedüst......................................................................................................... 1002 18.1.6 Der Array-Adapter Arrays.asüst(...)................................................................. 1003 18.1.7 Listlterator ..................................................................................................... 1005 23 Inhalt 18.2 18.3 18.4 18.1.8 toArrayC·.) von Collection verstehen -die Gefahr einer Falle erkennen........ 18.1.9 Primitive Elemente in Datenstrukturen verwalten......................................... 1010 Mengen (Sets)............................................................................................................... Ein erstes Mengen-Beispiel.............................................................................. 1011 18.2.2 Methoden der Schnittstelle Set ....................................................................... 1013 18.2.3 HashSet............................................................................................................ 1015 18.2.4 TreeSet-die sortierte Menge.......................................................................... 1015 18.2.5 Die Schnittstellen NavigableSet und SortedSet.............................................. 1017 18.2.6 LinkedHashSet.................................................................................................. 1019 Assoziative Speicher.................................................................................................... 1021 18.3.1 Die Klassen HashMap und TreeMap ............................................................... 1021 18.3.2 Einfügen und Abfragen des Assoziativspeichers............................................. 1024 Java-Stream-API............................................................................................................ 1026 Deklaratives Programmieren........................................................................... 1026 18.4.2 Interne versus externe Iteration ..................... 18.4.3 Was ist ein Stream?.......................................................................................... 1028 Einen Stream erzeugen................................................................................................ 18.5.1 18.6 18.8 24 1027 1029 Parallele oder sequenzielle Streams................................................................ 1032 Terminale Operationen................................................................................................ 1033 18.6.1 Die Anzahl der Elemente.................................................................................. 1033 18.6.2 Und jetzt alle-forEach(...) ............................................................................. 18.6.3 Einzelne Elemente aus dem Strom holen........................................................ 1034 18.6.4 Existenztests mit Prädikaten ........................................................................... 1035 1034 18.6.5 Einen Strom auf sein kleinstes bzw. größtes Element reduzieren................. 1036 18.6.6 Einen Strom mit eigenen Funktionen reduzieren........................................... 1037 18.6.7 Ergebnisse in einen Container schreiben, Teil 1: collect(...)............................. 1038 18.6.8 Ergebnisse in einen Container schreiben, Teil 2: Collector und Collectors...... 1039 18.6.9 Ergebnisse in einen Container schreiben, Teil 3: Gruppierungen ................... 1041 18.6.10 Stream-Elemente inein Array oder einen Iterator übertragen....................... 18.7 1010 18.2.1 18.4.1 18.5 1006 1043 Intermediäre Operationen........................................................................................... 1044 18.7.1 Element-Vorschau ........................................................................................... 1045 18.7.2 Filtern von Elementen ..................................................................................... 1045 18.7.3 Statusbehaftete intermediäre Operationen.................................................... 1045 18.7.4 Präfix-Operation............................................................................................... 1047 18.7.5 Abbildungen ..................................................................................................... 1048 Zum Weiterlesen.......................................................................................................... 1050 Inhalt 19 Einführung in grafische Oberflächen iosi 19.1 GUI-Frameworks.......................................................................................................... 1051 19.1.1 Kommandozeile.............................................................................................. 1051 19.1.2 Grafische Benutzeroberfläche......................................................................... 1051 19.1.3 Abstract Window Toolkit (AWT)...................................................................... 1052 19.1.4 Java Foundation Classes und Swing................................................................ 1052 19.1.5 JavaFX.............................................................................................................. 19.1.6 SWT (Sta nda rd Widget Tool kit) ..................................................................... 1054 19.2 19.3 19.4 19.5 1052 Deklarative und programmierte Oberflächen.......................................................... 1055 19.2.1 GUI-Beschreibungen in JavaFX....................................................................... 1055 19.2.2 Deklarative GUI-Beschreibungen für Swing?.................................................. 1056 GUI-Builder................................................................................................................... 1056 19.3.1 GUI-Builderfür JavaFX.................................................................................... 1057 19.3.2 GUI-Builder für Swing..................................................................................... 1057 Mit dem Eclipse WindowBuilder zur ersten Swing-Oberfläche.............................. 1057 19.4.1 WindowBuilder installieren ............................................................................ 1058 19.4.2 Mit WindowBuilder eine GUI-Klasse hinzufügen........................................... 1059 19.4.3 Das Layoutprogramm starten......................................................................... 1061 19.4.4 Grafische Oberfläche aufbauen...................................................................... 1062 19.4.5 Swing-Komponenten-Klassen......................................................................... 1065 19.4.6 Funktionalität geben....................................................................................... 1066 Grundlegendes zum Zeichnen.................................................................................... 1069 19.5.1 Die paint(Graphics)-Methodefürden AWT-Frame........................................ 1069 19.5.2 Die ereignisorientierte Programmierung ändert Fensterinhalte................... 1071 19.5.3 Zeichnen von Inhalten auf einen JFrame....................................................... 1072 19.5.4 Auffordern zum Neuzeichnen mit repaint(...)................................................. 1074 19.5.5 Java 2D-API ...................................................................................................... 1074 19.6 Zum Weiterlesen.......................................................................................................... 1075 20 Einführung in Dateien und Datenströme 1077 20.1 Alte und neue Welt in java.io und java.nio............................................................... 1077 20.1.1 java.io-Paket mit File-Klasse........................................................................... 1077 20.1.2 N10.2 und das java.nio-Paket.......................................................................... 1078 20.1.3 java.io.Flle oder java.nio.-Typen?................................................................... 1078 25 Inhalt 20.2 20.3 20.4 20.5 20.6 21 21.1 21.2 21.3 26 Dateisysteme und Pfade.............................................................................................. 1079 20.2.1 FileSystem und Path......................................................................................... 1079 20.2.2 Die Utility-Klasse Files...................................................................................... 1085 Dateien mit wahlfreiem Zugriff.................................................................................. 1088 20.3.1 Ein RandomAccessFile zum Lesen und Schreiben öffnen................................ 1088 20.3.2 Aus dem RandomAccessFile lesen................................................................... 1089 20.3.3 Schreiben mit RandomAccessFile.................................................................... 1092 20.3.4 Die Länge des RandomAccessFile.................................................................... 1092 20.3.5 Hin und her in der Datei .................................................................................. 1093 Basisklassen für die Ein-/Ausgabe............................................................................. 1094 20.4.1 Die vier abstrakten Basisklassen...................................................................... 1094 20.4.2 Die abstrakte Basisklasse OutputStream ........................................................ 1095 20.4.3 Die abstrakte Basisklasse InputStream........................................................... 1097 20.4.4 Die abstrakte Basisklasse Writer...................................................................... 1099 20.4.5 Die Schnittstelle Appendable ........................................................................ 20.4.6 Die abstrakte Basisklasse Reader..................................................................... 1101 20.4.7 Die Schnittstellen Closeable, AutoCloseable und Flushable........................... 1104 1100 Lesen aus Dateien und Schreiben in Dateien ............................................................ 1106 20.5.1 Byteorientierte Datenströme über Files beziehen.......................................... 20.5.2 Zeichenorientierte Datenströme über Files beziehen..................................... 1107 20.5.3 Die Funktion von OpenOption bei den Files.new(...)-Methoden................... 1109 20.5.4 Ressourcen aus dem Modulpfad und aus JAR-Dateien laden......................... 1110 Zum Weiterlesen.......................................................................................................... Einführung ins Datenbankmanagement mit JDBC 1106 1112 1113 Relationale Datenbanken und Java-Zugriffe............................................................ 1113 21.1.1 Das relationale Modell..................................................................................... 1113 21.1.2 Java-APIs zum Zugriff auf relationale Datenbanken ...................................... 1114 21.1.3 Die JDBC-ΑΡΙ und Implementierungen: JDBC-Treiber..................................... 1115 21.1.4 H2 ist das Werkzeug auf der Insel................................................................... 1115 Eine Beispielabfrage..................................................................................................... 1116 21.2.1 Schritte zur Datenbankabfrage........................................................................ 1116 21.2.2 Mit Java auf die relationale Datenbank zugreifen.......................................... 1116 Zum Weiterlesen.......................................................................................................... 1118 Inhalt 22 Bits und Bytes, Mathematisches und Geld 1119 22.1 Bits und Bytes............................................................................................................... 1119 22.1.1 Die Bit-Operatoren Komplement, Und, Oder und XOR................................... 1120 22.1.2 Repräsentation ganzer Zahlen in Java-das Zweierkomplement................. 22.1.3 Das binäre (Basis 2), oktale (Basis 8), hexadezimale (Basis 16) Stellenwertsystem .......................................................................................... 22.2 1121 1123 22.1.4 AuswirkungderTypumwandlungaufdieBit-Muster.................................... 1124 22.1.5 Vorzeichenlos arbeiten.................................................................................... 1127 22.1.6 Die Verschiebeoperatoren............................................................................... 1129 22.1.7 Ein Bit setzen, löschen, umdrehen und testen ............................................... 22.1.8 Bit-Methoden der Integer- und Long-Klasse................................................... 1132 1132 Fließkomma-Arithmetik in Java ................................................................................ 1134 22.2.1 Spezialwerte für Unendlich, Null, NaN........................................................... 1135 22.2.2 Standardnotation und wissenschaftliche Notation bei 22.2.3 Mantisse und Exponent ................................................................................ 1138 Die Eigenschaften der Klasse Math........................................................................... 1140 Fließkommazahlen........................................................................................ 1138 22.3 22.3.1 Objektvariablen der Klasse Math.................................................................... 1140 22.3.2 Absolutwerte und Vorzeichen......................................................................... 1140 22.3.3 Maximum/Minimum...................................................................................... 1141 22.3.4 Runden von Werten......................................................................................... 1142 22.3.5 Rest der ganzzahligen Division ..................................................................... 1145 22.3.6 22.4 22.5 Division mit Rundung in Richtung negativ unendlich, alternativer Restwert ........................................................................................................ 1145 22.3.7 Multiply-Accumulate....................................................................................... 1147 22.3.8 Wurzel- und Exponentialmethoden ............................................................... 1147 22.3.9 Der Logarithmus ............................................................................................ 1149 22.3.10 Winkelmethoden.......................................................................................... 1149 22.3.11 Zufallszahlen................................................................................................... 1151 Genauigkeit, Wertebereich eines Typs und Überlaufkontrolle ........................... 1151 22.4.1 Der größte und der kleinste Wert................................................................... 1151 22.4.2 Überlauf und alles ganz exakt......................................................................... 1152 22.4.3 Was bitte macht eine ulp?............................................................................... 1154 Zufallszahlen: Random, SecureRandom und SplittableRandom........................... 1156 22.5.1 Die Klasse Random.......................................................................................... 1156 22.5.2 Random-Objekte mit dem Samen aufbauen.................................................. 1156 22.5.3 Einzelne Zufallszahlen erzeugen..................................................................... 1157 22.5.4 Pseudo-Zufallszahlen in der Normalverteilung ............................................ 1158 22.5.5 Strom von Zufallszahlen generieren ............................................................ 1158 27 Inhalt 22.6 22.7 22.5.6 Die Klasse SecureRandom ............................................................................. 22.5.7 SplittableRandom ........................................................................................... 1160 Große Zahlen .............................................................................................................. 1161 22.6.1 Die Klasse Biglnteger....................................................................................... 1161 22.6.2 Beispiel: ganz lange Fakultäten mit Biglnteger............................................... 1168 22.6.5 Große Fließkommazahlen mit BigDecimal ..................................................... 1169 22.6.4 Mit MathContext komfortabel die Rechengenauigkeit setzen...................... 1172 22.6.5 Noch schneller rechnen durch mutable Implementierungen........................ 1174 Geld und Währung....................................................................................................... 1174 22.7.1 22.8 23 23.1 Geldbeträge repräsentieren............................................................................. 1174 22.7.2 ISO 4217........................................................................................................... 1175 22.7.3 Währungen in Java repräsentieren.................................................................. 1175 Zum Weiterlesen.......................................................................................................... Testen mit JUnit Softwaretests................................................................................................................ 23.1.1 23.2 1160 1176 1177 1177 Vorgehen beim Schreiben von Testfällen........................................................ 1178 Das Test-Framework JUnit........................................................................................... 1178 23.2.1 Test-Driven Development und Test-First......................................................... 1179 23.2.2 Testen, implementieren, testen, implementieren, testen, freuen................. 1181 23.2.3 JUnit-Tests ausführen ...................................................................................... 1183 23.2.4 assert(...)-Methoden der Klasse Assertions..................................................... 1183 23.2.5 Exceptions testen............................................................................................. 1186 23.2.6 Grenzen für Ausführungszeiten festlegen...................................................... 1187 23.2.7 Beschriftungen mit @DisplayName................................................................ 1188 23.2.8 Verschachtelte Tests........................................................................................ 23.2.9 Tests ignorieren................................................................................................ 1189 1188 23.2.10 Mit Methoden der Assumptions-Klasse Tests abbrechen .............................. 1189 23.2.11 Parametrisierte Tests....................................................................................... 23.3 1189 Java-Assertions-Bibliotheken und Asserti................................................................. 1191 23.3.1 Asserti............................................................................................................... 1191 23.4 Aufbau größerer Testfälle.......................................................................................... 1193 23.4.1 Fixtures............................................................................................................. 1193 23.4.2 Sammlungen von Testklassen und Klassenorganisation................................ 1195 23.5 Wie gutes Design das Testen ermöglicht................................................................... 1195 23.6 Dummy, Fake, Stub und Mock.................................................................................... 1198 28 Inhalt 23.7 JUnit-Erweiterungen, Testzusätze............................................................................. 1199 23.8 Zum Weiterlesen.......................................................................................................... 1200 24 24.1 24.2 24.3 24.4 24.5 Die Werkzeuge des JDK 1201 Übersicht....................................................................................................................... 1201 24.1.1 1202 Aufbau und gemeinsame Schalter................................................................. Java-Quellen übersetzen............................................................................................. 1202 24.2.1 Der Java-Compiler des JDK.............................................................................. 1202 24.2.2 Alternative Compiler....................................................................................... 1203 24.2.3 Native Compiler.............................................................................................. 1204 Die Java-Laufzeitumgebung....................................................................................... 1204 24.3.1 Schalter der JVM .............................................................................................. 1205 24.3.2 DerUnterschiedzwischenjava.exeundjavaw.exe........................................ 1207 Dokumentationskommentare mit Javadoc.............................................................. 1207 24.4.1 Einen Dokumentationskommentarsetzen .................................................... 1208 24.4.2 Mit dem Werkzeug javadoc eine Dokumentation erstellen.......................... 1210 24.4.3 HTML-Tags in Dokumentationskommentaren ............................................. 1211 24.4.4 Generierte Dateien.......................................................................................... 1211 24.4.5 Dokumentationskommentare im Überblick ................................................ 1212 24.4.6 Javadoc und Doclets *...................................................................................... 1213 24.4.7 Veraltete (deprecated) Typenund Eigenschaften............................................ 1214 24.4.8 Javadoc-Überprüfung mit DocLint.................................................................. 1217 Das Archivformat JAR.................................................................................................. 1217 24.5.1 Das Dienstprogramm jar benutzen................................................................. 1218 24.5.2 Das Manifest................................................................................................... 24.5.3 Applikationen in JAR-Archiven starten............................................................ 1219 1219 24.6 jlink: der Java Linker.................................................................................................... 1220 24.7 1221 Zum Weiterlesen.......................................................................................................... Anhang A Java SE-Module und Paketübersicht........................................................................ 1223 Index......................................................................................................................................... 1241 29
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	BV047560644
classification_rvk	ST 250
classification_tum	DAT 362
ctrlnum	(OCoLC)1284785486 (DE-599)BVBBV047560644
dewey-full	005.133
dewey-hundreds	000 - Computer science, information, general works
dewey-ones	005 - Computer programming, programs, data, security
dewey-raw	005.133
dewey-search	005.133
dewey-sort	15.133
dewey-tens	000 - Computer science, information, general works
discipline	Informatik
edition	16., aktualisierte und überarbeitete Auflage
format	Book
fullrecord	<?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>03077nam a22007098c 4500</leader><controlfield tag="001">BV047560644</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20230417 </controlfield><controlfield tag="007">t\|</controlfield><controlfield tag="008">211027s2022 gw a\|\|\| \|\|\|\| 00\|\|\| ger d</controlfield><datafield tag="016" ind1="7" ind2=" "><subfield code="a">1241344973</subfield><subfield code="2">DE-101</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9783836287456</subfield><subfield code="c">Festeinband : EUR 49.90 (DE), EUR 51.30 (AT), CHF 63.90 (freier Preis)</subfield><subfield code="9">978-3-8362-8745-6</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">3836287455</subfield><subfield code="9">3-8362-8745-5</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)1284785486</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)BVBBV047560644</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">XA-DE-NW</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-188</subfield><subfield code="a">DE-1050</subfield><subfield code="a">DE-858</subfield><subfield code="a">DE-739</subfield><subfield code="a">DE-Aug4</subfield><subfield code="a">DE-29T</subfield><subfield code="a">DE-19</subfield><subfield code="a">DE-M347</subfield><subfield code="a">DE-706</subfield><subfield code="a">DE-1049</subfield><subfield code="a">DE-1102</subfield><subfield code="a">DE-B768</subfield><subfield code="a">DE-573</subfield><subfield code="a">DE-573n</subfield><subfield code="a">DE-355</subfield><subfield code="a">DE-861</subfield><subfield code="a">DE-1028</subfield><subfield code="a">DE-860</subfield><subfield code="a">DE-824</subfield><subfield code="a">DE-523</subfield><subfield code="a">DE-83</subfield></datafield><datafield tag="082" ind1="0" ind2=" "><subfield code="a">005.133</subfield><subfield code="2">23/ger</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 250</subfield><subfield code="0">(DE-625)143626:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">004</subfield><subfield code="2">sdnb</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">DAT 362</subfield><subfield code="2">stub</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">16., aktualisierte und überarbeitete Auflage</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">Bonn</subfield><subfield code="b">Rheinwerk</subfield><subfield code="c">2022</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">1258 Seiten</subfield><subfield code="b">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 Cover: Programmieren mit der Java Platform, Standard Edition 17 ; Java von A bis Z: Einführung, Praxis, Referenz ; von Ausdrücken und Anweisungen zu Klassen und Objekten ; das Standardwerk</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Java Standard Edition 17</subfield><subfield code="0">(DE-588)1286419034</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Java</subfield><subfield code="g">Programmiersprache</subfield><subfield code="0">(DE-588)4401313-9</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Standard Edition 17</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Hand-Buch Bücher Grundlagen Kurse Tipps Workshops Tutorials Anleitung Training Ausbildung Informatik</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">JDBC</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">JDK</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">JSON</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Oracle</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Objektorientiert programmieren 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="653" ind1=" " ind2=" "><subfield code="a">Programmierung</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Software-Entwicklung</subfield></datafield><datafield tag="653" ind1=" " ind2=" "><subfield code="a">Java-17</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="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 17</subfield><subfield code="0">(DE-588)1286419034</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="710" ind1="2" ind2=" "><subfield code="a">Rheinwerk Verlag</subfield><subfield code="0">(DE-588)1081738405</subfield><subfield code="4">pbl</subfield></datafield><datafield tag="780" ind1="0" ind2="0"><subfield code="i">Vorangegangen ist</subfield><subfield code="z">978-3-8362-7737-2</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="q">text/html</subfield><subfield code="u">http://deposit.dnb.de/cgi-bin/dokserv?id=4393074fa45844a39f89095b23200cdb&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">Digitalisierung UB Passau - ADAM Catalogue Enrichment</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=032936087&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-032936087</subfield></datafield></record></collection>
genre	(DE-588)4123623-3 Lehrbuch gnd-content
genre_facet	Lehrbuch
id	DE-604.BV047560644
illustrated	Illustrated
indexdate	2024-12-20T19:22:13Z
institution	BVB
institution_GND	(DE-588)1081738405
isbn	9783836287456 3836287455
language	German
oai_aleph_id	oai:aleph.bib-bvb.de:BVB01-032936087
oclc_num	1284785486
open_access_boolean
owner	DE-188 DE-1050 DE-858 DE-739 DE-Aug4 DE-29T DE-19 DE-BY-UBM DE-M347 DE-706 DE-1049 DE-1102 DE-B768 DE-573 DE-573n DE-355 DE-BY-UBR DE-861 DE-1028 DE-860 DE-824 DE-523 DE-83
owner_facet	DE-188 DE-1050 DE-858 DE-739 DE-Aug4 DE-29T DE-19 DE-BY-UBM DE-M347 DE-706 DE-1049 DE-1102 DE-B768 DE-573 DE-573n DE-355 DE-BY-UBR DE-861 DE-1028 DE-860 DE-824 DE-523 DE-83
physical	1258 Seiten Illustrationen 24 cm x 19 cm
publishDate	2022
publishDateSearch	2022
publishDateSort	2022
publisher	Rheinwerk
record_format	marc
series2	Rheinwerk Computing
spellingShingle	Ullenboom, Christian Java ist auch eine Insel Einführung, Ausbildung, Praxis Java Standard Edition 17 (DE-588)1286419034 gnd Java Programmiersprache (DE-588)4401313-9 gnd
subject_GND	(DE-588)1286419034 (DE-588)4401313-9 (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 Standard Edition 17 (DE-588)1286419034 gnd Java Programmiersprache (DE-588)4401313-9 gnd
topic_facet	Java Standard Edition 17 Java Programmiersprache Lehrbuch
url	http://deposit.dnb.de/cgi-bin/dokserv?id=4393074fa45844a39f89095b23200cdb&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=032936087&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA
work_keys_str_mv	AT ullenboomchristian javaistaucheineinseleinfuhrungausbildungpraxis AT rheinwerkverlag javaistaucheineinseleinfuhrungausbildungpraxis

Verfügbarkeit

‌

Inhaltsverzeichnis