Einfach Java E-Book

Michael Inden

• Herausgeber: dpunkt.verlag
• Kategorie: Wissenschaft und neue Technologien
• Serie: Programmieren mit dpunkt
• Sprache: Deutsch
• Veröffentlichungsjahr: 2021

Seitenzahl: 466

Beschreibung

Java lernen – von Anfang an wie ein Experte

• Grundlagen der Java-Programmierung leicht und verständlich
• Java interaktiv im Selbststudium
• Aufgaben und Musterlösungen, Code zum Download

Sie wollen endlich Programmieren lernen und ihre ersten Projekte umsetzen? Dazu bietet sich Java als eine der populärsten Programmiersprachen geradezu an. Dieses Buch erleichtert Ihnen den Einstieg, denn Sie werden auf Ihrer Entdeckungsreise vom Java-Experten Michael Inden begleitet. Er erklärt Ihnen die Grundlagen der Java-Programmierung leicht und verständlich. Insbesondere wird die trockene Theorie auf ein Minimum reduziert und Sie legen immer mit kleinen Beispielen los.
Eine große Rolle dabei spielt der interaktive Einstieg mithilfe der JShell. Damit können kleine Programme direkt ausprobiert werden und Erfolgserlebnisse stellen sich schnell ein. Dieses Vorgehen eignet sich ideal, um im eigenen Tempo Java im Selbststudium zu erlernen. Allmählich werden sowohl die Themen anspruchsvoller als auch die zu erstellenden Programme größer. Als Hilfsmittel lernen Sie dann den Einsatz einer Entwicklungsumgebung sowie der objektorientierten Programmierung kennen. Mit den erlernten Grundlagen können Sie sich immer zielsicherer mit eigenen Projekten beschäftigen.
Das Buch besteht aus in sich abgeschlossenen, aber aufeinander aufbauenden Kapiteln zu den wichtigen Bereichen der Programmiersprache Java. Jedes Kapitel beschreibt die für den Einstieg wichtigen Sprachelemente.
Abgerundet werden viele Kapitel mit Aufgaben und Musterlösungen, sodass das zuvor Gelernte direkt anhand neuer Problemstellungen praktiziert und das Wissen vertieft werden kann. Auch lassen sich die eigenen Fortschritte abschätzen und gegebenenfalls eine Ehrenrunde zur Vertiefung des Wissens einlegen.
Zahlreiche kurze Codebeispiele verdeutlichen die Lerninhalte und laden oftmals zum Experimentieren ein. Gleich von Anfang an lernen Sie, ihren Sourcecode sauber zu strukturieren und einen guten Stil zu verfolgen.

Leseprobe

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

Michael Inden

Einfach Java

Gleich richtig programmieren lernen

Michael Inden

[email protected]

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: [email protected].

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

Inhaltsverzeichnis

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

Vorwort

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.

Zielgruppe

Dies ist ein Buch für Programmierneulinge. Es wendet sich somit an

Schüler und Schülerinnen, die ein paar Tipps und Hilfestellungen suchen, die das Nachvollziehen des Informatikunterrichts erleichtern,

Studierende, die ergänzende Erklärungen zu denen aus den Vorlesungen suchen, um Gelerntes schneller anwenden zu können oder besser für die nächste Prüfung vorbereitet zu sein,

und alle, die einfach die wunderbare und vielfältige Welt der Programmierung mit Java kennenlernen möchten.

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

einigermaßen fit im Installieren von Programmen sind und

die Kommandozeile grundlegend bedienen können.

Was vermittelt dieses Buch?

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.

Tipp: Praxistipp

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.

Aufbau dieses Buchs

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.

Einstieg

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.

Aufstieg

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.

Praxisbeispiele

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.

Schlussgedanken

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

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.

Sourcecode und ausführbare Programme

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.

Konventionen

Verwendete Zeichensätze

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.

Schreibweise von Methodenaufrufen

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.

Verwendete Abkürzungen

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

Verwendete Java-Version(en)

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.

Danksagung

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.

Anregungen und Kritik

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:

[email protected]

Zürich, im Juli 2021

Michael Inden

IEinstieg

1Einführung

1.1Java im Überblick

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!

Bestandteile von Java-Programmen

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.

1.2Los geht’s – Installation

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.

1.2.1Java-Download

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-1Oracle-Seite für Java

Nachdem Sie auf den Link zum JDK-Download geklickt haben, erscheint in etwa eine Darstellung wie die folgende:

Abbildung 1-2Java-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.

Hinweis: Neue Lizenzpolitik bei Oracle

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.

1.2.2Installation des JDKs

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.

1.2.3Nacharbeiten nach der Java-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.

Nacharbeiten für Windows

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-3Umgebungsvariablen bearbeiten

Außerdem sollte der Eintrag möglichst ganz oben stehen:

Abbildung 1-4Umgebungsvariablen 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.

Nacharbeiten für MacOS

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

1.2.4Java-Installation prüfen

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)

JShell prüfen

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.

1.3Entwicklungsumgebungen

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:

https://www.eclipse.org/

https://www.jetbrains.com/idea/

https://netbeans.apache.org/

https://code.visualstudio.com/

1.3.1Installation von Eclipse

Öffnen Sie einen Browser und gehen Sie auf die Seite www.eclipse.org. Diese präsentiert sich ähnlich zu Abbildung 1-5. Dort finden Sie oben rechts einen Download-Button, den Sie bitte drücken.

Abbildung 1-5Eclipse-Hauptseite zum Download

Dadurch wird die Download-Seite geöffnet. Dort sehen Sie verschiedene Möglichkeiten, bitte klicken Sie auf »Download Packages«.

Abbildung 1-6Eclipse-Installation »Download Packages«

Nun sollte sich die Seite mit den verfügbaren Packages öffnen. Diese sieht ähnlich zu Abbildung 1-7 aus. Dort wählen Sie abhängig von Ihrem Betriebssystem die passende Version und klicken diese zum Download an.

Abbildung 1-7Betriebssystemspezifische Eclipse-Versionen

Nachdem der Download abgeschlossen ist, entpacken oder starten Sie bitte das heruntergeladene ZIP, DMG oder die Datei im jeweiligen Linux-Format. Im Fall von Windows müssen Sie das entpackte Archiv noch in Ihren Programme-Ordner kopieren.

Auf der gezeigten Webseite wird der Eclipse Installer in einem Kasten angepriesen. Dieser ist sicher eine gute Alternative.

1.3.2Eclipse starten

Nach den beschriebenen Installationsschritten sollte Ihnen nun Eclipse als Programm im Start-Menü bzw. der Programmauswahl zur Verfügung stehen. Starten Sie es bitte, etwa durch einen Doppelklick auf das Programm-Icon.

Bei MacOS erhalten Sie gegebenenfalls noch einen Warnhinweis, dass es sich um ein aus dem Internet heruntergeladenes Programm handelt. Dies können Sie ignorieren und durch einen Klick auf Öffnen fortfahren.

Abbildung 1-8Warnmeldung (MacOS)

Als Nächstes wird ein Dialog angezeigt, um das Hauptverzeichnis für Ihre Projekte festzulegen. Sie können hier den Standard akzeptieren und ein Klick auf »Launch« startet dann Eclipse.

Abbildung 1-9Hauptverzeichnis festlegen

Nun öffnet sich der Startbildschirm von Eclipse, der sich je nach Version leicht unterschiedlich präsentiert.

Möglicherweise erscheint folgendes Bild, wobei Sie mit einem Klick auf »Hide« dann auf dem Hauptbildschirm landen.

Abbildung 1-10Startbildschirm von Eclipse

Der Hauptbildschirm präsentiert Ihnen verschiedene Möglichkeiten, um neue Projekte anzulegen oder bestehende zu importieren.

Abbildung 1-11Hauptbildschirm

Das Importieren wird separat in der Beschreibung zum Download der Sourcen zu diesem Buch thematisiert. Wir schauen uns nachfolgend das Anlegen eines Projekts mitsamt einer einfachen Klasse sowie deren Start an.

1.3.3Erstes Projekt in Eclipse

Nun wollen wir uns dem Anlegen eines Projekts und einer ersten Klasse widmen, um die Abläufe exemplarisch einmal durchgespielt zu haben, die für spätere Aktionen notwendig sind. Generell können Sie viele der hier gezeigten Aktionen auch zum Nachvollziehen der für die JShell gezeigten Programmschnipsel nutzen – dann als Teil einer Klasse und deren main()-Methode.

Keine Sorge, Sie müssen diese Schritte nicht im Detail verstehen. Es baut sich aber ein erstes Verständnis auf, das sich dann weiter vertieft, wenn Sie dies häufiger machen.

Beginnen wir mit dem Anlegen eines Java-Projekts. Dazu dient ein Wizard, also eine geführte Abfolge von Dialogen. Zunächst wählen wir »Java Project« und klicken dann auf »Next«.

Abbildung 1-12Anlegen eines neuen Java-Projekts

Damit landen wir auf der nächsten Seite zum Anlegen eines Java-Projekts mitsamt der Eingabe des Namens sowie der Auswahl der passenden Java-Version – beides durch Pfeile gekennzeichnet.

Abbildung 1-13Dialog »New Java Project«

Danach wird ein Dialog angezeigt, um ein korrespondierendes Modul anzulegen. Das wollen wir nicht tun, somit geht es durch einen Klick auf »Don’t Create« weiter.

Abbildung 1-14Frage nach Modulerzeugung

Es erscheint abschließend die Frage, ob die Java-Perspektive geöffnet werden soll. Das ist praktisch, um gleich die nächsten Schritte ausführen zu können.

Abbildung 1-15Frage nach Öffnen der Java-Perspektive

1.3.4Erste Klasse in Eclipse

Unser erstes Java-Projekt ist jetzt angelegt und ist bereit, um mit Leben in Form von Klassen gefüllt zu werden. Ausgangspunkt zum Anlegen einer Klasse ist wieder die Baumdarstellung auf der rechten Seite im Package Explorer. Dort öffnen wir ein Kontextmenü und wählen den Eintrag New > Class.

Abbildung 1-16Kontextmenü zum Anlegen einer Klasse

Durch Auswahl im Kontextmenü öffnet sich folgender Dialog zum Erzeugen einer Klasse.

Abbildung 1-17Dialog »New Java Class«

Im Dialog muss man das gewünschte Package sowie den Klassennamen eingeben. Bei Bedarf kann man das Erzeugen einer main()-Methode per Checkbox aktivieren. Ein Klick auf »Finish« erzeugt schließlich eine neue Klasse.

Nachdem das Grundgerüst steht, können Sie dann den Sourcecode aus den Beispielen im Editor einfügen bzw. abtippen.

Abbildung 1-18Sourcecode editieren

Schließlich wollen Sie sicherlich das so entstandene Java-Programm auch einmal in Aktion erleben. Dazu benötigt es bekanntermaßen eine main()-Methode. Mithilfe des Kontextmenüs oder des grünen Knopfs mit weißem Play-Pfeil kann man dann die Ausführung starten.

Abbildung 1-19Programm ausführen

2Schnelleinstieg

2.1Hallo Welt (Hello World)

Wir beginnen das Kennenlernen von Java mit einem simplen Programm, nämlich wie traditionell in den allermeisten Büchern mit HelloWorld, der Ausgabe eines Grußes auf der Konsole. Das haben wir schon in etwas komplizierterer Form in der Einleitung gesehen. Wir wollen es aber weiter vereinfachen und damit unsere Entdeckungsreise starten.

Java bietet mittlerweile mit der JShell einen interaktiven Kommandozeileninterpreter, auch Read-Eval-Print-Loop (REPL) genannt. Das erleichtert das schrittweise Erlernen von Java, weil wir nicht gleich zu Beginn eine Vielzahl an Konzepten verstehen oder zumindest hinnehmen müssen. Als weiterer Vorteil wird uns eine Menge Tipparbeit erspart.

Die interaktive JShell erlaubt es uns, kleinere Java-Codeschnipsel auszuprobieren. Wir starten diese mit dem Kommando jshell wie folgt:

$ jshell

| Welcome to JShell -- Version 16

| For an introduction type: /help intro

jshell>

Neben dem Hinweis auf die Version zeigt der Prompt jshell> an, dass wir nun Java-Befehle eingeben können. Probieren wir es gleich einmal aus:

jshell> System.out.println("Hello World from JShell!")

Hello World from JShell!

Herzlichen Glückwunsch zur ersten Programmausgabe mit Java!

Wir verwenden dabei die später vorgestellten Klassen und Methoden. Hier dient die über System.out referenzierte Instanz der Klasse java.io.PrintStream dazu, Ausgaben auf der Konsole zu ermöglichen. Funktionalität wird durch sogenannte Methoden bereitgestellt, in diesem Fall durch die Methode mit dem Namen println(), der man in runden Klammern einen Text eingerahmt von Anführungszeichen übergibt. Im Beispiel sehen wir auch die sogenannte Punktnotation, die Zugriff auf Eigenschaften und Methoden ermöglicht. Aber keine Sorge, Sie müssen noch nicht alle Details verstehen – wir werden diese im Verlaufe dieses Buchs noch ausführlich besprechen. Jetzt geht es zunächst um die ersten Schritte und ein initiales Gespür. Laden Sie die Begleitsourcen herunter oder tippen Sie die einfachen Beispiele ab, und wenn Sie sich sicher fühlen, dann variieren Sie auch gerne ein wenig.

Wir haben bereits einen netten Gruß auf der Konsole ausgeben können. Das war schon ein recht guter Anfang. Allerdings wäre es etwas eintönig, nur Texte ohne Variation auszugeben. Um den Gruß anzupassen, lernen wir nun Variablen kennen.

2.2Variablen und Datentypen

Variablen dienen zum Speichern und Verwalten von Werten. Dabei gibt es unterschiedliche Typen (auch Datentypen genannt), etwa für Texte, Zahlen und Wahrheitswerte. Wir schauen uns dies zunächst einmal einführend an und erweitern dann unser Wissen Schritt für Schritt, beispielsweise um ergänzende Infos zu Wertebereichen oder Aktionen mit den Variablen. Zum Einstieg betrachten und nutzen wir folgende Typen:

String

– Speichert textuelle Informationen, wie z. B. "Hallo". String-Werte sind von doppelten Anführungszeichen eingeschlossen.

char

– Speichert einzelne Zeichen, wie z. B. 'a' oder 'B'. Zeichenwerte sind von einfachen Anführungszeichen eingeschlossen.

int

und

long

– Speichern Ganzzahlen wie 123 oder -4711. Für

int

geht der Wertebereich von etwa -2 Milliarden bis 2 Milliarden, für

long

ist er noch viel größer.

float

und

double

– Speichern Gleitkommazahlen (mit Vorkomma- und Nachkommastellen), wie 72,71 oder -1,357. Achtung: Weil Java dem amerikanischen Sprachraum entstammt, werden als Dezimaltrenner Punkte statt Kommata verwendet. Somit muss es im Java-Programm

72.71

und

-1.357

heißen. Der Typ

float

besitzt eine geringere Genauigkeit und kann somit weniger Nachkommastellen als der Typ

double

verwalten.

boolean

– Speichert Wahrheitswerte als wahr oder falsch. In Java sind diese als

true

oder

false

repräsentiert.

2.2.1Definition von Variablen

In Java erzeugen wir eine Variable, indem wir zunächst den Typ, dann einen Namen sowie eine Wertzuweisung nach folgendem Muster (Syntax genannt) angeben:

Man spricht in diesem Zusammenhang von der Definition. Eine solche Definition wie auch andere Anweisungen müssen in Java normalerweise mit einem Semikolon beendet werden. In der JShell ist dies oft optional und man kann das Ganze wie folgt schreiben:

Lassen Sie uns etwas experimentieren:

Die JShell beantwortet jede Definition einer Variablen mit einer Bestätigung, wobei zunächst der Variablenname, dann ==> und schließlich der Wert folgt. Für das Beispiel mit einer Million sehen wir die Angabe von Unterstrichen, die sich zur Separierung, hier von Tausendersegmenten, eignet. Zwar ist es oben nur angedeutet, aber einer Variablen kann durchaus mehrmals im Programmverlauf an unterschiedlicher Stelle ein anderer Wert zugewiesen werden.

Eine solche Variable wird auch bei dem kürzest möglichen Hello-World-Programm automatisch als unbenannte Variable $1 erzeugt:

jshell> "Shortest hello world ever"

$1 ==> "Shortest hello world ever"

Besonderer Typ String

Genau wie Zahlen kann man auch Strings mit + verbinden. Man spricht hier von Konkatenation. Als Folge entsteht ein neuer String.

Wie gezeigt, sind problemlos mehrere Konkatenationen möglich. Ebenso kann man einen Zahlenwert mit einem String verknüpfen:

Der Typ String unterscheidet sich von den anderen vorgestellten Typen dadurch, dass er neben + noch einige weitere spezifische Funktionalitäten bereitstellt. Dies werden wir uns genauer in Kapitel 3 anschauen.

Besonderheit beim Typ char

Der Typ char repräsentiert ein einzelnes Zeichen:

Interessanterweise lassen sich darauf auch mathematische Aktionen wie + und - ausführen, allerdings entsteht dann ein Zahlenwert vom Typ int. Mithilfe eines später vorgestellten sogenannten Casts kann man durch die Angabe von (char) vor einem Ausdruck diesen wieder in ein Zeichen wandeln:

jshell> character + 5

$34 ==> 70

jshell> (char)(character + 5)

$35 ==> 'F'

Typ-Kurzschreibweise var

Als Kurzschreibweise gibt es die sogenannte Local Variable Type Inference mit dem reservierten Wort var. Dieses kann man statt einer konkreten Typangabe nutzen, um sich etwas Tipparbeit zu sparen. Was bedeutet das genauer?

Zuvor haben wir zur Definition von Variablen folgende Syntax genutzt:

Alternativ können wir kürzer var statt des konkreten Typs schreiben:

Java selbst ist so schlau, festzustellen, was der genaue Typ ist. Bei längeren Typnamen wird der Sourcecode dadurch etwas kürzer und eventuell auch lesbarer:

Eine derart definierte Variable hat dann genau den von Java ermittelten Typ, also ist theAnswer vom Typ int und name vom Typ String.

An dem Beispiel möchte ich noch einmal explizit auf zwei Dinge eingehen: Zum einen ist es in der JShell oftmals möglich, auf ein Semikolon am Ende der Anweisungen zu verzichten. Hier wird zur Demonstration nur bei der Definition von PI (π) ein solches verwendet, nicht aber für die beiden anderen Definitionen. Zum anderen kann man zwar var statt int nutzen, aber dies ist nicht sinnvoll, da es genauso viele Zeichen sind und man somit nichts gewinnt.

Besonderheit Deklaration

Es ist möglich, Variablen ohne Wertzuweisung zu notieren, man spricht dabei von Deklarieren. Die Wertzuweisung erfolgt somit nicht direkt, sondern erst später im Ablauf – nachfolgend ist dies durch eine Konsolenausgabe als zwischenzeitliche Aktion angedeutet:

Oftmals ist eine Definition, also die Kombination aus Deklaration und direkter Wertzuweisung, zu bevorzugen, da sich dies klarer liest und Fehlverwendungen vorbeugt. Außerdem kann man bei einer Deklaration var nicht verwenden, weil ja die Wertangabe fehlt und somit der Typ nicht ermittelt werden kann.

Konstanten – finale Variablen

Mithilfe des Schlüsselworts final vor der Definition einer Variablen machen wir diese unveränderlich und erzeugen somit eine Konstante:

Tipp: Keine Konstanten in der JShell

2.2.2Bezeichner (Variablennamen)

Mittlerweile haben wir durch die Nutzung einiger Variablen schon ein besseres Verständnis für Java gewonnen. Ohne es explizit zu erwähnen, haben wir uns bei der Benennung von Variablen an ein paar Regeln gehalten. Zunächst einmal muss jede Variable (und auch die später vorgestellten Methoden und Klassen) durch einen eindeutigen Namen, auch Identifier oder Bezeichner genannt, gekennzeichnet werden.

Bei der Benennung sollte man folgende Regeln und Hinweise beachten:

Namen sollten mit einem Buchstaben beginnen

1

– Ziffern sind als erstes Zeichen eines Variablennamens nicht erlaubt.

Namen können danach aus einem beliebigen Mix aus Buchstaben (auch Umlauten), Ziffern, $ und _ bestehen, dürfen aber keine Leerzeichen enthalten.

Enthalten Namen mehrere Wörter, dann ist es guter Stil, die sogenannte CamelCaseSchreibweise zu verwenden. Bei dieser beginnt das erste Wort mit einem Kleinbuchstaben und danach startet jedes neue Wort mit einem Großbuchstaben, etwa

arrivalTime

,

estimatedDuration

,

shortDescription

.

Die Groß- und Kleinschreibung von Namen spielt eine Rolle:

arrivalTime

und

arrivaltime

bezeichnen unterschiedliche Variablen.

Namen dürfen nicht mit den in Java vordefinierten und im Anhang aufgelisteten Schlüsselwörtern übereinstimmen, demzufolge sind

public

,

class

oder

int

keine gültigen Namen für Variablen.

PublicTransport

,

classic

oder

Winter

hingegen sind erlaubt.

Übrigens spielt es für Java überhaupt keine Rolle, ob Sie sehr kurze (i, m, p), kryptische (dpy, mtr) oder aber gut verständliche Namen (daysPerYear, maxTableRows) nutzen. Für Sie und das Verständnis beim Nachvollziehen eines Java-Programms macht das aber einen himmelweiten Unterschied. Natürlich sind kurze Variablennamen wie etwa x und y zur Bezeichnung von Koordinaten vollkommen verständlich, aber was sagt beispielsweise ein einzelner Buchstabe m aus? Schauen wir uns ein Beispiel an, das Ihnen das Gesagte verdeutlichen soll:

Die letzten beiden Variablendefinitionen sind ziemlich ungünstig, da man sich beim Unterscheiden schwertut. Besäßen diese denselben Typ, so würde es vermutlich leicht zu Fehlverwendungen kommen.

Im Listing sehen wir sogenannte Kommentare. Damit kann man erklärende Zusatzinformationen hinterlegen. In diesem Fall werden mit // einzeilige Kommentare eingeleitet. Alles was nach dem // bis zum Ende der Zeile folgt, wird bei der Ausführung von Java ignoriert. Weitere Varianten von Kommentaren lernen wir später in Abschnitt 2.6 kennen.

2.3Operatoren im Überblick

Operatoren dienen dazu, Operationen zwischen Variablen und / oder Werten auszuführen. Selbst eine banale Addition ist ein Beispiel, nämlich für den Operator +. Das lässt sich wunderbar mit der JShell nachprüfen:

Generell bietet Java folgende Arten von Operatoren:

Arithmetische Operatoren

Zuweisungsoperatoren

Vergleichsoperatoren

Logische Operatoren

Bit-Operatoren

Die Bit-Operatoren sind nur für spezielle Anwendungsfälle von Relevanz und werden in diesem Buch nicht weiter behandelt.

2.3.1Arithmetische Operatoren

Arithmetische Operatoren sind uns größtenteils bereits aus der Schule bekannt. Diese beschreiben neben den Grundrechenarten Addition, Subtraktion, Multiplikation und Division noch die Modulo-Berechnung. Die folgende Tabelle bietet einen Überblick.

Tabelle 2-1Arithmetische Operatoren

Beispiele für Grundrechenarten

Betrachten wir einfache Beispiele für diese Operationen, exemplarisch für den Typ int – natürlich lassen sich diese Grundrechenarten für alle Zahlentypen ausführen:

Das Ergebnis der letzten beiden Berechnungen könnte überraschen. Überlegen wir kurz: In Java gelten genau wie in der Mathematik die Vorrangregeln, also Punkt- vor Strichrechnung und es kommt zu folgender Auswertung, die zudem noch zeigt, dass bei Ganzzahlen die Division keinen Rest liefert:

Rekapitulieren wir: Multiplikation und Division werden vor Addition oder Subtraktion ausgeführt. Möchte man die Reihenfolge steuern, kann man dies durch passende Klammerung erreichen:

Modulo-Operator

Schauen wir uns noch die Modulo-Berechnung an, die den Divisionsrest ermittelt:

jshell> 5 % 1

$1 ==> 0

jshell> 5 % 2

$2 ==> 1

jshell> 5 % 3

$3 ==> 2

jshell> 5 % 4

$4 ==> 1

jshell> 5 % 5

$5 ==> 0

Anstelle der hier gewählten Kurzform können wir natürlich auch erst Zahlen einer Variablen zuweisen und danach dann die Operationen ausführen:

Der Modulo-Operator arbeitet auch auf Gleitkommazahlen:

jshell> 5.5 % 2.5

$36 ==> 0.5

Spezialfälle für das Inkrement bzw. Dekrement

Es gibt zwei Spezialfälle für das Inkrement bzw. Dekrement, die jeweils als Prä- und Postvariante existieren. Um den Wert einer Variablen i um 1 zu erhöhen, schreiben wir also ++i oder i++ anstatt i + 1:

Aber Achtung, dabei gibt es eine Besonderheit. Wieso erhalten wir denn dort für k trotz der Erhöhung erneut den Wert 1 als Ergebnis? Das liegt daran, dass i++ zunächst den Originalwert von i zurückgibt und danach die Erhöhung erfolgt. Das war der Grund, warum wir oben zur Korrektur eine Klammerung genutzt haben.

Neben den gerade gezeigten Varianten ++i oder i++ gibt es auch noch das Gegenstück mit --i oder i-- anstatt i - 1.

Spezialfall: Division durch 0

Bislang haben wir einige Aufrufe kennengelernt. Bei der Division erinnern wir uns vielleicht an den Spezialfall der verbotenen Teilung durch 0. Das ist in der Mathematik nicht erlaubt bzw. liefert den Wert ∞ (unendlich). Mit diesem Wert kann man aber nicht mehr weiter rechnen. Auch Java verbietet eine derartige Division und reagiert für Ganzzahlen darauf mit dem Auslösen einer ArithmeticException:

jshell> 7 / 0

| Exception java.lang.ArithmeticException: / by zero

Auf Fehlerbehandlungen und Exceptions im Speziellen gehe ich später in Kapitel 11 ein. Hier reicht zunächst das Wissen, dass nach einer solchen Fehlersituation die Ausführung eines Java-Programms gestoppt wird. In der JShell hingegen können Sie nach einem solchen Fehler problemlos weiterarbeiten und Kommandos eintippen.

Tipp: Besonderheit bei Gleitkommazahlen

Interessanterweise gibt es für Gleitkommazahlen spezielle Konstanten, wenn man durch 0 teilt:

jshell> 7.0 / 0.0

$15 ==> Infinity

jshell> 0.0 / 0.0

$16 ==> NaN

2.3.2Zuweisungsoperatoren

Nehmen wir nun die Variable x und die Wertzuweisung von 100 als Beispiel:

Um einen Wert, etwa 10, hinzuzufügen, können wir Folgendes schreiben:

Manchmal möchte man die Addition eines Werts kürzer notieren. Dazu existiert als Kurzform der Additionszuweisungsoperator +=:

jshell> x += 10

$118 ==> 120

jshell> x

x ==> 120

Neben += gibt es noch die praxisrelevanten Varianten -=, *=, /= und %=, die in der folgenden Tabelle aufgeführt sind und danach demonstriert werden.

Tabelle 2-2Zuweisungsoperatoren

Schauen wir uns wieder eine Abfolge von Aktionen zur Verdeutlichung an – die JShell erzeugt dabei immer neben der Zuweisung an counter noch temporäre Variablen:

Hinweis: Weitere, weniger gebräuchliche Operatoren

Es gibt darüber hinaus noch die Kurzformen &=, |=,^=, >>= und <<=, die aber eher selten in der Praxis benötigt werden und daher hier nicht weiter besprochen werden.

2.3.3Vergleichsoperatoren

Aus der Mathematik kennen wir diverse Operatoren, um Werte miteinander zu vergleichen. Exakt so funktioniert das auch in Java, mit der Abweichung, dass diese einen Wahrheitswert, also den Wert true oder false vom Typ boolean, liefern.

Tabelle 2-3Vergleichsoperatoren

Schauen wir uns wieder eine Abfolge von Aktionen zur Verdeutlichung an:

Die JShell erzeugt dabei temporäre Variablen vom Typ boolean. Wir können das aber selbstverständlich auch explizit machen und basierend auf den Ergebnissen gewisse Aktionen ausführen. Dazu werden wir in Kürze Fallunterscheidungen und bedingte Ausführungen einsetzen.

2.3.4Logische Operatoren

Um einfache Bedingungen zu prüfen, haben wir gerade schon die Vergleichsoperatoren kennengelernt. Oftmals muss aber nicht nur eine, sondern es müssen mehrere Bedingungen erfüllt sein, oder eine aus mehreren. Mitunter muss auch die Bedingung invertiert werden. Mithilfe der logischen Operatoren kann man dies in Java formulieren. Die Operatoren && (AND) und || (OR) operieren auf zwei booleschen Werten (boolean), der Operator ! (NOT) auf einem.

Tabelle 2-4Logische Operatoren

Operator

Name

Beschreibung

&&

AND

true, wenn beide Bedingungen erfüllt sind

||

OR

true, wenn mindestens eine der Bedingungen erfüllt ist

!

NOT

true, wenn die Bedingung nicht erfüllt ist

Schauen wir uns wieder eine Abfolge von Aktionen zur Verdeutlichung an. Zunächst definieren wir zwei int-Variablen.

Auf ein Detail möchte ich noch eingehen: auf die Klammerung bei der Negation. Diese ist erforderlich, weil man ja die Prüfung, also einen booleschen Ausdruck, negieren möchte. Würde man das ! direkt an die Variable schreiben, also !points, wäre das nicht erlaubt, da der Operator ! für int-Werte nicht definiert ist. Dadurch erhielten wir folgende Fehlermeldung, die das zuvor Gesagte bestätigt:

jshell> !points > 500

| Error:

| bad operand type int for unary operator '!'

| !points > 500

| ^-----^

Mehrere Verknüpfungen Es lassen sich nicht nur einzelne Werte miteinander verknüpfen, sondern auch ganze Ausdrücke, z. B. zur Prüfung der Möglichkeit, ein weiteres Bier in einer Bar zu bestellen:

2.4Fallunterscheidungen

Unsere bisherigen kleinen Java-Experimente liefen alle von oben nach unten ab. In der Praxis muss man aber immer mal wieder gewisse Bedingungen prüfen, etwa ob eine Person älter als 18 Jahre ist oder ob die Bestellmenge größer als 100 ist und ein Rabatt gewährt wird. Zur Formulierung der Bedingungen haben wir gerade verschiedene Operatoren kennengelernt. Um abhängig von deren Auswertung einige Programmzeilen nur bedingt auszuführen, dazu dient die if-Anweisung. Abhängig vom positiven Ausgang der Auswertung werden die nachfolgenden Anweisungen ausgeführt. Um diese bedingt auszuführenden Anweisungen von den restlichen Anweisungen abzugrenzen, bedient man sich sogenannter Blöcke, die wir nun vorab kurz kennenlernen, bevor wir dann mit Fallunterscheidungen konkret weitermachen.

Wissenswertes zu Blöcken

Blöcke enthalten eine Folge von Anweisungen, die mit geschweiften Klammern eingerahmt sind und somit den Beginn und das Ende eines Blocks festlegen: