Skip to content

2. Einrichtung der Entwicklungsumgebung

Die Arbeitsumgebung des Kotlin-Entwicklers besteht aus drei voneinander unabhängigen Komponenten:

  • das JDK („Java Development Kit“): Kotlin, wie wir es in diesem Dokument verwenden, wird in Bytecode übersetzt und von der Java Virtual Machine (JVM) ausgeführt, genau wie ein Java-Programm. Das JDK stellt diese virtuelle Maschine bereit, den Befehl [java], der Programme ausführt, die Java-SE-Standardbibliotheken (die Kotlin direkt nutzt: Dateien, Netzwerk, Datumsangaben, Threads usw.) sowie Werkzeuge wie [javap] oder [jar];
  • ein Projekt-Build-Werkzeug, hier Gradle: Es lädt den Kotlin-Compiler und die Bibliotheken herunter, die ein Projekt benötigt, kompiliert das Projekt, führt seine Tests aus und verpackt es;
  • einen Editor oder eine IDE (Integrated Development Environment): [IntelliJ IDEA], entworfen vom Unternehmen, das Kotlin geschaffen hat, ist die naheliegende Wahl; [VS Code] mit der Kotlin-Erweiterung ist eine weitere Möglichkeit. Die IDE basiert auf dem JDK und kann Gradle-Projekte lesen.

Der Kotlin-Compiler selbst steht nicht auf dieser Liste: Gradle lädt ihn für jedes Projekt herunter, und IntelliJ IDEA bringt ihn mit. Sie können ihn jedoch separat installieren, um mit dem Befehl [kotlinc] eine einzelne Datei zu kompilieren: Das tun wir für unser erstes Programm, es ist aber optional.

Dieses Dokument verwendet für alle Operationen die Befehle [java], [kotlinc] und [gradlew] : 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 gebaut und für unsere Zwecke gleichwertig sind. Wir empfehlen Eclipse Temurin, eine kostenlose 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

Sie müssen das JDK (das alles enthält) wählen und nicht nur das JRE (das nur das Ausführen vorkompilierter Programme erlaubt). Aktivieren Sie bei der Installation unter Windows die Optionen, die das JDK zu [PATH] hinzufügen und die Umgebungsvariable [JAVA_HOME] setzen: Gradle, der Compiler [kotlinc] und die Dateien der IDE nutzen 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 der Befehl [java] verfügbar ist und die Version des JDK anzeigt:

1
2
3
4
> java --version
openjdk 25.0.4 2026-07-21 LTS
OpenJDK Runtime Environment Temurin-25.0.4+7 (build 25.0.4+7-LTS)
OpenJDK 64-Bit Server VM Temurin-25.0.4+7 (build 25.0.4+7-LTS, mixed mode, sharing)

Diese Ergebnisse stammen vom JDK Temurin 25.0.4, mit dem dieses Dokument geschrieben wurde. Die genaue Version hängt vom Installationsdatum ab: Bugfix-Updates erscheinen vierteljährlich. Alle JDK-Versionen 25.0.x sind für dieses Dokument geeignet. Mehrere JDK-Instanzen können auf demselben Rechner nebeneinander bestehen: Das erste, das im Verzeichnis [PATH] gefunden wird, antwortet auf den Befehl [java].

Das JDK enthält auch den Java-Compiler [javac] ([javac --version] zeigt [javac 25.0.4] an). Wir brauchen ihn nicht: Der Kotlin-Compiler erzeugt den Bytecode selbst. Aber er ist vorhanden, und ein Gradle-Projekt kann problemlos Kotlin- und Java-Dateien mischen, die zusammenarbeiten.

2.1.2. Die Befehle des JDK

Dies sind die Befehle des JDK, die wir verwenden werden:

Befehl
Aufgabe
[java -jar program.jar]
Führt das Programm aus, das in einem [.jar]-Archiv enthalten ist, dessen Manifest die Hauptklasse angibt
[java -cp classes MyClass]
führt die Funktion [main] einer kompilierten Klasse aus, die im Klassenpfad gesucht wird ([-cp], „class path“)
[javap -cp classes MyClass]
zeigt die Member einer kompilierten Klasse an: Wir verwenden es, um zu sehen, was der Kotlin-Compiler erzeugt hat
[jar]
erstellt oder liest ein [.jar]-Archiv (eine ZIP-Datei mit kompilierten Klassen)

Das JDK bietet außerdem den interaktiven Interpreter [jshell], der aber nur Java-Anweisungen akzeptiert. Um einen Kotlin-Ausdruck ohne ein Programm zu testen, verwenden Sie stattdessen die unten beschriebenen Werkzeuge von IntelliJ IDEA.

2.2. Der Kotlin-Kommandozeilen-Compiler

2.2.1. Installation

Diese Installation ist optional: Gradle-Projekte benötigen sie nicht, und IntelliJ IDEA bringt einen eigenen Compiler mit. Sie erlaubt es, eine eigenständige Kotlin-Datei von einem Terminal aus zu kompilieren und auszuführen, ohne ein Projekt anzulegen.

Der Compiler kann von der Seite mit den veröffentlichten Versionen des Kotlin-Projekts auf GitHub heruntergeladen werden (https://github.com/JetBrains/kotlin/releases): Laden Sie im Bereich „Assets“ der Version 2.4.20 das Archiv [kotlin-compiler-2.4.20.zip] herunter. Entpacken Sie es in einen Ordner, zum Beispiel [C:\Program Files\kotlinc], und fügen Sie dessen Unterordner [bin] zu [PATH] hinzu (Windows: „Systemumgebungsvariablen bearbeiten“). Sie können auch einen Paketmanager verwenden: [scoop install kotlin] unter Windows (mit Scoop) oder SDKMAN! unter Linux und macOS ([sdk install kotlin 2.4.20]). Der Compiler benötigt ein JDK, das er über die Variable [JAVA_HOME] oder die Variable [PATH] findet.

Prüfen Sie die Installation in einem neuen Terminal:

> kotlinc -version
info: kotlinc-jvm 2.4.20 (JRE 25.0.4+7-LTS)

Auf die Compiler-Version (2.4.20) folgt die Version der JVM, die ihn ausführt (JDK 25).

2.2.2. Compiler-Befehle

Das Verzeichnis [bin] enthält zwei Hauptbefehle, [kotlinc] (den Compiler) und [kotlinr] (den Launcher, „runner“):

Befehl
Aufgabe
[kotlinc File.kt -d classes]
kompiliert eine oder mehrere Quelldateien und legt die entstandenen [.class]-Dateien im Ordner [classes] ab
[kotlinc File.kt -include-runtime -d prog.jar]
kompiliert und erzeugt ein ausführbares Archiv namens [.jar], das auch die Kotlin-Standardbibliothek enthält
[kotlinr -cp classes MyClass]
wie [java -cp classes MyClass], fügt aber die Kotlin-Standardbibliothek zum Klassenpfad hinzu
[kotlinr script.main.kts]
führt ein Kotlin-Skript (Datei [.main.kts]) aus, ohne sichtbaren Kompilierungsschritt

Ein Kotlin-Skript ist eine Folge von Anweisungen, die von oben nach unten ausgeführt werden, ohne Funktion [main]. Zum Beispiel das folgende Skript [essai.main.kts]:

val s = "Kotlin " + 2.4
println(s.length)

wird wie folgt ausgeführt:

> kotlinr essai.main.kts
10

Vor Kotlin 2.4.20 hieß der Launcher [kotlin]; in Kotlin 2.4.20 wurde er in [kotlinr] umbenannt, um einen Namenskonflikt mit einem anderen Befehl zu vermeiden, [kotlin], der zum Werkzeug „Kotlin Toolchain“ gehört. Der alte Name funktioniert in Version 2.4.20 des Compilers weiterhin (er ist nicht offiziell veraltet), aber die Kotlin-Dokumentation empfiehlt nun [kotlinr].

Ohne Argumente startete der Befehl [kotlinc] früher einen interaktiven Interpreter (eine „REPL“, entsprechend [jshell]). Diese Funktion ist inzwischen veraltet:

> kotlinc
error: Kotlin REPL is deprecated and should be enabled explicitly for now; please use the '-Xrepl' option

Um einige Zeilen Kotlin auszuprobieren, verwenden Sie stattdessen eine Scratch-Datei , die Sie mit IntelliJ IDEA anlegen („File / New / Scratch File“, Sprache Kotlin) und die die Ergebnisse neben jeder Zeile anzeigt.

2.3. Gradle

2.3.1. Die Rolle von Gradle

Eine reale Anwendung verwendet Bibliotheken, die nicht zum JDK oder zur Kotlin-Standardbibliothek gehören: einen Datenbanktreiber, ein Test-Framework, Hibernate, Spring, Coroutinen … Sie werden als [.jar]-Archive über ein öffentliches Repository verteilt, Maven Central (https://central.sonatype.com). Ein Build-Werkzeug liest die Projektbeschreibung, um zu ermitteln, welche Bibliotheken es benötigt, lädt sie (samt den Bibliotheken, von denen sie abhängen) herunter und kompiliert, testet und verpackt dann das Projekt.

Die beiden großen Build-Werkzeuge der Java-Welt sind Maven (das der Java-Kurs verwendet, auf dem dieses Dokument beruht) und Gradle. Kotlin lässt sich mit beiden verwenden, aber Gradle ist im Kotlin-Ökosystem der De-facto-Standard: Es wird von Android und von Kotlin-Projekten verwendet, die IntelliJ IDEA anlegt, und seine Build-Dateien sind in … Kotlin geschrieben. Dieses Dokument verwendet Gradle 9.8.

2.3.2. Der Gradle Wrapper: keine Installation erforderlich

Gradle muss nicht installiert werden. Jedes Projekt in diesem Dokument bringt den Gradle-Wrapper mit, einen kleinen Launcher aus drei Dateien im Projektstammverzeichnis:

  • [gradlew]: das Startskript für Linux und macOS ([./gradlew]);
  • [gradlew.bat]: dasselbe Skript für Windows ([gradlew]);
  • der Ordner [gradle/wrapper], der das Launcher-Programm ([gradle-wrapper.jar]) und seine Konfiguration ([gradle-wrapper.properties]) enthält.

Die Datei [gradle-wrapper.properties] legt die zu verwendende Gradle-Version fest:

distributionUrl=https\://services.gradle.org/distributions/gradle-9.8.0-bin.zip

Beim ersten Aufruf lädt [gradlew] diese Gradle-Version herunter und speichert sie auf dem Rechner; bei den folgenden Aufrufen verwendet es sie direkt. Jedes Projekt nutzt so die Gradle-Version, mit der es geschrieben wurde, unabhängig davon, welche Version auf dem Rechner installiert sein mag. Gradle benötigt zum Ausführen nur ein JDK, das es über die Variable [JAVA_HOME] oder die Variable [PATH] findet.

In diesem Dokument werden Befehle im Windows-Format geschrieben ([gradlew build]); unter Linux oder macOS schreibt man [./gradlew build]. In PowerShell müssen Sie außerdem [.\gradlew build] schreiben.

Wenn Sie dennoch den Befehl [gradle] verwenden möchten (zum Beispiel um ein Projekt mit [gradle init] anzulegen), laden Sie das Archiv [gradle-9.8.0-bin.zip] von https://gradle.org/releases herunter, entpacken Sie es und fügen Sie seinen Unterordner [bin] zu [PATH] hinzu; oder verwenden Sie [scoop install gradle] oder [sdk install gradle]. Prüfen Sie anschließend die Installation:

> gradle --version
------------------------------------------------------------
Gradle 9.8.0
------------------------------------------------------------

Build time:    2026-09-24 13:40:00 UTC
Revision:      a927be5e08efe79e0b87ada06c762dde6bb9f8b8

Kotlin:        2.4.10
Groovy:        4.0.33
Ant:           Apache Ant(TM) version 1.10.17 compiled on April 6 2026
Launcher JVM:  25.0.4 (Eclipse Adoptium 25.0.4+7-LTS)
Daemon JVM:    /home/claude/tools/jdk-25.0.4+7 (no Daemon JVM specified, using current Java home)
OS:            Linux 6.18.44-fc-v64 amd64

Diese Ergebnisse wurden unter Linux erzeugt. Die Zeile [Kotlin:] nennt die Version von Kotlin, die in Gradle integriert ist und zum Lesen der [.gradle.kts]-Build-Dateien dient: Sie ist unabhängig von der Version des Kotlin-Compilers, mit dem unsere Programme kompiliert werden (2.4.20) und die jedes Projekt selbst festlegt. Die Zeile [Launcher JVM] gibt das JDK an, das Gradle ausführt.

2.3.3. Gradle-Befehle

Auf den Befehl [gradlew] folgen eine oder mehrere Tasks; er wird im Stammverzeichnis des Projekts eingegeben, in dem die Datei [settings.gradle.kts] liegt:

Befehl
Aufgabe
[gradlew build]
kompiliert den Quellcode in [src/main/kotlin], führt die Tests aus und erstellt das Projektarchiv [.jar] in [build/libs]
[gradlew run]
kompiliert und führt dann die Hauptklasse des Projekts aus (Plugin [application])
[gradlew test]
kompiliert und führt dann die Unit-Tests in [src/test/kotlin] aus (Kapitel 6)
[gradlew clean]
löscht den [build]-Ordner
[gradlew tasks]
zeigt die Liste der im Projekt verfügbaren Tasks an
[gradlew installDist]
erstellt in [build/install] eine installierbare Fassung des Programms: seine Archive und Startskripte
[gradlew bootRun]
führt eine Spring-Boot-Anwendung aus (Kapitel 13)

Die Tasks hängen voneinander ab: Das Ausführen von [run] löst auch die Kompilierung aus, und Gradle führt nur die Teile erneut aus, die sich seit dem letzten Build geändert haben. Die Option [-q] („quiet“) unterdrückt die Meldungen von Gradle und zeigt nur die des ausgeführten Programms an; die Option [-Pname=value] setzt eine Property , die die Build-Datei lesen kann: Wir verwenden sie, um das auszuführende Programm auszuwählen. Die Argumente für das von [run] gestartete Programm werden über die Option [--args="a b"] übergeben.

Der erste Befehl, der in einem Projekt ausgeführt wird, ist langsam: Gradle startet einen Hintergrundprozess (den Gradle-„Daemon“), der einige Stunden aktiv bleibt, um die folgenden Befehle zu beschleunigen, und lädt herunter, was das Projekt benötigt.

2.3.4. Maven Central und der Gradle-Cache

Die von Gradle heruntergeladenen Bibliotheken werden lokal im Cache von Gradle gespeichert, im Ordner [%USERPROFILE%\.gradle\caches] (Linux und macOS: [~/.gradle/caches]). Sie werden nur einmal heruntergeladen und anschließend von allen Projekten wiederverwendet. Daher ist beim ersten Build eines Projekts eine Internetverbindung erforderlich. Derselbe Ordner [.gradle] enthält in [wrapper/dists] die vom Wrapper heruntergeladenen Gradle-Versionen.

Eine Bibliothek wird durch ihre Koordinaten identifiziert, drei durch Doppelpunkte getrennte Namen: die Gruppe (häufig ein umgekehrter Domainname, etwa [org.hibernate.orm]), den Namen der Bibliothek und ihre Version, zum Beispiel [tools.jackson.core:jackson-databind:3.1.5]. Diese Koordinaten tragen Sie in die Build-Datei eines Projekts ein, und Sie finden sie, indem Sie auf der Website von Maven Central nach der Bibliothek suchen.

2.3.5. Die Kotlin-Syntax: DSL

Die Build-Datei des Projekts heißt [build.gradle.kts]. Die Endung [.kts] zeigt an, dass es sich um ein Kotlin-Skript handelt: Die Datei ist in einer eigenen Sprache („DSL“, „Domain Specific Language“) geschrieben, die auf der Kotlin-Syntax aufbaut. Gradle unterstützt außerdem in Groovy geschriebene [build.gradle]-Dateien, die sich in älteren Projekten finden; seit Gradle 8.2 ist die Kotlin-DSL das Standardformat. Hier ein typischer Auszug:

1
2
3
4
5
6
7
8
plugins {
    kotlin("jvm") version "2.4.20"
    application
}

dependencies {
    implementation("tools.jackson.core:jackson-databind:3.1.5")
}

Auch ohne Kotlin schon zu kennen, können Sie diesen Text als Konfiguration lesen:

  • Ein Name, gefolgt von einem Block in geschweiften Klammern ([plugins { ... }], [dependencies { ... }]), ist ein Abschnitt der Konfiguration. In Kotlin ist das ein Funktionsaufruf, der einen Codeblock als Parameter erhält (ein Lambda, Kapitel 7);
  • [kotlin("jvm")] und [implementation("...")] sind Funktionsaufrufe; die Zeichenketten stehen in doppelten Anführungszeichen;
  • [version = "1.0"] weist einer Projekt-Property einen Wert zu.

Ein Vorteil dieses Formats: IntelliJ IDEA erkennt es als Kotlin-Code, bietet Code-Vervollständigung an und markiert Fehler schon während der Eingabe.

2.4. Der Editor

2.4.1. IntelliJ IDEA

IntelliJ IDEA vom Unternehmen JetBrains ist der für dieses Dokument empfohlene Editor. JetBrains ist auch das Unternehmen, das Kotlin entwickelt hat (die erste stabile Version der Sprache erschien 2016) und weiterentwickelt: Die Kotlin-Unterstützung ist in IntelliJ IDEA fest eingebaut, ohne Erweiterungen, und folgt der Entwicklung der Sprache am engsten. Seine Grundfunktionen, die für dieses Dokument mehr als ausreichen, sind kostenlos.

IntelliJ IDEA erkennt Gradle-Projekte: Wählen Sie „File / Open“ und dann den Ordner, der die Datei [settings.gradle.kts] enthält; IntelliJ startet Gradle, um das Projekt zu lesen (Sie können den Vorgang im Fenster „Build“ verfolgen), lädt die Bibliotheken herunter und zeigt dann eine „Gradle“-Ansicht an, über die Sie alle Tasks des Projekts erreichen. Anschließend können Sie ein Programm ausführen, indem Sie auf das grüne Dreieck am Rand neben seiner Funktion [main] klicken ([Ctrl-Shift-F10]), oder einen Test, indem Sie auf dasselbe Dreieck neben der Testfunktion klicken. Das zu verwendende JDK legen Sie unter „File / Project Structure / SDK“ fest; bei einem Gradle-Projekt ist es im Allgemeinen die Deklaration [jvmToolchain(25)] des Projekts (siehe unten), die das JDK für die Kompilierung bestimmt.

IntelliJ IDEA bietet außerdem Kotlin-spezifische Funktionen: die automatische Umwandlung einer Java-Datei in Kotlin („Code / Convert Java File to Kotlin File“ oder einfach durch Einfügen von Java-Code in eine Kotlin-Datei), die Anzeige des vom Compiler erzeugten Bytecodes („Tools / Kotlin / Show Kotlin Bytecode“) und die weiter oben erwähnten Scratch-Dateien.

2.4.2. VS Code

VS Code ist ein kostenloser, plattformübergreifender Editor. Um in Kotlin zu programmieren, installieren Sie die von JetBrains veröffentlichte Erweiterung Kotlin (öffnen Sie das Menü „Extensions“, suchen Sie nach „Kotlin“ und wählen Sie die Erweiterung, deren Herausgeber JetBrains ist). Diese offizielle Erweiterung ist neu: Sie nutzt dieselbe Code-Analyse-Engine wie IntelliJ IDEA und kann Gradle-Projekte importieren, bietet aber noch nicht alle Funktionen der IDE von JetBrains, und ihr Funktionsumfang ändert sich von Version zu Version. Prüfen Sie auf der Seite der Erweiterung, was sie zum Zeitpunkt der Installation unterstützt. Für die Zwecke dieses Dokuments eignet sie sich zum Lesen und Bearbeiten von Programmen; ausführen können Sie sie stets im integrierten Terminal („Terminal / New Terminal“) mit den im Text angegebenen [gradlew]-Befehlen.

Öffnen Sie in VS Code den Ordner eines Kapitels („File / Open Folder“), zum Beispiel den Ordner [kotlin-oct-2026/03-basics].

2.4.3. Android Studio

Kotlin ist auch die von Google für Android-Apps empfohlene Sprache. Android Studio, auf IntelliJ IDEA aufbauend, ist für diese Art von Apps gedacht, die in diesem Dokument nicht behandelt werden.

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

2.5. Ein Beispielprogramm: die Datei Hello.kt

2.5.1. Das Programm

Ein Kotlin-Programm kann eine einfache Datei sein, die eine Funktion namens [main] ohne Klassendeklaration enthält. Legen wir die folgende Datei [Hello.kt] an (im Beispielordner [02-installation] ):

1
2
3
4
// erstes Kotlin-Programm: eine Top-Level-Funktion main
fun main() {
    println("1st try with Kotlin 2.4")
}

Kommentare:

  • Zeile 1: ein Kommentar. Alles nach [//] bis zum Zeilenende wird vom Compiler ignoriert;
  • Zeile 2: die Funktion [main], der Einstiegspunkt des Programms. Das Schlüsselwort [fun] leitet eine Funktion ein. Sie wird auf Dateiebene deklariert („Top-Level-Funktion“), außerhalb jeder Klasse; sie muss weder als [public] deklariert werden (das ist in Kotlin die Standardsichtbarkeit) noch Programmargumente entgegennehmen;
  • Zeile 3: die einzige Anweisung des Programms: Sie gibt eine Textzeile auf dem Bildschirm aus. Die Funktion [println] (und [print], die keinen Zeilenumbruch macht) gehört zur Kotlin-Standardbibliothek; sie entspricht [System.out.println] in Java. Beachten Sie das fehlende Semikolon am Ende der Anweisung: Es ist in Kotlin optional und wird nicht geschrieben.

Das Programm ist etwas einfacher als sein Gegenstück im Java-Kurs ([void main() { IO.println(...); }]), aber der eigentliche Unterschied liegt woanders: Die Top-Level-Funktion [main] gibt es in Kotlin seit der ersten Version, während Java sie erst seit Java 25 unterstützt.

2.5.2. Kompilierung und Ausführung

Wir kompilieren das Programm mit [kotlinc] und geben dabei ein ausführbares Archiv namens [.jar] an, und führen es dann mit dem Befehl [java] des JDK aus:

1
2
3
> kotlinc Hello.kt -include-runtime -d hello.jar
> java -jar hello.jar
1st try with Kotlin 2.4
  • [-d hello.jar]: das Ziel der Kompilierung. Endet es auf [.jar], erzeugt der Compiler ein Archiv; andernfalls ist es ein Ordner, in dem er die [.class]-Dateien ablegt;
  • [-include-runtime]: Das Archiv enthält zusätzlich die Kotlin-Standardbibliothek ([kotlin-stdlib]), die Kotlin-Programme zur Laufzeit benötigen, sowie ein Manifest, das die Hauptklasse angibt. Das Programm kann somit mit [java -jar] auf jedem Rechner mit JDK (oder JRE) ausgeführt werden, auch wenn Kotlin dort nicht installiert ist. Dafür ist das Archiv mehr als 5 MB groß, hauptsächlich wegen der Standardbibliothek;
  • die Kompilierung dauert einige Sekunden: Der Kotlin-Compiler, selbst ein Java-Programm, muss erst starten. Gradle und IntelliJ IDEA vermeiden diesen Mehraufwand, indem sie zwischen den Kompilierungen einen Compiler aktiv halten.

Es gibt in Kotlin kein Gegenstück zum Java-Befehl [java Hello.java], der eine Quelldatei in einem Schritt kompiliert und ausführt; das nächstliegende Gegenstück ist das oben vorgestellte [.main.kts]-Skript.

2.5.3. Was der Compiler erzeugt

Die Java Virtual Machine (JVM) kennt nur Klassen: Eine Funktion kann nicht außerhalb einer Klasse existieren. Der Kotlin-Compiler verpackt die Top-Level-Funktionen einer Datei daher in eine von ihm erzeugte Klasse, die er nach der Datei benennt: Dateiname gefolgt von [Kt]. Für [Hello.kt] heißt die erzeugte Klasse [HelloKt]. Der Befehl [javap] des JDK zeigt ihre Member an:

1
2
3
4
5
6
> javap -cp hello.jar HelloKt
Compiled from "Hello.kt"
public final class HelloKt {
  public static final void main();
  public static void main(java.lang.String[]);
}
  • Die Klasse [HelloKt] ist [public final];
  • sie enthält unsere Funktion [main], die zu einer statischen Methode ohne Parameter geworden ist;
  • und eine zweite Methode, [main(String[])], vom Compiler hinzugefügt: Dies ist die Methode [public static void main(String[] args)] , die die virtuelle Maschine aufzurufen weiß. Sie ruft einfach die erste auf. Auf diesen Mechanismus kommen wir in Kapitel 3 zurück.

Dieser Klassenname identifiziert das auszuführende Programm: Das Manifest von [hello.jar] enthält die Zeile [Main-Class: HelloKt], und man kann auch [java -cp hello.jar HelloKt] schreiben.

Anders als in Java gibt es keine Einschränkungen für den Dateinamen: Er muss weder ein gültiger Bezeichner sein noch dem Namen einer darin enthaltenen Klasse entsprechen. Eine Datei namens [first-try.kt] wird akzeptiert, und ihre erzeugte Klasse heißt [First_tryKt] (der Compiler schreibt den ersten Buchstaben groß und ersetzt in einem Bezeichner unzulässige Zeichen durch [_]). Üblicherweise erhalten Dateien jedoch Namen, die mit einem Großbuchstaben beginnen und keine Bindestriche enthalten, wie [Hello.kt] oder [Basics01.kt].

Unter Windows werden mit [println] geschriebene Zeichen mit Akzenten im Terminal korrekt angezeigt: Die virtuelle Maschine wandelt den Text in die Kodierung des Terminals um. Quelldateien müssen in UTF-8 gespeichert werden, der Standardkodierung von VS Code und IntelliJ IDEA und derjenigen, die der Kotlin-Compiler immer voraussetzt. Anders ist die Lage, wenn das Programm von Gradle gestartet wird ([gradlew run] oder das grüne Dreieck in einem Gradle-Projekt): Seine Ausgabe ist dann keine Konsole mehr, sondern eine Pipe zu Gradle, und die virtuelle Maschine kodiert sie in der historischen Windows-Kodierung (windows-1252), sodass IntelliJ IDEA, das UTF-8 erwartet, anstelle jedes Zeichens mit Akzent ein Platzhalterzeichen anzeigt (eine Raute mit einem Fragezeichen). Die Kursprojekte beheben dieses Problem in ihrer Datei [build.gradle.kts] (siehe nächsten Abschnitt). Für das integrierte Terminal von IntelliJ IDEA (PowerShell) können Sie die Konsole auch auf UTF-8 umstellen, indem Sie zu Beginn der Sitzung [chcp 65001] eingeben, oder ein für alle Mal, indem Sie [powershell.exe -NoExit -Command "[Console]::OutputEncoding = [Text.Encoding]::UTF8"] unter „File / Settings / Tools / Terminal / Shell path“ als Interpreter eintragen.

Der Befehl [kotlinc] eignet sich für Programme aus einer einzigen Datei, die nur die Standardbibliothek verwenden. Sobald ein Programm eine externe Bibliothek benötigt, müssen Sie sie samt den Bibliotheken, von denen sie abhängt, herunterladen und dem Compiler und anschließend der virtuellen Maschine übergeben: Das läuft darauf hinaus, ein Gradle-Projekt anzulegen. Genau das tun wir für alle Beispiele dieses Dokuments.

2.6. Ein Gradle-Projekt

2.6.1. Projektstruktur

Ein Gradle-Projekt ist ein Ordner, der eine Build-Datei namens [build.gradle.kts] und nach einer Standard-Verzeichnisstruktur organisierte Quelldateien enthält. Die Wurzel eines Gradle-Builds enthält außerdem eine Datei namens [settings.gradle.kts], die den Namen des Builds und die Liste der darin zusammengefassten Projekte angibt, sowie den Wrapper. Der Ordner [02-installation] in den Beispielen ist ein Build, der zwei Projekte zusammenfasst, [FirstProgram] und [TwoHands]:

02-installation/
├── gradlew
├── gradlew.bat
├── gradle/
│   └── wrapper/
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── settings.gradle.kts
├── build.gradle.kts
├── Hello.kt
├── FirstProgram/
│   ├── build.gradle.kts
│   └── src/
│       └── main/
│           └── kotlin/
│               └── first/
│                   └── Main.kt
└── TwoHands/
    ├── build.gradle.kts
    └── src/
        └── main/
            └── kotlin/
                └── twohands/
                    ├── P1.kt
                    └── P2.kt
  • [src/main/kotlin] enthält die Quelldateien des Programms; [src/main/resources] würde die Daten- oder Konfigurationsdateien enthalten, die neben den kompilierten Klassen abgelegt werden; [src/test/kotlin] würde die Tests enthalten (Kapitel 6);
  • Unter [src/main/kotlin] spiegelt die Ordnerstruktur die der Pakete (Kapitel 4): Die Datei [Main.kt] des Pakets [first] liegt im Ordner [first]. Kotlin erzwingt diese Entsprechung im Gegensatz zu Java nicht, empfiehlt sie aber, und wir halten uns stets daran;
  • Die Datei [Hello.kt] gehört zu keinem Projekt: Sie liegt dort, um von [kotlinc] kompiliert zu werden, und Gradle ignoriert sie.

Ein eigenständiges Projekt (nicht mit anderen zusammengefasst) hat dieselbe Struktur, mit eigenen Dateien [settings.gradle.kts] und eigenem Wrapper: So ist es beim Projekt in Kapitel 3. Sie können diese Verzeichnisstruktur von Hand anlegen oder von der IDE erstellen lassen (IntelliJ: „File / New / Project“, als Sprache „Kotlin“ und als Build-System „Gradle“ mit der Kotlin-DSL wählen).

Die Dateien im Stammverzeichnis sehen wir uns im nächsten Abschnitt an. Die Datei [build.gradle.kts] im Projekt [FirstProgram] lautet wie folgt:

// das Projekt [FirstProgram]: ein Kotlin-Programm, das von der JVM ausgeführt wird
plugins {
    // das Kotlin-Plugin für die JVM (seine Version wird im Root-Projekt deklariert)
    kotlin("jvm")
    // das Plugin [application]: die Tasks run und installDist
    application
}

// die Koordinaten des Projekts
group = "examples.installation"
version = "1.0"

// das Repository, in dem Bibliotheken gesucht werden
repositories {
    mavenCentral()
}

dependencies {
    // keine Bibliothek außer der Kotlin-Standardbibliothek, die vom Plugin hinzugefügt wird
}

kotlin {
    // der Code wird mit JDK 25 kompiliert und ausgeführt
    jvmToolchain(25)
    compilerOptions {
        // eine Compiler-Warnung wird als Fehler behandelt
        allWarningsAsErrors = true
        // die Namen der Funktionsparameter bleiben im Bytecode erhalten
        javaParameters = true
    }
}

application {
    // die Klasse mit der Funktion main, die von [gradlew run] ausgeführt wird
    mainClass = "first.MainKt"
}

// unter Windows wird die Bildschirmausgabe des von Gradle gestarteten Programms (run, bootRun ...) in UTF-8 kodiert,
// sonst werden Zeichen mit Akzenten in der IntelliJ-IDEA-Konsole oder im Terminal falsch dargestellt
tasks.withType<JavaExec>().configureEach {
    jvmArgs("-Dstdout.encoding=UTF-8", "-Dstderr.encoding=UTF-8")
}

Kommentare:

  • Zeile 1: ein Kommentar. Die Build-Datei ist in Kotlin geschrieben: Kommentare werden genauso geschrieben wie in einem Programm;
  • Zeilen 2–7: die auf das Projekt angewendeten Plugins . Sie stellen Gradle die Tasks bereit, die wir brauchen:
    • Zeile 4: das Kotlin-Plugin für die JVM. Es fügt Tasks hinzu, die die Dateien in [src/main/kotlin] kompilieren, und fügt die Kotlin-Standardbibliothek automatisch zu den Abhängigkeiten des Projekts hinzu. Die Schreibweise [kotlin("jvm")] ist eine Kurzform der vollständigen Kennung des Plugins, [org.jetbrains.kotlin.jvm]. Seine Version ist hier nicht angegeben, weil das Projekt Teil eines Multiprojekt-Builds ist, in dem das Wurzelprojekt diese Version für alle festlegt (siehe nächsten Abschnitt). In einem eigenständigen Projekt würden Sie [kotlin("jvm") version "2.4.20"] schreiben: Diese Version bestimmt die Version des verwendeten Kotlin-Compilers;
    • Zeile 6: das Plugin [application], das die Tasks [run] (das Programm ausführen) und [installDist] (eine installierbare Fassung vorbereiten) hinzufügt;
  • Zeilen 10–11: die Kennungen von Projekt, Gruppe und Version, die das Projekt anhand seines Namens identifizieren ([FirstProgram], der Name seines Ordners). Dies sind auch die Kennungen, mit denen ein anderes Projekt auf dieses verweisen könnte, ähnlich wie bei einer Bibliothek von Maven Central (Kapitel 6);
  • Zeilen 14–15: das Repository, in dem Gradle nach den Bibliotheken des Projekts sucht, hier Maven Central;
  • Zeilen 18–20: die vom Projekt verwendeten Bibliotheken. Dieses Projekt verwendet keine, abgesehen von der Kotlin-Standardbibliothek, die das Kotlin-Plugin automatisch hinzufügt;
  • Zeile 24: die Toolchain des Projekts: Der Code wird für Java 25 kompiliert und von [gradlew run] mit einem JDK 25 ausgeführt, auch wenn Gradle selbst von einem anderen JDK ausgeführt wird. Gradle sucht dieses JDK unter den auf dem Rechner installierten. Findet es keines, bricht es mit der Fehlermeldung [Cannot find a Java installation on your machine ... matching: {languageVersion=25 ...}] ab, es sei denn, der Build deklariert das Plugin [foojay-resolver-convention], was alle Projekte des Kurses tun (siehe nächsten Abschnitt): Gradle lädt dann selbstständig ein JDK 25 herunter. In IntelliJ IDEA können Sie dieses JDK auch über „File / Project Structure / SDK / Add SDK / Download JDK“ installieren;
  • Zeile 27: Eine Compiler-Warnung wird als Fehler behandelt und stoppt die Kompilierung. Der Kotlin-Compiler meldet viele Probleme (nicht verwendete Variablen, unnötige Typumwandlungen, überflüssige [!!]-Operatoren usw.): Wir wollen Programme, die nichts davon erzeugen;
  • Zeile 29: Der Compiler bewahrt die Namen der Funktionsparameter im Bytecode. Einige Bibliotheken nutzen das, zum Beispiel Jackson, um aus einem JSON-Dokument ein Objekt zu erzeugen (Kapitel 5), oder Spring (Kapitel 13);
  • Zeilen 33–35: die Klasse, deren Funktion [main] von [gradlew run] ausgeführt wird. Der Name ist der der Klasse, die der Compiler für die Datei [Main.kt] im Paket [first] erzeugt: [first.MainKt];
  • Zeilen 38–41: Alle Tasks, die ein Java-Programm ausführen ([JavaExec]), wie [run], erhalten zwei Optionen für die virtuelle Maschine: Die Bildschirmausgabe des Programms ([System.out], [System.err]) wird in UTF-8 kodiert. Ohne sie würden vom Programm geschriebene Zeichen mit Akzenten in der Konsole von IntelliJ IDEA unter Windows verfälscht (siehe den Hinweis zu Akzenten weiter oben). [tasks.withType<JavaExec>()] bezieht sich auf alle Tasks dieses Typs, und [configureEach { … }] konfiguriert jeden von ihnen. Alle Kursprojekte, die ein Programm ausführen, enthalten diese Konfiguration.

Dieses Projekt verwendet keine Bibliotheken. Ein Projekt, das eine Bibliothek verwendet, deklariert sie im Abschnitt [dependencies] mit ihren Koordinaten, wie wir es ab Kapitel 5 tun werden:

1
2
3
dependencies {
    implementation("tools.jackson.core:jackson-databind:3.1.5")
}

Das Schlüsselwort [implementation] zeigt an, dass die Bibliothek zum Kompilieren und Ausführen des Programms erforderlich ist. Sie begegnen auch [runtimeOnly] (nur zur Ausführung erforderlich, etwa ein Datenbanktreiber) und [testImplementation] (nur für Tests erforderlich). Gradle lädt dann [jackson-databind] und die Bibliotheken herunter, von denen sie abhängt.

Die Datei [Main.kt] enthält das Programm:

1
2
3
4
5
6
package first

// das Hauptprogramm des Projekts [FirstProgram]
fun main() {
    println("1st try with a Gradle / Kotlin 2.4 project")
}
  • Zeile 1: Die Datei gehört zum [first]-Paket. Der vollständige Name der für diese Datei erzeugten Klasse lautet daher [first.MainKt];
  • Zeilen 4–6: die Funktion [main], in derselben Form wie in [Hello.kt]. Eine Kotlin-Datei kann beliebig viele Funktionen und Klassen enthalten, ob öffentlich oder nicht: Der Dateiname hängt nicht von ihrem Inhalt ab.

2.6.2. Kompilierung und Ausführung

Der Befehl [gradlew build], eingegeben im Ordner [02-installation], kompiliert die Projekte des Builds (und würde ihre Tests ausführen, wenn sie welche hätten): Gradle lädt bei Bedarf das Kotlin-Plugin, den Compiler und die Standardbibliothek herunter, kompiliert dann die Dateien in [src/main/kotlin] und legt die entstandenen Klassen unter Beibehaltung der Paketstruktur für jedes Projekt im Ordner [build/classes/kotlin/main] ab ([FirstProgram/build/classes/kotlin/main/first/MainKt.class]).

Der Befehl [gradlew run] kompiliert ein Projekt und führt es anschließend aus. In einem Build mit mehreren Projekten wird das Projekt durch seinen Pfad angegeben, dem ein Doppelpunkt vorangestellt ist: [:FirstProgram:run] ist der Task [run] des Projekts [FirstProgram]. Mit der Option [-q]wird nur die Ausgabe des Programms angezeigt:

> gradlew -q :FirstProgram:run
1st try with a Gradle / Kotlin 2.4 project

Sie können auch in den Projektordner wechseln und [..\gradlew -q run] eingeben: Gradle sucht aufwärts die Datei [settings.gradle.kts] im Stammverzeichnis und führt den Task [run] des Projekts im aktuellen Ordner aus. Dagegen würde die Eingabe von [gradlew run] im Stammverzeichnis den Task [run] für alle Projekte ausführen, die einen haben.

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 (im Ordner [FirstProgram]):

> java -cp build/classes/kotlin/main first.MainKt
1st try with a Gradle / Kotlin 2.4 project

Das funktioniert hier, weil dieses Programm zur Laufzeit tatsächlich nichts aus der Kotlin-Standardbibliothek verwendet: Der Compiler ersetzt den Aufruf von [println] durch einen direkten Aufruf von [System.out.println]. Ein Programm, das zum Beispiel eine Liste verwendet ([listOf(1, 2, 3)]), scheitert auf diese Weise jedoch mit dem Fehler [java.lang.NoClassDefFoundError: kotlin/collections/CollectionsKt]: Die Klasse [CollectionsKt] der Standardbibliothek wird nicht gefunden. Sie müssen dann das Archiv [kotlin-stdlib-2.4.20.jar] zum Klassenpfad hinzufügen (es liegt im Gradle-Cache; auch der Ordner [lib] des Compilers [kotlinc] enthält es, unter dem Namen [kotlin-stdlib.jar]): [java -cp "build/classes/kotlin/main;path/kotlin-stdlib-2.4.20.jar" first.MainKt] unter Windows (unter Linux und macOS ist das Trennzeichen [:]). Der Befehl [kotlinr -cp build/classes/kotlin/main first.MainKt] des Kommandozeilen-Compilers erledigt das für uns.

Am einfachsten lassen Sie Gradle das Programm und alles, was es braucht, mit dem Task [installDist] des Plugins [application] erstellen:

> gradlew -q :FirstProgram:installDist

Er erzeugt den Ordner [FirstProgram/build/install/FirstProgram], der einen Ordner [lib] (das Projektarchiv, die Kotlin-Standardbibliothek und gegebenenfalls die weiteren Bibliotheken des Projekts) und einen Ordner [bin] mit zwei Startskripten enthält, [FirstProgram] (Linux, macOS) und [FirstProgram.bat] (Windows), die [java] mit dem richtigen Klassenpfad aufrufen. In dieser Form wird ein Programm ausgeliefert, damit es auf einen anderen Rechner mit JDK kopiert werden kann:

> FirstProgram\build\install\FirstProgram\bin\FirstProgram
1st try with a Gradle / Kotlin 2.4 project

Der Ordner [build] kann bedenkenlos gelöscht werden ([gradlew clean]): Er wird bei der nächsten Kompilierung neu angelegt. Der Befehl [gradlew build] erzeugt auch das Archiv des Projekts [build/libs/FirstProgram-1.0.jar], das nur seine eigenen Klassen enthält.

2.7. Ein Projekt mit mehreren Modulen

2.7.1. Der Multiprojekt-Build

Ein Gradle-Build kann mehrere Projekte zusammenfassen, die man seine Teilprojekte (oder Module) nennt. Die Datei [settings.gradle.kts] im Stammverzeichnis listet sie auf. Die im Ordner [02-installation] lautet wie folgt:

// Kapitel 2: ein Gradle-Build, der die beiden Projekte des Ordners zusammenfasst

// Gradle lädt das von jvmToolchain(25) angeforderte JDK selbst herunter, wenn es auf dem Rechner nicht gefunden wird
plugins {
    id("org.gradle.toolchains.foojay-resolver-convention") version "1.0.0"
}

rootProject.name = "installation"

// die Unterprojekte, bezeichnet durch ihren Ordnernamen
include("FirstProgram", "TwoHands")
  • Zeilen 3–6: ein Plugin für den Build selbst (nicht für ein Projekt), [foojay-resolver-convention]: Wenn ein Projekt über [jvmToolchain(25)] ein JDK anfordert, das Gradle auf dem Rechner nicht findet, lädt Gradle es vom Dienst foojay.io herunter und legt es in seinem Cache ab. Der erste Lauf dauert etwas länger, dafür muss der Lernende nicht mehr das richtige JDK installiert haben. Der Block [plugins] muss der erste in der Datei sein. Alle Builds des Kurses deklarieren dieses Plugin;
  • Zeile 8: der Name des Builds (des Wurzelprojekts). Ohne diese Zeile wäre es der Ordnername;
  • Zeile 11: die Teilprojekte, identifiziert durch ihre Ordnernamen. Ein Teilprojekt kann tiefer verschachtelt sein: [include("TaxV5:tax-dao")] bezeichnet das Projekt im Ordner [TaxV5/tax-dao] (Kapitel 6).

Das Wurzelprojekt hat ebenfalls eine Datei namens [build.gradle.kts]:

1
2
3
4
5
// Kapitel 2: Root-Projekt. Das Kotlin-Plugin wird hier mit seiner Version deklariert, aber nicht angewendet:
// die Unterprojekte wenden es an
plugins {
    kotlin("jvm") version "2.4.20" apply false
}
  • Zeilen 3–4: Das Kotlin-Plugin wird samt Version deklariert, aber nicht auf das Wurzelprojekt angewendet ([apply false]), das keinen zu kompilierenden Code enthält. Diese Deklaration macht das Plugin für die Teilprojekte verfügbar, die es über [kotlin("jvm")] ohne Wiederholung der Version anwenden: Alle Teilprojekte verwenden so dieselbe Kotlin-Version, die sich an einer einzigen Stelle ändern lässt. Würde jedes Teilprojekt die Plugin-Version selbst deklarieren, würde Gradle das Plugin mehrfach laden, wovon das Kotlin-Plugin abrät.

Im Ordner [02-installation] kompiliert der Befehl [gradlew build] beide Projekte; eine IDE, die diesen Ordner öffnet, sieht beide Projekte gleichzeitig. In Kapitel 6 werden wir sehen, dass ein Teilprojekt von einem anderen abhängen kann ([implementation(project(":TaxV5:tax-dao"))]), und in den Kapiteln 10 bis 13, dass ein Build sogar Projekte eines anderen Builds wiederverwenden kann ([includeBuild]).

2.7.2. Ein Projekt mit mehreren main-Funktionen

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

1
2
3
4
5
6
package twohands

// ein erster Einstiegspunkt des Projekts [TwoHands]
fun main() {
    println("main of the P1.kt file")
}

und die Datei [P2.kt], die bis auf den Namen identisch ist. Beide Funktionen heißen [main] und gehören zum selben Paket: Es gibt keinen Konflikt, weil sie sich in zwei verschiedenen Klassen befinden, [twohands.P1Kt] und [twohands.P2Kt]. Der Befehl [java] führt die ihm angegebene Klasse aus (im Ordner [TwoHands], sobald das Projekt kompiliert ist):

1
2
3
4
> java -cp build/classes/kotlin/main twohands.P1Kt
main of the P1.kt file
> java -cp build/classes/kotlin/main twohands.P2Kt
main of the P2.kt file

Für den Befehl [gradlew run] legt die Datei [build.gradle.kts] des Projekts die auszuführende Klasse fest:

1
2
3
4
5
6
application {
    // das von [gradlew run] ausgeführte Programm wird durch die Eigenschaft [main] festgelegt;
    // standardmäßig ist es die Funktion main der Datei P2.kt:
    // gradlew -q :TwoHands:run -Pmain=twohands.P1Kt
    mainClass = providers.gradleProperty("main").orElse("twohands.P2Kt")
}
  • Zeile 5: Die auszuführende Klasse wird durch die Gradle-Property [main] angegeben, die auf der Kommandozeile über die Option [-Pmain=...] übergeben wird. Die Funktion [providers.gradleProperty("main")] liest diese Property; [orElse(...)] gibt den Wert an, der verwendet wird, wenn sie nicht angegeben wurde: hier die Klasse [twohands.P2Kt].

Der Rest der Datei entspricht dem von [FirstProgram], ergänzt um eine Konfiguration für den Task [run] ([standardInput = System.in]), die Tastatureingaben an das Programm weitergibt: Ohne sie kann ein von [gradlew run] gestartetes Programm die Tastatur nicht lesen.

Ergebnisse:

1
2
3
4
> gradlew -q :TwoHands:run
main of the P2.kt file
> gradlew -q :TwoHands:run -Pmain=twohands.P1Kt
main of the P1.kt file

So können Sie das auszuführende Programm wählen, ohne die Datei [build.gradle.kts] zu ändern. Mit IntelliJ IDEA stellt sich das Problem nicht: Jede Funktion [main] hat ihr eigenes grünes Dreieck am Rand.

2.7.3. Ein Paket pro Programm

Die Projekte der folgenden Kapitel verwenden alle diesen Mechanismus, da jedes viele kleine Programme enthält. Damit diese Programme sich nicht gegenseitig stören, folgt dieses Dokument einer einfachen Konvention: Jedes Programm hat sein eigenes Paket, das seinen Namen in Kleinbuchstaben trägt und in einem gleichnamigen Ordner liegt. So ist das Programm [Basics04.kt] aus Kapitel 3 die Datei [03-basics/src/main/kotlin/basics04/Basics04.kt], die mit der Zeile [package basics04] beginnt; seine Klasse ist [basics04.Basics04Kt], und es wird wie folgt ausgeführt:

gradlew -q run -Pmain=basics04.Basics04Kt

Für diese Konvention gibt es zwei Gründe:

  • Alle Programme eines Projekts werden gemeinsam kompiliert. Läge alles im selben Paket, könnten zwei Programme keine Funktion oder Klasse mit demselben Namen deklarieren (eine Funktion [display], eine Klasse [Person] …): Der Compiler würde eine doppelte Deklaration melden. Mit einem Paket pro Programm hat jedes seinen eigenen Namensraum;
  • ein Programm aus mehreren Dateien ist einfach ein Paket mit mehreren Dateien: In Kapitel 4 enthält das Paket [persons] die Klasse [Person] in [Person.kt] und das Hauptprogramm in [Main.kt], das mit [-Pmain=persons.MainKt] ausgeführt wird.

Der Text jedes Kapitels nennt vor den Ergebnissen eines Programms den genauen Befehl, der es ausführt. Auf diese Struktur kommen wir in Kapitel 3 zurück.

2.8. Die Beispiele in diesem Dokument

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

  • Laden Sie den Ordner [kotlin-oct-2026] herunter (Link am Anfang des Dokuments). Er enthält einen Ordner pro Kapitel ([02-installation], [03-basics], [04-classes] …), und jeder dieser Ordner ist ein Gradle-Build samt Wrapper: ein einzelnes Projekt oder mehrere Teilprojekte, die seine Datei [settings.gradle.kts] zusammenfasst;
  • Öffnen Sie den Ordner eines Kapitels in IntelliJ IDEA („File / Open“) und führen Sie dann ein Programm aus, indem Sie auf das grüne Dreieck neben seiner Funktion [main] klicken;
  • oder führen Sie in einem Terminal im Ordner des Kapitels ein Programm mit [gradlew -q run -Pmain=package.ClassKt] aus (bei mehreren Teilprojekten steht der Pfad des Teilprojekts vor [run]); der Text jedes Kapitels nennt den genauen Befehl.

Der erste [gradlew]-Befehl in einem Kapitel erfordert Internetzugang: Gradle lädt dann seine eigene Distribution, das Kotlin-Plugin und die Bibliotheken des Projekts herunter, die es anschließend in seinem Cache ablegt.

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