Programmierung Java Version 1.6

360 Pages·2015·4.49 MB·German

Programmierung
Java
Version 1.6 (SS 2015
Shanghai Hamburg College)
Bernd Kahlbrandt
24. Februar 2015
ii
Alle in diesem Dokument enthaltenen Informationen, Verfahren und Darstellungen wurden nach
bestemWissenzusammengestelltundsorgfältigüberprüft.DennochsindFehlernichtauszuschlie-
ßen.Aus diesem Grundsinddie im vorliegendenDokumententhaltenen Informationenmit keiner
Verpflichtung oder Garantie irgendeiner Art verbunden. Weder der Autor noch die Hochschule
übernehmen infolgedessen irgendwelche juristische Verantwortung und werden keine daraus fol-
gende oder sonstige Haftung übernehmen, die auf irgendeine Art aus der Benutzung dieser Infor-
mationen oder Teilen davon entsteht.
© 2009–2021Bernd Kahlbrandt
Vorwort
Wenn ich eine neue Vorlesung halten will oder auch andere, mir neue Dinge erarbeiten will, so
hat es sich für mich bewährt aufzuschreiben, was ich gelernt habe. So habe ich im Februar 2009
dieses Dokument begonnen. Es spiegelt meinen ersten ernsthaften Versuch wider, Programmie-
rung systematisch zu lernen. Was einmal daraus werden wird, ist offen. Sicher ist, dass ich viel
gelernt habe. Auch das Zusammenspiel von Programmierung (PR) und Algorithmen und Daten-
strukturen (AD) hat sich für meinen Lernprozess bewährt. Für das Softwareengineering (SE) ist
meine Beispielsammlung gewachsen. Eigentlich lehre ich in allen Veranstaltungen (PR, DB, SE,
AD) Grundprinzipien der Softwareentwicklung auf verschiedenen Niveaus.
VorvielenJahrenlasichimerstenKapiteldesBuchs[OK99]meinesKollegenBerndOwsnicki:
„Außerdem muß man schon sehr gut programmieren können, damit im Endprodukt
der Kern des Algorithmus noch zu erkennen ist.“
Warum versuchenwir eigentlich nicht dies den Studierenden nicht beizubringen? In dieser Veran-
staltung versuche ich, einen Beitrag dazu zu leisten.
Gemäß der aktuellen Modulbeschreibungen B-WI und B-TI PR1 (=ˆ PT + PM) und PR2
werden die folgenden Themen behandelt:
• Elementare Programmiertechniken
– primitive Typen,
– Unicode,
– Arrays,
– Referenztypen,
– Sequenz,
– Selektion,
– Iteration,
– Rekursion
• Abstraktionsmechanismen
– Funktionale Abstraktion
– Datenabstraktion (ADT)
– Kontrollabstraktion(z.B. Iteratoren, Streams)
• Objektorientierung(prozeduralundfunktional)-Polymorphie:Overloading,Overriding,late
binding
• Ausgewählte Elemente objektorientierter Bibliotheken, z.B. :
– Collections
– Streams,
iii
iv
– Channels (aus java.nio)
• Typisierungskonzepte
– Dynamische vs. statische Typisierung
• Ausgewählte Elemente objektorientierter Bibliotheken, z.B.
– GUI-Frameworks
– Generics
• Metasprachliche Konzepte
– Annotationen,
– XML
– Reflection
• Vertiefungen
– Typ- vs. Implementationshierarchie
– elementare Entwurfsmuster
– Modellierungen (anhand UML)
– nebenläufige bzw. asynchrone Programmierung
– Deployment
• Correctness
– Design by Contract (Assertions, Invarianten)
– Teststrategien
Lernen sollen Sie dieses:
• Beherrschung von handwerklichen Programmierfertigkeiten und elementaren Programmier-
techniken.
• KennenlernenunterschiedlicherKonzepteundModellevonProgrammiersprachen(Program-
mierparadigmen).Dabei wirdzunächst das Paradigma Objektorientierung wichtig sein. An-
dere Paradigmen folgen an passenden Stellen im Verlauf der Veranstaltung.
• ObjektorientierteModellierungundtechnischeRealisierungvonSystemenimKleinendurch-
führen können.
• Beherrschung von fortgeschrittenen Fertigkeiten und Programmiertechniken.
• Objektorientierte Modellierung und technischen Realisierung von Systemen, die nur team-
orientiert erarbeitet werden können, beherrschen.
Selbstverständlich gibt es in B-TI und B-WI unterschiedliche Schwerpunkte. Insofern werden
nicht alle Themen in jedem der Studiengänge behandelt werden.
Die Arbeit an diesem Skript begann im SS 2009 und WS 2009/10 parallel zu den Vorlesun-
gen Programmierung 1 und 2 im Bachelor-Studiengang Technische Informatik am Department
Informatik der Fakultät TI an der HAW. Eine erste Version α für Studierende wurde im SS 2010
veröffentlicht.Diese wurde sukzessiveüber die beiden Semester weiterentwickelt.Zum Sommerse-
mester 2011 erschien eine erste β-Version.
Für das WS 2012 habe ich etwas ergänzt. Im SS 2012 verwende ich das Skript für die Pro-
grammiervorlesungimStudiengangWirtschaftsinformatik.DazuerscheintesinEtappen.Deshalb
habe ich die Reihenfolge der Kapitel so verändert, dass alle Teile am Anfang stehen, die Martin
Hübner im ersten Teil der Vorlesung behandelt hat.
FürdasWS2012/13und dasSS2013entstandeineinTeilengrundsätzlichüberarbeitete Ver-
sion.So nehme ich in Kap.2 mit Ihnen eine ganz schlanke„Tiefbohrung“ in die objekt-orientierte
Programmierung mit Java vor.
v
Danke
In den Semestern ab SS 2011 konnte ich zum ersten Mal direkte Beiträge von Studierenden zu
diesemSkripterwähnen.Ichkannnicht—analogDonKnuth—für die Entdeckungeines Fehlers
oder einen konstruktiven Beitrag einem Hex-Euro (2,56) zahlen. Ich bemühe mich aber um eine
Würdigung der Beiträge meiner Veranstaltungsteilnehmerinnen und -teilnehmer. Die Tabelle mit
demVergleichvoncompareTo undequals aufS.49habeichalsAntwortaufeineFragevonTugba
Karakaya im SS 2011 aufgestellt. Gute Fragen und Beiträge kamen (ohne zeitliche, quantitative
oder qualitative Einstufung waren alle hilfreich) von Jeremias Twele, Ihmed Bahrini, Thomas
Broja,ClemensDrauschke,IbrahimGenc,LarsHarmsen,TugbaKarakaya,VitaliKagadij,Ilyuza
Mingazova,AntonStarobinski,AliZardosht,...Jan-TristanRudathatimWS2011/12großeTeile
Korrektur gelesen.
Im SS 2012 gab es konstruktive Anmerkungen von Charlotte Christophers, Olf Deussen, Mi-
chael Erhard und Ramin Mohibi u.a.
AusdemWS2012/13erinnereichvieleFragenundBeiträgeu.a.vonKurtLaabs,Christopher
Masch, Henning Krohn, Natalie Gläser.
Im SS 2013 hat Florian Arfert das Kap. 17 korrekturgelesenund mich auf Fehler und Verbes-
serungsmöglichkeitenhingewiesen.
Zur Auflage WS 2014/15, SS 2015
In dieser Auflage halte ich dieses Skript für soweit gediehen, dass ich es als Version 1.5 ohne
Zusatz β veröffentliche. Jetzt ist die aktuelle und hier zu Grunde gelegte Version Java 8. Es
ist nicht möglich in der verfügbaren Zeit auch nur die grundlegenden Neuerungen vollständig
zu besprechen. Insofern werden z.B. Lambda-Ausdrücke behandelt aber auf eine systematische
Einführung in funktionale Programmierung wird verzichtet.
ImIndexverweisenfettgesetzteSeitenzahlenaufdieDefinitiondesBegriffsundkursiv gesetzte
Seitenzahlen auf Inhalte im Literaturverzeichnis.
vi INHALTSVERZEICHNIS
Inhaltsverzeichnis
Abbildungsverzeichnis xiv
1 Einführung 1
1.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Objektorientierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4 Programmierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.5 Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.6 Rechner, Betriebssystem, Compiler und Konsorten. . . . . . . . . . . . . . . . . . 12
1.6.1 Compiler/Linker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.6.2 Virtuelle Maschine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.6.3 Java Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.7 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.8 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2 Ein Einführungsbeispiel 17
2.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.4 Klasse Bruch: Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.5 Erste Verbesserungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.6 Gleichheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.7 Vergleichbarkeit:Größer und kleiner . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.8 Resumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.9 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.10 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3 Klassen 33
3.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.3 Struktur von Klassendateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.4 Attribute, Operationen und Methoden . . . . . . . . . . . . . . . . . . . . . . . . 37
3.5 Pakete (Packages) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.6 Schnittstellen (Interfaces) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.7 Generalisierung und Spezialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.8 Die Klasse Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.9 Anwendungsbeispiel: Elementare Verschlüsselung . . . . . . . . . . . . . . . . . . 49
3.10 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.11 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4 Basiskonstrukte 51
4.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
INHALTSVERZEICHNIS vii
4.3 Deklaration, Zuweisung, Kommentar und Ausdruck . . . . . . . . . . . . . . . . . 51
4.4 Primitive und Referenz-Datentypen . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.5 Befehle, detailliert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.5.1 Schleifen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.5.2 Kontrollstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.6 Operatorenin Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.6.1 Zuweisungsoperator„=“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.6.2 Boolesche Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.6.3 Relationale Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.6.4 Mathematische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.6.5 Bitweise Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4.6.6 Cast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.6.7 instanceof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.6.8 .- Operator (Attribut- und Methoden-Zugriff) . . . . . . . . . . . . . . . . . 67
4.6.9 Vorrang von Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.7 Initialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.8 Methodenaufruf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.9 Rekursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.10 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.11 Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.12 Datum und Uhrzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.13 Deprecated . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.14 Typumwandlungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.15 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.16 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
5 Der Zähler (The Count) 81
5.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5.3 Einführungsbeispiel - Beschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5.4 Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
5.5 Ein erster Entwurf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
5.6 Eine erste Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
5.7 Testen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
5.8 Zwei-Schichten-Modell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
5.9 Oberflächen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.10 Counter mit Klassenattribut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5.11 Mehrere Sichten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
5.12 Unterschiedliche Typen von Zählern . . . . . . . . . . . . . . . . . . . . . . . . . . 95
5.13 Speichern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
5.14 Erstes Refactoring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
5.15 Varianten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
5.16 Mehrbenutzerzähler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
5.17 Weitere Übungsmöglichkeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
5.18 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
5.19 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
6 Numerische Datentypen und Zahlendarstellungen 101
6.1 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6.3 Primitive Typen und Wrapper-Klassen . . . . . . . . . . . . . . . . . . . . . . . . 101
6.4 Ganzzahlige Typen - Interna . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
6.4.1 Ganze Zahlen — binär . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
6.4.2 Ganze Zahlen - Verschiedene Basen. . . . . . . . . . . . . . . . . . . . . . . 104
viii INHALTSVERZEICHNIS
6.5 Fließkommazahlen— Interna . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
6.6 Spezielle Zahlensysteme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
6.6.1 Fibonacci Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
6.7 Einige numerische Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
6.8 Zahlenalgorithmenund Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . 109
6.9 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
6.10 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
7 Bitweise Operationen 113
7.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
7.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
7.3 Grundlagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
7.4 Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
7.5 Binärbäume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
7.6 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
7.7 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
8 Mehr über Klassen 119
8.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.3 Initialisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
8.4 Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
8.5 Assoziationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
8.6 Vererbung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
8.7 Mehr über Konstruktoren. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
8.8 Innere und lokale Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
8.9 Anonyme Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
8.10 Anonyme Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
8.11 Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
8.12 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
8.13 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
9 Datum und Uhrzeit 137
9.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
9.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
9.3 Grundlagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
9.4 Einheiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
9.5 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
9.6 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
10 Fehlerbehandlung 143
10.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
10.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
10.3 Klassifikation von Fehlern. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
10.4 Compiler-Fehler und -Warnungen . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
10.5 Laufzeitfehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
10.6 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
10.7 Fehlererkennung zur Laufzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
10.8 Vorbedingungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
10.9 Nachbedingungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
10.10 Zusicherungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
10.11 Fehlerbehandlungsstrategien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
10.12 Fehlermeldungen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
10.13 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
INHALTSVERZEICHNIS ix
10.14 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
11 Javadoc 155
11.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
11.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
11.3 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
11.4 HTML in Javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
11.5 Javadoc-Dateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
11.6 Javadoc-Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
11.7 Praktische Hinweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
11.8 Doclets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
11.9 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
11.10 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
12 Ein- und Ausgabe 163
12.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
12.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
12.3 Ein- und Ausgaben von und auf die Konsole . . . . . . . . . . . . . . . . . . . . . 163
12.4 Dateien (Files) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
12.5 Eingabe von Dateinamen und Auswahl von Dateien . . . . . . . . . . . . . . . . . 165
12.6 Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
12.7 Channels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
12.8 Serialisierung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
12.9 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
12.10 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
13 Container-Klassen 173
13.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
13.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
13.3 Parametrisierte Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
13.4 Parametrisierte Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
13.5 Assoziationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
13.6 Technische Einzelheiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
13.7 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
13.8 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
14 Noch mehr zu Klassen und Schnittstellen: λ-Ausdrücke 181
14.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
14.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
14.3 Funktionale Schnittstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
14.4 Lambda-Ausdrücke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
14.5 Methodenreferenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
14.6 λ-Ausdrücke als Alternative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
14.7 Datum und Uhrzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
14.8 Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
14.9 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
14.10 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
15 Streaming API 191
15.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
15.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
15.3 Grundprinzipien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
15.4 Stream-Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
15.5 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
x INHALTSVERZEICHNIS
15.6 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
16 Graphische Oberflächen 197
16.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
16.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
16.3 Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
16.4 Swing Schritt für Schritt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
16.4.1 Schritt 1: Ein einfaches Fenster . . . . . . . . . . . . . . . . . . . . . . . . . 198
16.4.2 Schritt 2: Hinzufügen einer Menüleiste . . . . . . . . . . . . . . . . . . . . . 199
16.4.3 Schritt 3: Reagieren auf Menüauswahl . . . . . . . . . . . . . . . . . . . . . 200
16.4.4 Schritt 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
16.5 Layout Manager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
16.6 Swing Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
16.6.1 JLabel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
16.6.2 Font . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
16.6.3 JButton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
16.6.4 JList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
16.6.5 JTable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
16.6.6 JTree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
16.7 Java FX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
16.7.1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
16.7.2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
16.7.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
16.7.4 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
16.7.5 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
16.8 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
16.9 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
17 Generics 213
17.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
17.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
17.3 Grundlagen: Einfache Typparameter . . . . . . . . . . . . . . . . . . . . . . . . . 214
17.4 Einschränkungen für Typparameter . . . . . . . . . . . . . . . . . . . . . . . . . . 217
17.5 Wildcards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
17.6 Generische Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
17.7 Verwendung parametrisierter Elemente . . . . . . . . . . . . . . . . . . . . . . . . 224
17.8 Verwendung generischer Elemente . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
17.9 Die Java Collection-Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
17.10 Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
17.11 Comparable und Comparator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
17.12 Geordnete Collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
17.13 Generische Klassen und Methoden . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
17.14 Enumerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
17.15 Historische Anmerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
17.16 Aufgaben . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
18 Reflection 239
18.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
18.2 Lernziele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
18.3 Objekte, Klassen und Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
18.4 Dynamische Aufrufe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
18.5 Umgang mit Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
18.6 Anwendungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
18.7 Etwas über Interna . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246