Dipl.-Inform. Michael Inden ist Oracle-zertifizierter Java-Entwickler. Nach seinem Studium in Oldenburg hat er bei diversen internationalen Firmen in verschiedenen Rollen etwa als Softwareentwickler, -architekt, Consultant, Teamleiter, CTO sowie Leiter Academy gearbeitet. Zurzeit ist er freiberuflich als Autor und Trainer in Zürich tätig.
Michael Inden hat über zwanzig Jahre Berufserfahrung beim Entwurf komplexer Softwaresysteme gesammelt, an diversen Fortbildungen und mehreren Java-One-Konferenzen teilgenommen. Sein besonderes Interesse gilt dem Design qualitativ hochwertiger Applikationen sowie dem Coaching. Sein Wissen gibt er gerne als Trainer in internen und externen Schulungen und auf Konferenzen weiter, etwa bei der JAX/W-JAX, JAX London, Oracle Code One, ch.open sowie bei der Java User Group Switzerland.
Zu diesem Buch – sowie zu vielen weiteren dpunkt.büchern – können Sie auch das entsprechende E-Book im PDF-Format herunterladen. Werden Sie dazu einfach Mitglied bei dpunkt.plus+: www.dpunkt.plus |
Gleich richtig programmieren lernen
Michael Inden
michael_inden@hotmail.com
Lektorat: Michael Barabas
Projektkoordinierung: Anja Weimer
Fachgutachten: Torsten Horn, Aachen
Copy-Editing: Ursula Zimpfer, Herrenberg
Satz: Michael Inden
Herstellung: Stefanie Weidner
Umschlaggestaltung: Helmut Kraus, www.exclam.de
Bibliografische Information der Deutschen Nationalbibliothek
Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.
ISBN:
Print 978-3-86490-852-1
PDF 978-3-96910-543-6
ePub 978-3-96910-544-3
mobi 978-3-96910-545-0
1. Auflage 2021
Copyright © 2021 dpunkt.verlag GmbH
Wieblinger Weg 17
69123 Heidelberg
Hinweis:
Dieses Buch wurde auf PEFC-zertifiziertem Papier aus nachhaltiger Waldwirtschaft gedruckt. Der Umwelt zuliebe verzichten wir zusätzlich auf die Einschweißfolie.
Schreiben Sie uns:
Falls Sie Anregungen, Wünsche und Kommentare haben, lassen Sie es uns wissen: hallo@dpunkt.de.
Die vorliegende Publikation ist urheberrechtlich geschützt. Alle Rechte vorbehalten. Die Verwendung der Texte und Abbildungen, auch auszugsweise, ist ohne die schriftliche Zustimmung des Verlags urheberrechtswidrig und daher strafbar. Dies gilt insbesondere für die Vervielfältigung, Übersetzung oder die Verwendung in elektronischen Systemen.
Es wird darauf hingewiesen, dass die im Buch verwendeten Soft- und Hardware-Bezeichnungen sowie Markennamen und Produktbezeichnungen der jeweiligen Firmen im Allgemeinen warenzeichen-, marken- oder patentrechtlichem Schutz unterliegen.
Alle Angaben und Programme in diesem Buch wurden mit größter Sorgfalt kontrolliert. Weder Autor noch Verlag können jedoch für Schäden haftbar gemacht werden, die in Zusammenhang mit der Verwendung dieses Buches stehen.
5 4 3 2 1 0
Für unsere bezaubernde Prinzessin Sophie Jelena
Vorwort
IEinstieg
1Einführung
1.1Java im Überblick
1.2Los geht’s – Installation
1.2.1Java-Download
1.2.2Installation des JDKs
1.2.3Nacharbeiten nach der Java-Installation
1.2.4Java-Installation prüfen
1.3Entwicklungsumgebungen
1.3.1Installation von Eclipse
1.3.2Eclipse starten
1.3.3Erstes Projekt in Eclipse
1.3.4Erste Klasse in Eclipse
2Schnelleinstieg
2.1Hallo Welt (Hello World)
2.2Variablen und Datentypen
2.2.1Definition von Variablen
2.2.2Bezeichner (Variablennamen)
2.3Operatoren im Überblick
2.3.1Arithmetische Operatoren
2.3.2Zuweisungsoperatoren
2.3.3Vergleichsoperatoren
2.3.4Logische Operatoren
2.4Fallunterscheidungen
2.5Methoden
2.5.1Methoden aus dem JDK nutzen
2.5.2Eigene Methoden definieren
2.5.3Nützliche Beispiele aus dem JDK
2.5.4Signatur einer Methode
2.5.5Fehlerbehandlung und Exceptions
2.6Kommentare
2.7Schleifen
2.7.1Die for-Schleife
2.7.2Die for-each-Schleife
2.7.3Die while-Schleife
2.7.4Die do-while-Schleife
2.8Rekapitulation
2.9Weiterführende Dokumentation für nächste Schritte
2.10Aufgaben und Lösungen
2.10.1Aufgabe 1: Mathematische Berechnungen
2.10.2Aufgabe 2: Methode und if
2.10.3Aufgabe 3: Selbstabholerrabatt
2.10.4Aufgabe 4: Schleifen mit Berechnungen
2.10.5Aufgabe 5: Schleifen und fixe Schrittweite
2.10.6Aufgabe 6: Schleifen mit variabler Schrittweite
2.10.7Aufgabe 7: Verschachtelte Schleifen – Variante 1
2.10.8Aufgabe 8: Verschachtelte Schleifen – Variante 2
2.10.9Aufgabe 9: Verschachtelte Schleifen – Variante 3
3Strings
3.1Schnelleinstieg
3.1.1Gebräuchliche Stringaktionen
3.1.2Suchen und Ersetzen
3.1.3Informationen extrahieren und formatieren
3.2Nächste Schritte
3.2.1Die Klasse Scanner
3.2.2Mehrzeilige Strings (Text Blocks)
3.2.3Strings und char[]s
3.3Praxisbeispiel: Text in Title Case wandeln
3.4Aufgaben und Lösungen
3.4.1Aufgabe 1: Länge, Zeichen und Enthaltensein
3.4.2Aufgabe 2: Title Case mit Scanner
3.4.3Aufgabe 3: Zeichen wiederholen
3.4.4Aufgabe 4: Vokale raten
3.4.5Aufgabe 5: String Merge
4Arrays
4.1Schnelleinstieg
4.1.1Gebräuchliche Aktionen
4.1.2Mehrdimensionale Arrays
4.2Nächste Schritte
4.2.1Eindimensionale Arrays
4.2.2Mehrdimensionale Arrays
4.3Praxisbeispiel: Flächen füllen
4.4Aufgaben und Lösungen
4.4.1Aufgabe 1: Durcheinanderwürfeln eines Arrays
4.4.2Aufgabe 2: Arrays kombinieren
4.4.3Aufgabe 3: Rotation um eine oder mehrere Positionen
4.4.4Aufgabe 4: Zweidimensionales String-Array ausgeben
4.4.5Aufgabe 5: Dreieckiges Array: Upside Down
5Klassen und Objektorientierung
5.1Schnelleinstieg
5.1.1Grundlagen zu Klassen und Objekten
5.1.2Eigenschaften (Attribute)
5.1.3Verhalten (Methoden)
5.1.4Objekte vergleichen – die Rolle von equals()
5.2Nächste Schritte
5.2.1Klassen ausführbar machen
5.2.2Imports und Packages
5.2.3Übergang zum Einsatz einer IDE
5.2.4Imports und Packages: Auswirkungen auf unsere Applikation
5.2.5Verstecken von Informationen
5.3Vererbung
5.3.1Basisklassen und abstrakte Basisklassen
5.3.2Overloading und Overriding
5.4Die Klasse Object
5.4.1Beispielklasse Person
5.4.2Die Methode toString()
5.4.3Ergänzungen zur Methode equals(Object)
5.4.4Typprüfung mit instanceof
5.4.5Pattern Matching bei instanceof
5.5Schnittstelle (Interface) und Implementierung
5.6Records
5.7Aufgaben und Lösungen
5.7.1Aufgabe 1: Obstkorb
5.7.2Aufgabe 2: Superheld
5.7.3Aufgabe 3: Zähler
5.7.4Aufgabe 4: Zähler mit Überlauf
6Collections
6.1Schnelleinstieg
6.1.1Die Klasse ArrayList
6.1.2Die Klasse HashSet
6.1.3Iteratoren
6.1.4Die Klasse HashMap
6.2Nächste Schritte
6.2.1Generische Typen (Generics)
6.2.2Basisinterfaces für die Containerklassen
6.3Praxisbeispiel: Einen Stack selbst realisieren
6.4Aufgaben und Lösungen
6.4.1Aufgabe 1: Tennisverein-Mitgliederliste
6.4.2Aufgabe 2: Liste mit Farbnamen füllen und filtern
6.4.3Aufgabe 3: Duplikate entfernen – Variante 1
6.4.4Aufgabe 4: Duplikate entfernen – Variante 2
6.4.5Aufgabe 5: Hauptstädte
6.4.6Aufgabe 6: Häufigkeiten von Namen
6.4.7Aufgabe 7: Objekte mit Maps selbst gebaut
6.4.8Aufgabe 8: Listenreihenfolge umdrehen (mit Stack)
7Ergänzendes Wissen
7.1Sichtbarkeits- und Gültigkeitsbereiche
7.2Primitive Typen und Wrapper-Klassen
7.2.1Grundlagen
7.2.2Casting: Typerweiterungen sowie -verkleinerungen
7.2.3Konvertierung von Werten
7.3Ternary-Operator (?-Operator)
7.4Aufzählungen mit enum
7.5Switch
7.6Moderne Switch Expressions
7.6.1Einführendes Beispiel
7.6.2Weitere Gründe für die Neuerung
7.7Pattern Matching bei Switch Expressions (Java 17 Preview)
7.7.1Einführendes Beispiel
7.7.2Spezialitäten
7.8Break und Continuein Schleifen
7.8.1Funktionsweise von break und continuein Schleifen
7.8.2Wie macht man es besser?
7.9Rekursion
7.10Aufgaben und Lösungen
7.10.1Aufgabe 1: Würfelspiel
7.10.2Aufgabe 2: Prüfung auf Vokale mit switch
7.10.3Aufgabe 3: Temperaturumrechnung
7.10.4Aufgabe 4: Palindrom-Prüfung mit Rekursion
IIAufstieg
8Mehr zu Klassen und Objektorientierung
8.1Wissenswertes zu Vererbung
8.1.1Generalisierung und Spezialisierung
8.1.2Polymorphie
8.1.3Sub-Classing und Sub-Typing
8.2Varianten innerer Klassen
8.2.1»Normale« innere Klassen
8.2.2Statische innere Klassen
8.2.3Methodenlokale innere Klassen
8.2.4Anonyme innere Klassen
9Lambdas und Streams
9.1Einstieg in Lambdas
9.1.1Syntax von Lambdas
9.1.2Functional Interfaces und SAM-Typen
9.2Methodenreferenzen
9.3Externe vs. interne Iteration
9.3.1Externe Iteration
9.3.2Interne Iteration
9.3.3Das Interface Predicate<T>
9.4Streams im Überblick
9.4.1Streams erzeugen – Create Operations
9.4.2Intermediate und Terminal Operations im Überblick
9.4.3Zustandslose Intermediate Operations
9.4.4Zustandsbehaftete Intermediate Operations
9.4.5Terminal Operations
9.5Aufgaben und Lösungen
9.5.1Aufgabe 1: Erwachsene aus Personenliste extrahieren
9.5.2Aufgabe 2: Stream-API
9.5.3Aufgabe 3: Informationen mit Stream-API extrahieren
9.5.4Aufgabe 4: Häufigkeiten von Namen
9.5.5Aufgabe 5: Kollektoren
10Verarbeitung von Dateien
10.1Schnelleinstieg
10.1.1Das Interface Path und die Utility-Klasse Files
10.1.2Anlegen von Dateien und Verzeichnissen
10.1.3Inhalt eines Verzeichnisses auflisten
10.1.4Pfad ist Datei oder Verzeichnis?
10.1.5Dateiaktionen und die Utility-Klasse Files
10.1.6Informationen zu Path-Objekten ermitteln
10.1.7Kopieren
10.1.8Umbenennen
10.1.9Löschen
10.2Dateibehandlung und die Klasse File
10.2.1Konvertierung von Path in Fileund zurück
10.2.2Die Klasse Fileim Kurzüberblick
10.2.3Dateiinhalte verarbeiten und Systemressourcen
10.3Praxisbeispiel: Directory-Baum darstellen
10.3.1Basisvariante
10.3.2Variante mit schönerer Darstellung
10.3.3Finale Variante mit ausgeklügelter Darstellung
10.4Aufgaben und Lösungen
10.4.1Aufgabe 1: Texte in Datei schreiben und wieder lesen
10.4.2Aufgabe 2: Dateigrößen
10.4.3Aufgabe 3: Existenzprüfung
10.4.4Aufgabe 4: Rechteprüfung
10.4.5Aufgabe 5: Verzeichnisinhalt auflisten
11Fehlerbehandlung mit Exceptions
11.1Schnelleinstieg
11.1.1Fehlerbehandlung
11.1.2Exceptions selbst auslösen – throw
11.1.3Eigene Exception-Typen definieren
11.1.4Exceptions propagieren – throws
11.2Fehlerbehandlung in der Praxis
11.3Automatic Resource Management (ARM)
11.4Hintergrundwissen: Checked und Unchecked Exceptions
12Datumsverarbeitung
12.1Schnelleinstieg
12.1.1Die Aufzählungen DayOfWeek und Month
12.1.2Die Klasse LocalDate
12.1.3Die Klassen LocalTime und LocalDateTime
12.2Nächste Schritte
12.2.1Datumsarithmetik
12.2.2Formatierung und Parsing
12.3Praxisbeispiel: Kalenderausgabe
12.4Aufgaben und Lösungen
12.4.1Aufgabe 1: Wochentage
12.4.2Aufgabe 2: Freitag, der 13.
12.4.3Aufgabe 3: Mehrmals Freitag, der 13.
12.4.4Aufgabe 4: Schaltjahre
IIIPraxisbeispiele
13Praxisbeispiel: Tic Tac Toe
13.1Spielfeld initialisieren und darstellen
13.2Setzen der Steine
13.3Prüfen auf Sieg
13.4Bausteine im Einsatz
14Praxisbeispiel: CSV-Highscore-Liste einlesen
14.1Verarbeitung von Spielständen (Highscores)
14.2Extraktion der Daten
14.3Besonderheiten der Implementierung
15Praxisbeispiel: Worträtsel
15.1Applikationsdesign – Vorüberlegungen zur Strukturierung
15.2Einlesen der verfügbaren Wörter
15.3Hilfsdatenstrukturen
15.4Datenmodell
15.4.1Datenspeicherung und Initialisierung
15.4.2Zufällige Wahl von Richtung, Position, Wort und Buchstabe
15.4.3Algorithmus zum Verstecken von Wörtern
15.4.4Wort prüfen und platzieren
15.5HTML-Erzeugung
15.6Hauptapplikation
15.7Ausgabe als HTML und Darstellung im Browser
15.8Fazit
IVSchlussgedanken
16Gute Angewohnheiten
16.1Grundregeln eines guten Programmierstils
16.2Coding Conventions
16.2.1Grundlegende Namens- und Formatierungsregeln
16.2.2Namensgebung
16.2.3Dokumentation
16.2.4Programmdesign
16.2.5Parameterlisten
16.2.6Logik und Kontrollfluss
16.3Sourcecode-Prüfung
16.4JUnit 5: Auch ans Testen denken
16.4.1Das JUnit-Framework
16.4.2Schreiben und Ausführen von Tests
17Schlusswort
VAnhang
ASchlüsselwörter im Überblick
BSchnelleinstieg JShell
CGrundlagen zur JVM und Infos zum Java-Ökosystem
C.1Wissenswertes zur Java Virtual Machine (JVM)
C.1.1Einführendes Beispiel
C.1.2Ausführung eines Java-Programms
C.2Das Java-Ökosystem im Kurzüberblick
Literaturverzeichnis
Index
Zunächst einmal bedanke ich mich bei Ihnen, dass Sie sich für dieses Buch entschieden haben. Hierin finden Sie einen fundierten und interaktiven Einstieg in die Programmierung mit Java. Dabei fangen wir mit den Grundlagen an und bauen Ihr Wissen immer weiter aus, sodass Sie nach der Lektüre bereit sind, eigene Experimente zu wagen, und bestenfalls Programmieren als neues Hobby lieben gelernt haben. Insbesondere die ungeheuren Möglichkeiten, kreativ zu werden und dabei immer wieder Neues zu entdecken, werden Sie bestimmt ähnlich faszinieren wie mich seit über 30 Jahren.
Dies ist ein Buch für Programmierneulinge. Es wendet sich somit an
Zum Einstieg sind Programmiererfahrungen keine zwingende Voraussetzung – natürlich schaden diese nicht. Selbst dann nicht, wenn Sie sich vielleicht eher mit Python, C#, TypeScript oder JavaScript beschäftigt haben – aber für die Lektüre des Buchs ist es hilfreich, wenn Sie
Sie als Leser erhalten in diesem Buch einen Einstieg in Java. Allerdings ist die trockene Theorie auf ein Minimum reduziert und wir legen immer mit kleinen Beispielen los. Deshalb ist es auch ein Buch zum Mitmachen. Ich ermutige Sie ganz besonders, parallel zum Lesen auch immer ein paar Dinge auszuprobieren, vielleicht sogar mal das eine oder andere abzuwandeln. Man lernt Programmieren einfach am besten, wenn man es praktiziert. Somit bietet es sich an, die abgebildeten Codeschnipsel abzutippen, also direkt in der JShell einzugeben, oder später im Editor Ihrer IDE.
Damit Sie nicht über einfache Probleme stolpern, führt das Buch jeweils behutsam und schrittweise in die jeweiligen Thematiken ein und gibt Ihnen immer auch ein paar Hinweise, auf was man achten oder was man vielleicht sogar vermeiden sollte. Dazu dienen diverse Praxistipps mit Hintergrundinformationen.
In derart formatierten Kästen finden sich im späteren Verlauf des Buchs immer wieder einige wissenswerte Tipps und ergänzende Hinweise zum eigentlichen Text.
Dieses Buch besteht aus jeweils in sich abgeschlossenen, aber aufeinander aufbauenden Kapiteln zu elementar wichtigen Bereichen der Programmiersprache Java. Abgerundet werden viele Kapitel mit diversen Aufgaben und zugehörigen Musterlösungen, sodass das zuvor Gelernte direkt anhand neuer Problemstellungen praktiziert und das Wissen vertieft werden kann.
Für Ihren erfolgreichen Weg zur Java-Programmierung gliedert sich das Buch in die vier Teile Einstieg, Aufstieg, Praxisbeispiele und Schlussgedanken.
Im Teil »Einstieg« werden Grundlagen behandelt. Hier empfiehlt es sich wirklich, die Kapitel in der Reihenfolge des Buchs zu lesen, da mit jedem Kapitel neue Grundlagen und Themen hinzukommen, die im Anschluss vorausgesetzt und verwendet werden. Dann folgt der Teil »Aufstieg«. Dort beschäftigen wir uns mit leicht fortgeschrittenen Themen. Hier können Sie zwar nach Lust und Laune eins der Kapitel zur Lektüre auswählen, aber auch hier bauen einige Themen aufeinander auf. Der Teil »Praxisbeispiele« verdeutlicht die bisherigen Lerninhalte anhand von vereinfachten, didaktisch aufbereiteten Beispielen aus der Praxis. Hier haben Sie viel Spielraum zum Experimentieren und Einbringen eigener Ideen. Im Teil »Schlussgedanken« wird ein Ausblick gegeben, etwa auf Programmierstil und Testen. Das Buch endet dann mit einem Rückblick und Hinweisen für nächste Schritte.
Kapitel 1 – Einführung Dieses Kapitel gibt zunächst einen kurzen Überblick über Javas mittlerweile über 25-jährige Geschichte. Bevor wir dann mit dem Lernen von Java als Programmiersprache loslegen können, müssen wir ein paar Installationen vornehmen. Zum einen benötigen wir Java an sich und zum anderen wird eine IDE (Integrated Development Environment) im Verlauf des Buchs mit zunehmender Komplexität der Beispiele immer nützlicher.
Kapitel 2 – Schnelleinstieg Dieses Kapitel bietet einen Schnelleinstieg und stellt viele wesentliche Elemente von Java vor. Dabei nehmen wir ganz behutsam Fahrt auf: Wir beginnen mit einer einfachen Ausgabe eines Textes, ganz traditionell »Hello World«, und lernen dann, wie wir das mithilfe von Variablen variieren. Zudem schauen wir uns die bedingte Ausführung mit Fallunterscheidungen und Wiederholungen mit Schleifen an.
Kapitel 3 – Strings Strings sind aus kaum einem Programm wegzudenken. Variablen vom Typ String repräsentieren Zeichenketten und dienen zur Verwaltung von textuellen Informationen. In diesem Kapitel behandle ich die Thematik genauer.
Kapitel 4 – Arrays Ebenso wie Strings sind auch Arrays recht gebräuchliche Datenstrukturen und helfen dabei, mehrere gleichartige Dinge zu speichern, etwa eine Menge von Zahlen, Namen, Personen usw. Insbesondere bilden Arrays auch die Grundlage für viele andere Datenstrukturen. In diesem Kapitel lernen wir Arrays im Detail kennen.
Kapitel 5 – Klassen und Objektorientierung Immer wieder hört man, Java ist eine objektorientierte Sprache. Doch was bedeutet das? Zum Verständnis gibt dieses Kapitel einen Einblick in den objektorientierten Entwurf von Software. Dazu vermittle ich die grundlegenden Ideen von Zustand (Daten) in Kombination mit Verhalten (Funktionen auf diesen Daten) und wie man dies in Java formuliert.
Kapitel 6 – Collections Während Arrays ziemlich elementar sind, bieten die Collections oder Containerklassen mehr Flexibilität und Komfort bei der Verwaltung von Daten. In Java unterstützen die vordefinierten Listen, Mengen und Schlüssel-Wert-Abbildungen bei der Verwaltung anderer Objekte.
Kapitel 7 – Ergänzendes Wissen In diesem Kapitel werden verschiedene wichtige Themen angesprochen, die in den vorherigen Kapiteln aus didaktischen Gründen bewusst ausgelassen wurden. Warum? Deren Beschreibung erfordert mehr Wissen rund um Java, was Sie mittlerweile erworben haben – vorher wäre das Ganze aber zu tief in die Details gegangen und hätte zu viel anderes Wissen vorausgesetzt. Hier angelangt lohnt es sich aber, das bisherige Wissen etwa mit Informationen zu primitiven Typen, dem Ternary-Operator, Fallunterscheidungen mit switch usw. zu komplettieren.
Kapitel 8 – Mehr zu Klassen und Objektorientierung Die objektorientierte Programmierung ist ein vielschichtiges und umfangreiches Thema. Kapitel 5 hat eine Einführung geliefert. In diesem Kapitel wird Ihr Wissen noch ein wenig vertieft, beispielsweise zu Besonderheiten in Java, zu Vererbung und Polymorphie.
Kapitel 9 – Lambdas und Streams Dieses Kapitel stellt sowohl Lambda-Ausdrücke (kurz Lambdas) als auch das damit eng verbundene Stream-API vor. Beides sind essenzielle Bausteine von modernem Java und ermöglichen es, Lösungen oftmals elegant zu formulieren.
Kapitel 10 – Verarbeitung von Dateien Dieses Kapitel beschäftigt sich mit der Verarbeitung von Informationen aus Dateien. Dies ist für viele Anwendungen von großer Bedeutung, da diverse Informationen nicht nur während der Programmlaufzeit von Interesse sind, sondern vor allem auch darüber hinaus – denken Sie etwa an die Highscore-Liste Ihres Lieblingsspiels.
Kapitel 11 – Fehlerbehandlung mit Exceptions Sicher kennen Sie es: Manchmal tritt ein Programmfehler auf und das Programm stürzt ab. Wichtige Daten gehen mitunter verloren. So etwas ist immer ärgerlich. Daher gehört auch die Behandlung von Fehlern zum guten Ton beim Programmieren. Diese Kapitel führt in die Thematik ein.
Kapitel 12 – Datumsverarbeitung Während früher die Datumsverarbeitung eher stiefmütterlich in Java unterstützt wurde, bietet modernes Java mittlerweile eine Vielzahl praktischer Funktionalitäten zur Datumsverarbeitung, die in diesem Kapitel einführend dargestellt werden.
Kapitel 13 – Praxisbeispiel: Tic Tac Toe In diesem Kapitel entwickeln wir eine einfache Version des Strategiespiels Tic Tac Toe, das auf einem Spielfeld mit 3 × 3 Feldern gespielt wird. Dabei wird verdeutlicht, warum wir Programme sinnvoll in kleine Methodenbausteine untergliedern sollten.
Kapitel 14 – Praxisbeispiel: CSV-Highscore-Liste einlesen In diesem Kapitel verdeutlicht ein weiteres Praxisbeispiel die Verarbeitung von Dateien und kommaseparierter Daten, auch CSV (Comma Separated Values) genannt. Um das Ganze unterhaltsam zu gestalten, werden wir statt trockener Anwendungsdaten eine Liste von Spielständen als Eingabe nutzen.
Kapitel 15 – Praxisbeispiel: Worträtsel Dieses dritte Praxisbeispiel umfasst eine etwas komplexere Programmieraufgabe, nämlich die Erstellung von Worträtseln, die man aus Zeitschriften kennt. Dabei sollen aus einem scheinbaren »Buchstabensalat« verschiedene dort versteckte Begriffe extrahiert werden. Dieses Kapitel vermittelt, wie man Aufgaben in verschiedene kleine Problemstellungen untergliedert und diese jeweils mit eigenen Klassen realisieren kann. Schließlich ist es dann Aufgabe der eigentlichen Applikation, wie ein Dirigent zu wirken und die Einheiten passend zusammenzufügen. Dabei lernen wir beispielsweise den Import möglicher Wörter aus Dateien, die Modellierung des Rätsels und einen einfachen Export nach HTML kennen.
Kapitel 16 – Gute Angewohnheiten Dieses Kapitel stellt Ihnen ein paar Dinge zu gutem Programmierstil vor. Das mündet dann in sogenannten Coding Conventions, also Regeln beim Programmieren. Außerdem zeige ich noch, wie sich einige davon mit Tools prüfen lassen und wie man Programme mit JUnit 5 testen und dadurch Fehler vermeiden kann.
Kapitel 17 – Schlusswort Hier rekapitulieren wir kurz, was Sie durch die Lektüre gelernt haben sollten und wie Sie möglicherweise weitermachen können.
Anhang A – Schlüsselwörter im Überblick In Java existiert eine Reihe von Schlüsselwörtern, die reserviert sind und nicht als Bezeichner für Variablen, Methoden, Klassen oder anderes verwendet werden dürfen. Hier erhalten Sie einen Überblick.
Anhang B – Schnelleinstieg JShell In diesem Buch werden diverse Beispiele direkt auf der Konsole ausprobiert. Der Grund ist vor allem, dass Java seit Version 9 die interaktive Kommandozeilenapplikation JShell als REPL (Read-Eval-Print-Loop) bietet, die in den letzten Java-Versionen immer komfortabler geworden ist.
Anhang C – Grundlagen zur JVM und Infos zum Java-Ökosystem In diesem Anhang vermittle ich vertiefendes Grundwissen zur JVM (Java Virtual Machine). Zudem beleuchte ich kurz das breitgefächerte Ökosystem rund um Java.
Ich hatte schon angedeutet, dass es zum Erlernen des Programmierens ziemlich hilfreich ist, die Beispiele und Codeschnipsel auch auszuprobieren und abzutippen. Um Ihnen ein wenig Tipparbeit und Mühe zu ersparen, finden Sie viele der Beispiele als Programme in einem Eclipse-Projekt. Dieses steht unter www.dpunkt.de/Einfach-Java zur Verfügung. Weitere Informationen zum genauen Vorgehen finden Sie auf der Download-Seite.
Blockkommentare in Listings Beachten Sie bitte, dass sich in einigen Listings mitunter Blockkommentare (hier fett markiert) finden, die der Orientierung und dem besseren Verständnis dienen. In der Praxis sollte man derartige Kommentierungen mit Bedacht einsetzen und lieber einzelne Sourcecode-Abschnitte in Methoden auslagern, wie dies später im Rahmen der Praxisbeispiele offensichtlich wird. Für diverse Beispiele dieses Buchs dienen diese Kommentare aber als Anhaltspunkte, weil die eingeführten oder dargestellten Sachverhalte für Sie als Leser vermutlich noch neu und ungewohnt sind.
public static void main(String[] args) throws InterruptedException,
IOException
{
// Prozess erzeugen
String command = "sleep 60s";
Process sleeper = Runtime.getRuntime().exec(command);
...
// Process => ProcessHandle
ProcessHandle sleeperHandle = ...
...
}
In diesem Buch gelten folgende Konventionen bezüglich der Schriftart: Neben der vorliegenden Schriftart sind wichtige Textpassagen kursiv oder kursiv und fett markiert. Englische Fachbegriffe werden eingedeutscht großgeschrieben, etwa Event Handling. Zusammensetzungen aus englischen und deutschen (oder eingedeutschten) Begriffen werden mit Bindestrich verbunden, z. B. Plugin-Manager. Listings mit Sourcecode sind in der Schrift Courier gesetzt, um zu verdeutlichen, dass dies einen Ausschnitt aus einem Java-Programm darstellt. Auch im normalen Text wird für Klassen, Methoden, Konstanten und Parameter diese Schriftart genutzt.
Im Text beschriebene Methodenaufrufe enthalten in der Regel die Typen der Übergabeparameter, etwa substring(int, int). Sind die Parameter in einem Kontext nicht entscheidend, wird mitunter auf deren Angabe aus Gründen der besseren Lesbarkeit verzichtet.
Im Buch verwende ich die in der nachfolgenden Tabelle aufgelisteten Abkürzungen. Weitere Abkürzungen werden im laufenden Text in Klammern nach ihrer ersten Definition aufgeführt und anschließend bei Bedarf genutzt.
Abkürzung |
Bedeutung |
API |
Application Programming Interface |
ASCII |
American Standard Code for Information Interchange |
IDE |
Integrated Development Environment |
JDK |
Java Development Kit |
JEP |
JDK Enhancement Proposal |
JLS |
Java Language Specification |
JRE |
Java Runtime Environment |
JVM |
Java Virtual Machine |
Nahezu alle Beispiele wurden mit Java 16 entwickelt und ausprobiert. Für dieses Buch sind die brandaktuellen Java-Features zwar von Interesse, aber nicht von entscheidender Bedeutung, da es ja um die Grundlagen der Sprache geht. Deswegen basieren die meisten Programme auf Java 11, das zudem im Sommer 2021 die aktuelle LTS-Version (Long Term Support) ist. Die neueren Java-Versionen offerieren jedoch einige hilfreiche Syntaxänderungen und API-Erweiterungen. Daher beschreibe und verwende ich diese, wo es sinnvoll ist und das Verständnis erleichtert. In einem Abschnitt werden sogar Neuerungen aus dem im September 2021 erscheinenden Java 17 im Bereich von switch vorgestellt.
Somit sind Sie nach der Lektüre dieses Buchs bestens gerüstet für modernes Java und können nach Lust und Laune die neuen Features in eigenen Experimenten und Hobbyprojekten einsetzen.
Wie schon bei einigen meiner bisherigen Bücher hat mich auch diesmal Michael Kulla wieder ganz besonders unterstützt, wie üblich breitgefächert vom Aufdecken von Tippfehlern bis hin zu diversen inhaltlichen Hinweisen. Das gilt ebenfalls für Prof. Dr. Dominik Gruntz. Er hat wie gewohnt mit Spürsinn gelesen und eine Vielzahl an hilfreichen Anmerkungen hinterlassen. Auch Jean-Claude Brantschen trug mit seinen Kommentaren und Tipps zur Verbesserung bei. Außerdem gilt Christian Heitzmann ein herzlicher Dank für diverse Anregungen zum Inhalt, zur Struktur sowie zu Begrifflichkeiten. Schließlich hat Maria Herdt freundlicherweise durch einen kritischen Blick auf einige Kapitel ein paar Verbesserungen aufzeigen können. Nochmals vielen Dank an euch alle!
Zunächst geht ein Dankeschön an das Team des dpunkt.verlags (Dr. Michael Barabas, Anja Weimer, Stefanie Weidner und Veronika Schnabel) für die tolle Zusammenarbeit. Außerdem möchte ich mich bei Torsten Horn für die fundierte fachliche Durchsicht sowie bei Ursula Zimpfer für ihre Adleraugen beim Copy-Editing bedanken.
Abschließend geht ein lieber Dank an meine Frau Lilija für ihr Verständnis und die Unterstützung. Ihren ganz besonderen Anteil hat unser kleiner Sonnenschein Sophie Jelena dazu beigetragen, indem sie den Papa immer wieder zum Lachen gebracht hat.
Trotz großer Sorgfalt und mehrfachen Korrekturlesens lassen sich missverständliche Formulierungen oder teilweise sogar Fehler leider nicht vollständig ausschließen. Falls Ihnen etwas Derartiges auffallen sollte, so zögern Sie bitte nicht, mir dies mitzuteilen. Gerne nehme ich auch Anregungen oder Verbesserungsvorschläge entgegen. Kontaktieren Sie mich bitte per Mail unter:
michael_inden@hotmail.com
Zürich, im Juli 2021
Michael Inden
Java wurde Mitte der 1990er-Jahre von der Firma Sun entwickelt und später von Oracle übernommen. Mittlerweile hat Java zwar schon mehr als 25 Jahre auf dem Buckel, wird aber nicht altersschwach, sondern kontinuierlich gepflegt und besitzt ein extrem breitgefächertes und professionelles Angebot an externen Bibliotheken und Entwicklungstools. Insbesondere gibt es mit Eclipse, IntelliJ IDEA und NetBeans sowie Visual Studio Code mehrere hervorragende sogenannte IDEs (Integrated Development Environments) zum komfortablen Programmieren.
Java eignet sich zur Entwicklung unterschiedlichster Applikationen, etwa für Businessapplikationen, Webapplikationen und sogar einige (einfachere) Datenbanken. Es wird aber auch im Bereich Mobile in Form von Android-Apps oder gar im Bereich von Spielen, z. B. Minecraft, verwendet. Java ist also eine vielseitige Programmiersprache mit breitem Einsatzspektrum. Ein guter Grund, sich damit ein wenig zu beschäftigen.
Außerdem ist Programmieren ein wunderbares Hobby sowie ein faszinierender Beruf und es macht zudem noch jede Menge Spaß, fördert die Kreativität und den Gestaltungswillen.
Darüber hinaus ist Java laut TIOBE-Index1 seit Jahren eine der populärsten Programmiersprachen. Eine wichtige Rolle spielte vermutlich lange die freie Verfügbarkeit. Zumindest für die Originalvariante von Oracle gilt das mittlerweile nur noch für private, nicht kommerzielle Zwecke. Praktischerweise existieren inzwischen einige frei verwendbare Alternativen wie etwa das AdoptOpenJDK2. Zudem ist Java recht einfach zu erlernen (schwieriger als Python, aber deutlich leichter als C++) und bietet ein großes Ökosystem an Tools, Bibliotheken und Literatur sowie Hilfestellungen wie StackOverflow im Internet. Weiterhin zeichnet sich Java durch seine gute Performance aus. Das Ganze ist die Folge von jahrelangen Optimierungen und Verbesserungen. Dadurch ist die Ausführung von Java beispielsweise nur geringfügig langsamer als die von C++, aber um Längen schneller als die Ausführung von Python. Schließlich ermöglicht Java sowohl die objektorientierte als auch die funktionale Programmierung, sodass man je nach Einsatzzweck geeignet wählen kann.
Wie Sie sehen, sprechen viele gute Gründe für einen Einstieg in die Programmierung mit Java. Das Wichtigste ist jedoch der Spaß am Programmieren, Tüfteln und Ausprobieren. Lassen Sie uns starten!
Java als Programmiersprache besitzt wie eine natürliche Sprache auch eine Grammatik und feststehende Begriffe / Wörter. Man spricht dabei von Syntax und Schlüsselwörtern (vgl. Anhang A).
Java-Programme werden textuell verfasst. Das wird Sourcecode genannt. Schauen wir uns zum Einstieg ein einfaches Java-Programm an:
public class MyFirstJavaProgram
{
public static void main(String[] args)
{
System.out.println("Hello World");
}
}
Keine Sorge, Sie müssen das Ganze noch nicht vollständig verstehen, wir werden das alles Stück für Stück erlernen. Hier ist zunächst nur wichtig, dass Sie elementare Bestandteile von Java-Programmen grob einordnen können. Dazu gehören die Schlüsselwörter, also Java-Befehle oder -Anweisungen, hier etwa public, class, static und void. Wie die Begriffe in einer Sprache tragen diese reservierten Wörter eine besondere Bedeutung, ganz analog etwa zu Auto, Haus, Tür usw. im Deutschen.
Ebenso wie im Deutschen können (oder besser sollten) die Begriffe nicht einfach wahllos miteinander verknüpft werden, um einen gültigen Satz zu formulieren. Das wird durch die Grammatik geregelt. Auch in Java existiert eine solche. Damit wird etwa festgelegt, dass es static void, aber nicht void static heißen muss.
Zudem sehen wir geschweifte Klammern. Diese kann man sich wie Absätze in einem Text vorstellen. In Java bündeln diese Klammern Anweisungen. Man spricht dann auch von Blöcken und Sichtbarkeitsbereichen.
Genug der Vielzahl an Informationen. Nachfolgend werden wir die Dinge schön gründlich und detailliert besprechen und didaktisch immer ein neues Themengebiet ergründen, bis wir schließlich einen guten Einstieg in die Java-Programmierung vollzogen haben werden.
Vorab wollen wir aber erst einmal Java und Eclipse installieren und erste Schritte machen, um für unsere weitere Entdeckungsreise bereit zu sein.
Im ersten Teil dieses Buchs wird ein Hands-on-Ansatz verfolgt, bei dem wir Dinge oftmals in Form kleinerer Java-Codeschnipsel direkt ausprobieren. Sie benötigen vorab keine tiefgreifenden Programmiererfahrungen, allerdings schaden diese natürlich nicht, ganz im Gegenteil. Hilfreich wäre allerdings, wenn Sie sich einigermaßen mit dem Installieren von Programmen und grundlegend mit der Kommandozeile auskennen.
Damit Sie die nachfolgend beschriebenen Java-Programme ausführen können, benötigen Sie ein sogenanntes JDK (Java Development Kit). Dort finden sich alle für den Moment benötigten Tools. Beginnen wir also mit der Installation von Java.
Die aktuelle Java-Version ist frei auf der folgenden Oracle-Webseite verfügbar: http://www.oracle.com/technetwork/java/javase/downloads/index.html
Abbildung 1-1 Oracle-Seite für Java
Nachdem Sie auf den Link zum JDK-Download geklickt haben, erscheint in etwa eine Darstellung wie die folgende:
Abbildung 1-2 Java-Download-Seite
Im oberen Bereich sehen wir einige Hinweise zur neuen Lizenzpolitik, die ich nachfolgend im Hinweiskasten thematisiere. Im unteren Bereich finden Sie verschiedene Links für unterschiedliche Betriebssysteme. Wählen Sie den für Sie passenden Link.
Wenn Sie Ihre Software kommerziell vertreiben oder dies planen, dann sollten Sie beim Herunterladen von Java unbedingt die Lizenzpolitik von Oracle beachten: Das bis Java 8 selbst in Produktionssystemen immer kostenfrei verwendbare Oracle JDK ist dafür nun leider kostenpflichtig. Als Alternative können Sie auf das OpenJDK (https://openjdk.java.net/) ausweichen. Für dieses Buch das Wichtigste: Für private Projekte und während der Entwicklung kann das Oracle JDK weiterhin kostenfrei genutzt werden.
Unter MacOS doppelklicken Sie auf die .dmg-Datei, um die Installationsdatei zu starten, und folgen den Aufforderungen. Möglicherweise müssen Sie das Administrator-Passwort eingeben, um fortzufahren. Nachdem die Installation abgeschlossen ist, können Sie die .dmg-Datei löschen, um Speicherplatz zu sparen.
Für Windows doppelklicken Sie bitte auf die .exe-Datei. Auch diese kann nach erfolgreicher Installation gelöscht werden. Führen Sie also das heruntergeladene Installationsprogramm aus (z. B. jdk-16.0.1_windows-x64_bin.exe). Damit wird Java installiert – standardmäßig ins Verzeichnis C:\Programme\Java\jdk-16.0.1, wobei der Verzeichnisname von der gewählten Version abhängt. Akzeptieren Sie die Standardeinstellungen und befolgen Sie die Anweisungen während der Installation.
Damit Java bei Ihnen nach dem Download und der Installation auch in der Konsole korrekt funktioniert, sind noch ein paar Nacharbeiten nötig. Dazu müssen wir es zur leichteren Handhabung in den Pfad aufnehmen. Dies wird im Anschluss für die weitverbreiteten Betriebssysteme Windows und MacOS beschrieben. Falls Sie ein Unix-Derivat nutzen, dann finden Sie weitere Informationen auf dieser Seite: https://www.java.com/de/download/help/download_options.html. Für Windows und Mac gibt es dort auch noch einige ergänzende Informationen.
Das Installationsverzeichnis muss in die Umgebungsvariable PATH aufgenommen werden. Diese können Sie unter »Umgebungsvariablen« ändern. Drücken Sie die Win-Taste und geben Sie dann »umgeb« ein, bis »Systemumgebungsvariablen bearbeiten« erscheint. Mit Enter erscheint der Dialog »Systemvariablen«. Klicken Sie auf den Button »Bearbeiten« zum Öffnen eines Bearbeitungsdialogs. Fügen Sie in der Liste das Installationsverzeichnis gefolgt von bin, etwa C:\Programme\Java\jdk-16.0.1\bin, hinzu. Um nicht den gesamten Pfad eingeben zu müssen, bietet es sich an, eine weitere Umgebungsvariable namens JAVA_HOME anzulegen.
Abbildung 1-3 Umgebungsvariablen bearbeiten
Außerdem sollte der Eintrag möglichst ganz oben stehen:
Abbildung 1-4 Umgebungsvariablen ordnen
Beachten Sie bitte noch Folgendes: Bestätigen Sie die gesamten Dialoge bitte immer mit OK, sodass die Variablen gesetzt sind. Eventuell geöffnete Konsolen müssen geschlossen und neu geöffnet werden, um die geänderten Variablen wirksam werden zu lassen.
Auch unter MacOS empfiehlt es sich, einen Verweis auf Java im Pfad in der jeweiligen Shell (dem Terminal) passend zu setzen.
export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-16.jdk/Contents/Home
export PATH=$JAVA_HOME/bin:$PATH
Nach dem Ausführen der obigen Schritte sollte Java auf Ihrem Rechner installiert und von der Konsole startbar sein und Sie damit bereit für die nächsten Schritte.
Öffnen Sie eine Konsole und geben Sie folgendes Kommando ein – im folgenden Text nutze ich immer $ zur Kennzeichnung von Eingaben auf der Konsole, also dem Terminal bei MacOS bzw. der Windows-Eingabeaufforderung:
$ java --version
java 16 2021-03-16
Java(TM) SE Runtime Environment (build 16+36-2231)
Java HotSpot(TM) 64-Bit Server VM (build 16+36-2231, mixed mode, sharing)
Prüfen Sie der Vollständigkeit halber bitte auch noch den Aufruf sowie das Beenden des Tools JShell, das wir für den ersten Teil des Buchs intensiv nutzen werden:
$ jshell
| Welcome to JShell -- Version 16
| For an introduction type: /help intro
jshell> /exit
| Goodbye
Wenn die Programme bzw. Tools starten und Sie ähnliche Meldungen erhalten (möglicherweise mit kleinen Abweichungen bei den Versionsangaben), so können wir uns auf die Entdeckungsreise zur Java-Programmierung machen.
Zum Schreiben von umfangreicheren Java-Programmen (also zum Bearbeiten von viel Sourcecode) empfehle ich den Einsatz einer IDE anstelle von Texteditoren oder anstatt rein auf der Konsole in der JShell zu arbeiten. Für kleine Experimente ist aber gerade die JShell ein wunderbares Hilfsmittel.
Für Änderungen an größeren Java-Programmen kann man zwar auch mal einen Texteditor nutzen, aber dieser bietet nicht die Annehmlichkeiten einer IDE: In IDEs laufen verschiedene Aktionen und Sourcecode-Analysen automatisch und im Hintergrund ab, wodurch gewisse Softwaredefekte direkt noch während des Editierens erkannt und angezeigt werden können, etwa in einer To-do-/Task-Liste. IDEs bereiten zudem vielfältige Informationen auf. Weiterhin werden diverse Annehmlichkeiten wie Quick Fixes zur Korrektur kleinerer Probleme sowie automatische Transformationen und Änderungen von Sourcecode, sogenannte Refactorings, unterstützt.
Für Java existieren verschiedene IDEs. Sowohl Eclipse als auch NetBeans sind kostenlos. In den letzten Monaten wird auch das frei verfügbare Visual Studio Code von Microsoft immer populärer. Schließlich gibt es IntelliJ IDEA als kostenlose Community Edition sowie als kostenpflichtige Ultimate Edition. Alle IDEs haben ihre speziellen Vorzüge, aber auch (kleinere) Schwächen.
Für dieses Buch werden wir Eclipse nutzen. Wenn Sie bereits etwas Erfahrung haben, dann sind Sie natürlich frei, sich die anderen IDEs anzuschauen und auszuprobieren. Vieles geht über persönliche Präferenzen. Entscheiden Sie also später selbst und besuchen Sie dazu folgende Internetadressen:
www.eclipse.orgAbbildung 1-5