Verfügbarkeit: Java ist auch eine Insel

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

Gespeichert in:

Bibliographische Detailangaben
1. Verfasser:	Ullenboom, Christian (VerfasserIn)
Format:	Buch
Sprache:	German
Veröffentlicht:	Bonn Rheinwerk 2022
Ausgabe:	16., aktualisierte und überarbeitete Auflage
Schriftenreihe:	Rheinwerk Computing
Schlagworte:	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
Online-Zugang:	Inhaltstext Inhaltsverzeichnis
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
Beschreibung:	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
999			\|a oai:aleph.bib-bvb.de:BVB01-032936087

Datensatz im Suchindex

_version_	1804182887390511104
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
adam_txt	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
any_adam_object_boolean	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
discipline_str_mv	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>03076nam 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="999" ind1=" " 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
index_date	2024-07-03T18:27:22Z
indexdate	2024-07-10T09:14:41Z
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
spelling	Ullenboom, Christian Verfasser (DE-588)123404738 aut Java ist auch eine Insel Einführung, Ausbildung, Praxis Christian Ullenboom 16., aktualisierte und überarbeitete Auflage Bonn Rheinwerk 2022 1258 Seiten Illustrationen 24 cm x 19 cm txt rdacontent n rdamedia nc rdacarrier Rheinwerk Computing 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 Java Standard Edition 17 (DE-588)1286419034 gnd rswk-swf Java Programmiersprache (DE-588)4401313-9 gnd rswk-swf 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 (DE-588)4123623-3 Lehrbuch gnd-content Java Programmiersprache (DE-588)4401313-9 s Java Standard Edition 17 (DE-588)1286419034 s DE-604 Rheinwerk Verlag (DE-588)1081738405 pbl Vorangegangen ist 978-3-8362-7737-2 text/html http://deposit.dnb.de/cgi-bin/dokserv?id=4393074fa45844a39f89095b23200cdb&prov=M&dok_var=1&dok_ext=htm Inhaltstext Digitalisierung UB Passau - ADAM Catalogue Enrichment application/pdf 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 Inhaltsverzeichnis
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_exact_search_txtP	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

Es ist kein Print-Exemplar vorhanden.

Fernleihe Bestellen Achtung: Nicht im THWS-Bestand! Beschreibung

MARC

Datensatz im Suchindex

Es ist kein Print-Exemplar vorhanden.

Ähnliche Einträge