Skip to content

2. Einrichtung der Entwicklungsumgebung

Die Arbeitsumgebung von Java-Entwicklern besteht aus drei voneinander unabhängigen Komponenten:

  • dem JDK („Java Development Kit“): dem Compiler [javac], der virtuellen Maschine und dem Befehl [java], der Programme ausführt, den Standardbibliotheken von Java SE und Werkzeugen wie [jshell] oder [jar];
  • einem Build-Werkzeug für Projekte, hier Maven: Es lädt die Bibliotheken herunter, die ein Projekt benötigt, kompiliert es, führt seine Tests aus und paketiert es;
  • einem Editor oder einer IDE (Integrated Development Environment, integrierte Entwicklungsumgebung): [IntelliJ IDEA], [VS Code] mit Java-Erweiterungen oder [Eclipse]. Die IDE basiert auf dem JDK und kann Maven-Projekte lesen.

Dieses Dokument verwendet die Befehle [java], [javac] und [mvn] für alle Vorgänge: Sie funktionieren unter Windows, Linux und macOS auf dieselbe Weise, unabhängig vom gewählten Editor.

2.1. JDK 25

2.1.1. Installation

Es gibt mehrere Distributionen des JDK, die alle aus dem OpenJDK-Quellcode erstellt werden und für unsere Zwecke gleichwertig sind. Wir empfehlen Eclipse Temurin, eine freie Open-Source-Distribution der Eclipse Foundation, die Sie unter https://adoptium.net herunterladen können: Wählen Sie dort die Version 25 – LTS, das Betriebssystem und den Pakettyp (unter Windows ein [.msi]-Installer). Unter Windows können Sie es auch in einem Terminal (PowerShell oder Eingabeaufforderung) mit dem Paketmanager [winget] installieren:

winget install EclipseAdoptium.Temurin.25.JDK

Wählen Sie das JDK (das alles enthält) und nicht nur die JRE (die lediglich das Ausführen bereits kompilierter Programme erlaubt). Aktivieren Sie bei der Installation unter Windows die Optionen, die das JDK zu [PATH] hinzufügen und die Umgebungsvariable [JAVA_HOME] setzen: Maven und die IDEs verwenden sie, um das JDK zu finden. Unter Linux ist das JDK in den Repositories der großen Distributionen verfügbar (zum Beispiel [sudo apt install openjdk-25-jdk] unter Ubuntu).

Öffnen Sie nach der Installation ein neues Terminal, um zu prüfen, ob die Befehle [java] und [javac] verfügbar sind und die Version des JDK anzeigen:

1
2
3
4
5
6
> java --version
openjdk 25.0.4.1 2026-08-18
OpenJDK Runtime Environment (build 25.0.4.1+1-1-24.04.4-Ubuntu)
OpenJDK 64-Bit Server VM (build 25.0.4.1+1-1-24.04.4-Ubuntu, mixed mode, sharing)
> javac --version
javac 25.0.4.1

Diese Ergebnisse stammen vom JDK-Paket von Ubuntu. Bei Temurin steht in den Zeilen 2 und 3 [Temurin-25], und die genaue Version hängt vom Installationsdatum ab: Patch-Updates erscheinen vierteljährlich. Alle JDK-Versionen 25.0.x eignen sich für dieses Dokument. Mehrere JDKs können auf demselben System nebeneinander existieren: Das erste, das im Verzeichnis [PATH] gefunden wird, beantwortet den Befehl [java].

2.1.2. Befehle des JDK

Das JDK stellt zahlreiche Befehle bereit. Hier sind die, die wir verwenden werden:

Befehl
Rolle
[java File.java]
kompiliert ein in einer Quelldatei geschriebenes Programm im Speicher und führt es aus (Java 11; mehrere Dateien ab Java 22)
[javac -d classes File.java]
kompiliert eine oder mehrere Quelldateien und legt die entstandenen [.class]-Dateien im Ordner [classes] ab
[java -cp classes ClassName]
führt die Methode [main] einer kompilierten Klasse aus, die im Klassenpfad gesucht wird ([-cp])
[java -cp "lib/*" File.java]
führt eine Quelldatei aus, die die Bibliotheken ([.jar]-Dateien) im Ordner [lib] verwendet
[jshell]
Interaktiver Interpreter: Sie geben Java-Anweisungen ein und sehen sofort deren Ergebnisse
[jar]
erstellt oder liest ein [.jar]-Archiv (eine ZIP-Datei mit kompilierten Klassen)

Der Interpreter [jshell] (Java 9) ist nützlich, um eine Methode oder einen Ausdruck zu testen, ohne ein Programm zu schreiben:

> jshell
|  Welcome to JShell -- Version 25.0.4.1
|  For an introduction type: /help intro

jshell> 1 + 2
$1 ==> 3

jshell> var s = "Java " + 25
s ==> "Java 25"

jshell> s.length()
$3 ==> 7

jshell> /exit
|  Goodbye

2.2. Maven

2.2.1. Installation

Eine reale Java-Anwendung verwendet Bibliotheken, die nicht zum JDK gehören: einen Datenbanktreiber, ein Test-Framework, Hibernate, Spring … Sie werden als [.jar]-Archive über ein öffentliches Repository verteilt, Maven Central (https://central.sonatype.com). Ein Build-Werkzeug wie Maven liest die Datei [pom.xml] eines Projekts, um zu bestimmen, welche Bibliotheken es benötigt, lädt sie (samt den Bibliotheken, von denen sie abhängen) herunter und kompiliert, testet und paketiert anschließend das Projekt. Ein weiteres weit verbreitetes Werkzeug, Gradle, erfüllt dieselbe Aufgabe; dieses Dokument verwendet Maven.

Maven kann unter https://maven.apache.org/download.cgi als ZIP-Archiv heruntergeladen werden ([apache-maven-3.9.x-bin.zip]). Entpacken Sie es in einen Ordner, zum Beispiel [C:\Program Files\apache-maven-3.9.11], und fügen Sie dessen Unterordner [bin] zu [PATH] hinzu (Windows: „Systemumgebungsvariablen bearbeiten“). Unter Linux ist Maven in den Repositories der Distributionen verfügbar ([sudo apt install maven]). Prüfen Sie die Installation in einem neuen Terminal:

1
2
3
4
5
6
> mvn -v
Apache Maven 3.9.11 (3e54c93a704957b63ee3494413a2b544fd3d825b)
Maven home: /opt/maven
Java version: 25.0.4.1, vendor: Ubuntu, runtime: /usr/lib/jvm/java-25-openjdk-amd64
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "6.18.44-fc-v64", arch: "amd64", family: "unix"

Zeile 4 ist wichtig: Sie zeigt das von Maven verwendete JDK, auf das die Variable [JAVA_HOME] verweist. Es muss ein JDK 25 sein. Die IDEs IntelliJ IDEA und VS Code bringen ihr eigenes Maven mit: Das genügt, wenn Sie Maven nicht über die Befehlszeile verwenden.

Die von Maven heruntergeladenen Bibliotheken werden auf dem lokalen Rechner im lokalen Repository [%USERPROFILE%\.m2\repository] gespeichert (Linux, macOS: [~/.m2/repository]). Sie werden nur einmal heruntergeladen und dann von allen Projekten verwendet. Beim ersten Build eines Projekts ist daher eine Internetverbindung erforderlich.

2.2.2. Maven-Befehle

Auf den Befehl [mvn] folgen eine oder mehrere Phasen des Build-Zyklus oder ein Plugin-Goal; er wird in dem Ordner eingegeben, der die Datei [pom.xml] enthält:

Befehl
Rolle
[mvn compile]
kompiliert den Quellcode in [src/main/java]; die Klassen werden in [target/classes] abgelegt
[mvn test]
kompiliert und führt anschließend die Unit-Tests in [src/test/java] aus (Kapitel 6)
[mvn package]
kompiliert, testet und erstellt das Projektarchiv [.jar] in [target]
[mvn install]
wie [package], kopiert das Archiv anschließend in das lokale Repository, wo andere Projekte es verwenden können (Kapitel 6)
[mvn clean]
löscht den Ordner [target]
[mvn compile exec:java]
kompiliert und führt anschließend die Hauptklasse des Projekts aus (Plugin [exec-maven-plugin])
[mvn spring-boot:run]
startet eine Spring-Boot-Anwendung (Kapitel 13)

Die Phasen sind aufeinander aufgebaut: Die Ausführung von [package] löst auch [compile] und [test] aus. Die Option [-q] („quiet“) unterdrückt die Meldungen von Maven und zeigt nur die des ausgeführten Programms an; die Option [-Dexec.args="a b"] übergibt dem von [exec:java] gestarteten Programm Argumente.

2.3. Der Editor

2.3.1. IntelliJ IDEA

IntelliJ IDEA von der Firma JetBrains ist der am weitesten verbreitete Java-Editor. Seine Grundfunktionen, die für dieses Dokument mehr als ausreichen, sind kostenlos. Er unterstützt Maven-Projekte: Wählen Sie „File / Open“ und dann den Ordner mit der Datei [pom.xml]; IntelliJ lädt die Bibliotheken herunter, kompiliert das Projekt und erlaubt es, eine Klasse über das grüne Dreieck am Rand neben ihrer Methode [main] ([Ctrl-Shift-F10]) auszuführen oder einen Test über dasselbe Dreieck neben der Testmethode auszuführen. Das zu verwendende JDK legen Sie unter „File / Project Structure / SDK“ fest.

Sie können den gesamten Beispielordner [java-oct-2026] auf einmal öffnen („File / Open“): IntelliJ erkennt dort alle Maven-Projekte und zeigt sie in seinem Panel „Maven“ an. Eine Vorsichtsmaßnahme ist an dieser Stelle nötig. Die Projekte der Kapitel 10 bis 13 (Versionen 6 bis 9 der [Tax]-Anwendung) verwenden die Module [tax-dao], [tax-business] und [tax-ui] aus Version 5, die in Kapitel 6 geschrieben wurde. Dies sind keine öffentlichen Bibliotheken: Maven findet sie nur dann im lokalen Repository, wenn sie dort installiert wurden. Sie müssen daher zuerst Version 5 installieren: Erweitern Sie im Panel „Maven“ den Eintrag [tax-v5] / „Lifecycle“ und doppelklicken Sie auf [install] (oder geben Sie [mvn install] im Ordner [06-architectures/TaxV5] ein) und klicken Sie dann im Panel auf die Schaltfläche „Sync All Maven Projects“. Kapitel 6 erklärt, was dieser Befehl bewirkt und was zu tun ist, wenn IntelliJ weiterhin nicht aufgelöste Abhängigkeiten meldet.

2.3.2. VS Code

VS Code ist ein kostenloser, plattformübergreifender Editor. Um in Java zu programmieren, können Sie das Extension Pack for Java von Microsoft installieren (öffnen Sie das Menü „Extensions“ und suchen Sie nach „Extension Pack for Java“); es enthält Sprachunterstützung, einen Debugger, die Testausführung und Maven-Unterstützung. Damit erhalten Sie:

  • Syntaxhervorhebung, Codevervollständigung und Hilfe über Tooltips;
  • Fehlererkennung bereits während der Eingabe;
  • Codenavigation (F12: zur Definition springen);
  • Ausführung und Debugging (die Links „Run“ und „Debug“ über jeder Methode [main] oder F5);
  • Ausführung von Unit-Tests (die Ansicht „Testing“) und eine Ansicht „Maven“ der Projekte.

Öffnen Sie in VS Code den Ordner mit den Programmen („File / Open Folder“), zum Beispiel den Ordner [java-oct-2026] mit den Beispielen dieses Dokuments. Im integrierten Terminal („Terminal / New Terminal“) können Sie die Befehle [java] und [mvn] eingeben, ohne den Editor zu verlassen.

2.3.3. Eclipse

Eine dritte Möglichkeit ist die Open-Source-IDE Eclipse (https://eclipseide.org), historisch die erste große Java-IDE, die ebenfalls Maven-Projekte importiert („File / Import / Maven / Existing Maven Projects“).

Im weiteren Verlauf dieses Dokuments werden die Vorgänge mit den Befehlen [java], [javac] und [mvn] beschrieben, die unabhängig vom Editor dieselben Ergebnisse liefern.

2.4. Ein erstes Programm: eine kompakte Quelldatei

2.4.1. Das Programm

Ab Java 25 kann ein Java-Programm eine einfache Datei sein, die nur eine Methode [main] enthält, ohne Klassendeklaration. Man spricht von einer „kompakten Quelldatei“. Erstellen wir die folgende Datei [Hello.java]:

1
2
3
4
// erstes Java-Programm: eine kompakte Quelldatei
void main() {
    IO.println("1st try with Java 25");
}

und führen wir sie aus:

> java Hello.java
1st try with Java 25

Kommentare:

  • Zeile 1: ein Kommentar. Alles, was auf [//] bis zum Zeilenende folgt, wird vom Compiler ignoriert;
  • Zeile 2: die Methode [main], der Einstiegspunkt des Programms. In einer kompakten Quelldatei muss sie weder in einer Klasse deklariert noch [public] und [static] sein, und sie muss auch keine Programmargumente entgegennehmen; wir werden in Kapitel 3 sehen, dass der Compiler sie selbst in eine Klasse einbettet;
  • Zeile 3: die einzige Anweisung des Programms: Sie gibt eine Textzeile auf dem Bildschirm aus. Die Klasse [IO] (Java 25) stellt einfache Methoden zum Schreiben ([print], [println]) und zum Lesen von der Tastatur ([readln]) bereit;
  • der Befehl [java Hello.java] kompiliert das Programm im Speicher – ohne eine [.class]-Datei zu erzeugen – und führt es anschließend aus. Diese Möglichkeit, eine Quelldatei direkt auszuführen, wurde mit Java 11 eingeführt.

Der Dateiname muss ein gültiger Java-Bezeichner sein: [Hello.java] oder [Basics01.java] sind zulässig, [basics-01.java] dagegen wird vom Compiler abgelehnt ([bad file name]), weil der Dateiname zum Namen der erzeugten Klasse wird. Nach Konvention beginnen Klassennamen – und damit Dateinamen – mit einem Großbuchstaben.

Sie können das Programm auch mit [javac] kompilieren, was eine Datei mit der Endung [.class] erzeugt, und diese kompilierte Datei dann ausführen:

1
2
3
4
5
> javac -d classes Hello.java
> dir classes (list of files)
Hello.class
> java -cp classes Hello
1st try with Java 25

Die Datei [Hello.class] enthält den Bytecode der vom Compiler erzeugten Klasse [Hello]. Der Befehl [java -cp classes Hello] weist die virtuelle Maschine an, die Methode [main] der Klasse [Hello] auszuführen, die sich im Ordner [classes] befindet.

Kompakte Quelldateien eignen sich für kleine Programme, und wir verwenden sie für die meisten Beispiele. Benötigt ein Programm eine externe Bibliothek, lässt es sich trotzdem mit dem Befehl [java -cp "lib/*" Program.java] starten, wenn Sie die [.jar]-Archive der Bibliothek (und der Bibliotheken, von denen sie abhängt) in einen Ordner [lib] kopiert haben. Diese Archive von Hand zusammenzutragen, wird aber schnell mühsam; deshalb schreiben wir ein Maven-Projekt.

Unter Windows werden Umlaute und andere Sonderzeichen, die von [IO.println] oder [System.out.println] geschrieben werden, im Terminal korrekt angezeigt: Java wandelt den Text in die Kodierung des Terminals um. Die Quelldateien müssen in UTF-8 gespeichert werden, der Standardkodierung von VS Code und IntelliJ IDEA und derjenigen, die der Compiler seit Java 18 voraussetzt.

2.5. Ein Maven-Projekt

2.5.1. Projektstruktur

Ein Maven-Projekt ist ein Ordner, der eine Datei [pom.xml] („Project Object Model“) und nach einer Standard-Verzeichnisstruktur organisierte Quelldateien enthält. Das Projekt [FirstProgram] im Ordner [02-installation] sieht wie folgt aus:

1
2
3
4
5
6
7
FirstProgram/
├── pom.xml
└── src/
    └── main/
        └── java/
            └── first/
                └── Main.java
  • [src/main/java] enthält die Quelldateien des Programms; [src/main/resources] enthält die Daten- oder Konfigurationsdateien, die neben den kompilierten Klassen abgelegt werden; [src/test/java] enthält die Tests (Kapitel 6);
  • Unter [src/main/java] entspricht die Ordnerstruktur der der Pakete (Kapitel 4): Die Klasse [first.Main] befindet sich im Ordner [first].

Sie können diese Verzeichnisstruktur manuell anlegen oder von der IDE anlegen lassen (IntelliJ: „File / New / Project“, als Build-System „Maven“ auswählen). Die Datei [pom.xml] sieht wie folgt aus:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- die Projektkoordinaten -->
    <groupId>examples.installation</groupId>
    <artifactId>first-program</artifactId>
    <version>1.0</version>

    <properties>
        <!-- Ziel-Java-Version und Kodierung der Quelldateien -->
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <build>
        <plugins>
            <!-- der Compiler, mit allen Warnungen -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.15.0</version>
                <configuration>
                    <compilerArgs>
                        <arg>-Xlint:all</arg>
                    </compilerArgs>
                </configuration>
            </plugin>
            <!-- mvn exec:java führt die Hauptklasse aus -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <mainClass>first.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
  • Zeilen 8–10: die Koordinaten des Projekts, die es eindeutig identifizieren: die Gruppe ([groupId], oft ein umgekehrter Domainname wie [org.hibernate]), der Projektname ([artifactId]) und seine Version. Mit denselben Angaben verweist bei Bedarf ein anderes Projekt auf dieses, ähnlich wie auf eine Bibliothek aus Maven Central verwiesen wird (Kapitel 6);
  • Zeile 14: Der Code wird für Java 25 kompiliert;
  • Zeile 15: Die Quelldateien sind in UTF-8 geschrieben;
  • Zeilen 21–30: das Kompilierungs-Plugin mit der Option [-Xlint:all], die alle Compilerwarnungen aktiviert;
  • Zeilen 32–39: das Plugin [exec-maven-plugin], mit dem sich die Hauptklasse des Projekts – in Zeile 37 angegeben – über den Befehl [mvn exec:java] ausführen lässt.

Dieses Projekt verwendet keine Bibliotheken. Ein Projekt, das eine Bibliothek verwendet, deklariert sie anhand ihrer Koordinaten in einem Abschnitt [<dependencies>], wie wir es ab Kapitel 5 tun werden:

1
2
3
4
5
6
7
<dependencies>
    <dependency>
        <groupId>tools.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>3.1.5</version>
    </dependency>
</dependencies>

Die Datei [Main.java] enthält das Programm in seiner Standardform, mit einer Klasse [public] und einer Methode [public static void main(String[] args)]:

1
2
3
4
5
6
7
8
9
package first;

// das Hauptprogramm des Projekts [FirstProgram]
public class Main {

    public static void main(String[] args) {
        System.out.println("1st try with a Maven project / Java 25");
    }
}
  • Zeile 1: Die Klasse gehört zum Paket [first]; ihr vollständiger Name lautet [first.Main];
  • Zeilen 4–9: die Klasse [Main]. Eine Quelldatei enthält höchstens eine öffentliche Klasse, die den Namen der Datei trägt;
  • Zeilen 6–8: die Methode [main] in der Form, die sie seit der ersten Java-Version hat. Beide Formen vergleichen wir in Kapitel 3.

2.5.2. Kompilierung und Ausführung

Der Befehl [mvn compile], im Projektordner eingegeben, kompiliert das Projekt: Maven lädt bei Bedarf die erforderlichen Plugins herunter, kompiliert dann die Dateien in [src/main/java] und legt die entstandenen Klassen unter Beibehaltung der Pakethierarchie im Ordner [target/classes] ab ([target/classes/first/Main.class]). Der Befehl [mvn compile exec:java] kompiliert das Projekt und führt es anschließend aus; mit der Option [-q] wird nur die Ausgabe des Programms angezeigt:

> mvn -q compile exec:java
1st try with a Maven project / Java 25

Sobald das Projekt kompiliert ist, können Sie die Klasse auch direkt mit dem Befehl [java] ausführen und dabei den Speicherort der Klassen angeben:

> java -cp target/classes first.Main
1st try with a Maven project / Java 25

Der Ordner [target] kann bedenkenlos gelöscht werden ([mvn clean]): Er wird bei der nächsten Kompilierung neu angelegt. Der Befehl [mvn package] erzeugt außerdem das Archiv [target/first-program-1.0.jar], das sich mit [java -cp target/first-program-1.0.jar first.Main] ausführen lässt: In diesem Format wird ein Java-Programm ausgeliefert.

2.6. Ein Projekt mit mehreren Modulen

2.6.1. Das Aggregator-Projekt

Ein Maven-Projekt kann mehrere andere Projekte zusammenfassen, die man seine Module nennt. Der Ordner [02-installation] enthält eine Datei [pom.xml], die seine beiden Projekte zusammenfasst:

<?xml version="1.0" encoding="UTF-8"?>
<!-- ein „Aggregator"-Projekt: Es fasst die Projekte des Ordners zusammen, um sie gemeinsam zu bauen -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>examples.installation</groupId>
    <artifactId>installation</artifactId>
    <version>1.0</version>
    <packaging>pom</packaging>

    <modules>
        <module>FirstProgram</module>
        <module>TwoHands</module>
    </modules>
</project>
  • Zeile 11: Dieses Projekt erzeugt kein [.jar]-Archiv: Es dient nur dazu, andere Projekte zusammenzufassen ([pom]);
  • Zeilen 13–16: die Module, identifiziert über ihre Ordnernamen.

Im Ordner [02-installation] kompiliert der Befehl [mvn compile] beide Projekte; eine IDE, die diesen Ordner öffnet, sieht beide Projekte gleichzeitig. In Kapitel 6 werden wir sehen, dass ein übergeordnetes Projekt seinen Modulen auch eine gemeinsame Konfiguration (Bibliotheksversionen, Compileroptionen) vorgeben kann.

2.6.2. Ein Projekt mit mehreren main-Methoden

Ein Projekt kann mehrere Klassen enthalten, jede mit einer Methode [main] : Jede ist ein möglicher Einstiegspunkt, und die auszuführende Klasse wird zur Laufzeit gewählt. Das Projekt [TwoHands] enthält zwei Klassen. Die Klasse [P1]:

1
2
3
4
5
6
7
8
package twohands;

public class P1 {

    public static void main(String[] args) {
        System.out.println("main of the class P1");
    }
}

und die Klasse [P2], die bis auf ihren Namen identisch ist. Der Befehl [java] führt die angegebene Klasse aus:

1
2
3
4
> java -cp target/classes twohands.P1
main of the class P1
> java -cp target/classes twohands.P2
main of the class P2

Für den Befehl [mvn exec:java] legt die Projektdatei [pom.xml] die auszuführende Klasse fest:

1
2
3
4
5
6
7
8
9
            <!-- die Klasse, deren Methode main von mvn exec:java ausgeführt wird -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <mainClass>twohands.P2</mainClass>
                </configuration>
            </plugin>
  • Zeile 7: Die ausgeführte Methode [main] gehört zur Klasse [twohands.P2] (dem vollständigen Klassennamen einschließlich des Pakets).

Ergebnisse:

> mvn -q compile exec:java
main of the class P2

Sie können eine andere Klasse wählen, ohne die Datei [pom.xml] zu ändern: [mvn -q exec:java -Dexec.mainClass=twohands.P1].

2.7. Beispiele in diesem Dokument

So führen Sie die Beispiele in diesem Dokument aus:

  • Laden Sie den Ordner [java-oct-2026] herunter (Link am Anfang des Dokuments);
  • öffnen Sie ihn in VS Code („File / Open Folder“) oder, für ein bestimmtes Maven-Projekt, dessen Ordner in IntelliJ IDEA;
  • führen Sie in einem Terminal im Ordner eines Kapitels eine kompakte Quelldatei mit [java Name.java] oder ein Maven-Projekt mit [mvn -q compile exec:java] im Projektordner aus (der Text jedes Kapitels nennt den genauen Befehl).

Die Kapitel 10 und 11 verwenden eine MySQL-Datenbank; die Installation von MySQL zusammen mit [Laragon] wird im Anhang beschrieben.