Java-Versionen in Android-Builds

Unabhängig davon, ob Ihr Quellcode in Java, Kotlin oder beiden Sprachen geschrieben ist, müssen Sie an mehreren Stellen eine JDK- oder Java-Sprachversion für Ihren Build auswählen.

Glossar

Java Development Kit (JDK)

Das Java Development Kit (JDK) enthält:

• Tools wie einen Compiler, Profiler und Archiv-Creator. Diese werden im Hintergrund während des Builds verwendet, um Ihre Anwendung zu erstellen.
• Bibliotheken mit APIs, die Sie aus Ihrem Kotlin- oder Java-Quellcode aufrufen können. Hinweis: Nicht alle Funktionen sind verfügbar unter Android.
• Die Java Virtual Machine (JVM), ein Interpreter, der Java-Anwendungen ausführt. Sie verwenden die JVM, um die Android Studio IDE und das Gradle-Build-Tool auszuführen. Die JVM wird nicht auf Android Geräten oder in Emulatoren verwendet.

JetBrains Runtime (JBR)

Die JetBrains Runtime (JBR) ist ein erweitertes JDK, das mit Android Studio ausgeliefert wird. Es enthält mehrere Optimierungen für die Verwendung in Studio und verwandten JetBrains Produkten, kann aber auch zum Ausführen anderer Java-Anwendungen verwendet werden.

Wie wähle ich ein JDK aus, um Android Studio auszuführen?

Wir empfehlen, die JBR zum Ausführen von Android Studio zu verwenden. Sie wird mit Android Studio bereitgestellt und zum Testen verwendet und enthält Verbesserungen für eine optimale Nutzung von Android Studio. Legen Sie dazu die Umgebungsvariable STUDIO_JDK nicht fest.

Die Startskripts für Android Studio suchen in der folgenden Reihenfolge nach einer JVM:

1. Umgebungsvariable STUDIO_JDK
2. Verzeichnis studio.jdk (in der Android Studio-Distribution)
3. Verzeichnis jbr (JetBrains Runtime) in der Android Studio-Distribution. Empfohlen.
4. Umgebungsvariable JDK_HOME
5. Umgebungsvariable JAVA_HOME
6. Ausführbare Datei java in der Umgebungsvariable PATH

Wie wähle ich aus, welches JDK meine Gradle-Builds ausführt?

Wenn Sie Gradle über die Schaltflächen in Android Studio ausführen, wird das in den Android Studio-Einstellungen festgelegte JDK verwendet. Wenn Sie Gradle in einem Terminal ausführen, entweder in oder außerhalb von Android Studio, bestimmt die Umgebungsvariable JAVA_HOME (falls festgelegt), welches JDK die Gradle-Skripts ausführt. Wenn JAVA_HOME nicht festgelegt ist, wird der Befehl java in der Umgebungsvariable PATH verwendet.

Um möglichst konsistente Ergebnisse zu erzielen, legen Sie die JAVA_HOME Umgebungsvariable und die Gradle-JDK-Konfiguration in Android Studio auf dasselbe JDK fest.

Beim Ausführen des Builds erstellt Gradle einen Prozess namens Daemon, um den eigentlichen Build auszuführen. Dieser Prozess kann wiederverwendet werden, solange für die Builds dieselbe JDK- und Gradle-Version verwendet wird. Durch die Wiederverwendung eines Daemons wird die Zeit verkürzt, die zum Starten einer neuen JVM und zum Initialisieren des Build-Systems benötigt wird.

Wenn Sie Builds mit verschiedenen JDKs oder Gradle-Versionen starten, werden zusätzliche Daemons erstellt, die mehr CPU und Arbeitsspeicher verbrauchen.

Gradle-JDK-Konfiguration in Android Studio

Wenn Sie die Gradle-JDK-Konfiguration des vorhandenen Projekts ändern möchten, öffnen Sie die Gradle-Einstellungen über File (Datei) oder Android Studio (unter macOS) > Settings > Build, Execution, Deployment > Build Tools > Gradle (Einstellungen > Build, Ausführung, Bereitstellung > Build-Tools > Gradle). Das Drop-down-Menü Gradle JDK enthält die folgenden Optionen:

• Makros wie JAVA_HOME und GRADLE_LOCAL_JAVA_HOME
• JDK-Tabelleneinträge im vendor-version Format wie jbr-17, die in den Android-Konfigurationsdateien gespeichert sind
• JDK herunterladen
• Bestimmtes JDK hinzufügen
• Lokal erkannte JDKs aus dem Standardverzeichnis für die JDK-Installation des Betriebssystems

Die ausgewählte Option wird in der Option gradleJvm in der Datei .idea/gradle.xml des Projekts gespeichert. Der JDK-Pfad wird verwendet, um Gradle auszuführen, wenn es über Android Studio gestartet wird.

Die Makros ermöglichen die dynamische Auswahl des JDK-Pfads für das Projekt:

• JAVA_HOME: verwendet die Umgebungsvariable mit demselben Namen
• GRADLE_LOCAL_JAVA_HOME: verwendet die Eigenschaft java.home in der Datei .gradle/config.properties, die standardmäßig auf die JetBrains Runtime festgelegt ist.

Das ausgewählte JDK wird verwendet, um den Gradle-Build auszuführen und JDK-API-Referenzen aufzulösen, wenn Sie Ihre Build-Skripts und Ihren Quellcode bearbeiten. Beachten Sie, dass die angegebene compileSdk weiter einschränkt, welche Java-Symbole beim Bearbeiten und Erstellen des Quellcodes verfügbar sind.

Wählen Sie eine JDK-Version aus, die höher oder gleich den JDK-Versionen ist, die von Plug-ins verwendet werden, die Sie in Ihrem Gradle-Build verwenden. Die mindestens erforderliche JDK-Version für das Android-Gradle-Plug-in (AGP) finden Sie in der Kompatibilitätstabelle in den Versionshinweisen.

Für das Android-Gradle-Plug-in Version 8.x ist beispielsweise JDK 17 erforderlich. Wenn Sie versuchen, einen Gradle-Build damit mit einer früheren Version des JDK auszuführen, wird eine Meldung wie die folgende angezeigt:

An exception occurred applying plugin request [id: 'com.android.application']
> Failed to apply plugin 'com.android.internal.application'.
   > Android Gradle plugin requires Java 17 to run. You are currently using Java 11.
      Your current JDK is located in /usr/local/buildtools/java/jdk
      You can try some of the following options:
       - changing the IDE settings.
       - changing the JAVA_HOME environment variable.
       - changing `org.gradle.java.home` in `gradle.properties`.

Welche Java-APIs kann ich in meinem Java- oder Kotlin-Quellcode verwenden?

Eine Android-App kann einige der in einem JDK definierten APIs verwenden, aber nicht alle. Das Android SDK definiert Implementierungen vieler Java-Bibliotheksfunktionen als Teil der verfügbaren APIs. Die Eigenschaft compileSdk gibt an, welche Android SDK-Version beim Kompilieren des Kotlin- oder Java-Quellcodes verwendet werden soll.

android {
    ...
    compileSdk = 36
}

android {
    ...
    compileSdk 36
}

Jede Android-Version unterstützt eine bestimmte Version des JDK und eine Teilmenge der verfügbaren Java-APIs. Wenn Sie eine Java-API verwenden, die in einer compileSdk verfügbar ist, die nicht in der angegebenen minSdk verfügbar ist, können Sie die API möglicherweise in der früheren Android-Version über einen Prozess namens Desugaring verwenden. Unter Java 11+-APIs, die über Desugaring verfügbar sind, finden Sie die unterstützten APIs.

In dieser Tabelle können Sie nachsehen, welche Java-Version von welcher Android API unterstützt wird und wo Sie Details zu den verfügbaren Java-APIs finden.

Welches JDK kompiliert meinen Java-Quellcode?

Das JDK der Java-Toolchain enthält den Java-Compiler, der zum Kompilieren von Java-Quellcode verwendet wird. Dieses JDK führt während des Builds auch Javadoc- und Unit-Tests aus.

Die Toolchain verwendet standardmäßig das JDK, das zum Ausführen von Gradle verwendet wird. Wenn Sie die Standardeinstellung verwenden und einen Build auf verschiedenen Computern ausführen (z. B. auf Ihrem lokalen Computer und einem separaten Continuous Integration-Server), können sich die Ergebnisse des Builds unterscheiden, wenn verschiedene JDK-Versionen verwendet werden.

Um einen konsistenteren Build zu erstellen, können Sie explizit eine Java-Toolchain-Version angeben. Wenn Sie dies angeben:

• Wird ein kompatibles JDK auf dem System gesucht, auf dem der Build ausgeführt wird.
  • Wenn kein kompatibles JDK vorhanden ist (und ein Toolchain-Resolver definiert ist), wird eines heruntergeladen.
• Die Java-APIs der Toolchain werden für Aufrufe aus dem Quellcode verfügbar gemacht.
• Java-Quellcode wird mit der Java-Sprachversion kompiliert.
• Standardwerte für sourceCompatibility und targetCompatibility werden bereitgestellt.

Wir empfehlen, immer die Java-Toolchain anzugeben und entweder dafür zu sorgen, dass das angegebene JDK installiert ist, oder einen Toolchain-Resolver zu Ihrem Build hinzuzufügen.

Sie können die Toolchain angeben, unabhängig davon, ob Ihr Quellcode in Java, Kotlin oder beiden Sprachen geschrieben ist. Geben Sie die Toolchain auf der obersten Ebene der Datei build.gradle(.kts) Ihres Moduls an.

So geben Sie die Java-Toolchain-Version an:

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

Dies funktioniert, wenn Ihr Quellcode in Kotlin, Java oder einer Mischung aus beiden Sprachen geschrieben ist.

Die JDK-Version der Toolchain kann mit dem JDK identisch sein, das zum Ausführen von Gradle verwendet wird. Beachten Sie jedoch, dass sie unterschiedliche Zwecke erfüllen.

Welche Java-Sprachfunktionen kann ich in meinem Java-Quellcode verwenden?

Die Eigenschaft sourceCompatibility bestimmt, welche Java-Sprachfunktionen während der Kompilierung von Java-Quellcode verfügbar sind. Sie hat keine Auswirkungen auf Kotlin-Quellcode.

Geben Sie sourceCompatibility in der Datei build.gradle(.kts) Ihres Moduls so an:

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
    }
}

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
    }
}

Wenn diese Eigenschaft nicht angegeben ist, wird standardmäßig die Java-Toolchain Version verwendet. Wenn Sie keine Java-Toolchain verwenden, wird standardmäßig eine Version verwendet, die vom Android-Gradle-Plug-in ausgewählt wurde (z. B. Java 8 oder höher).

Welche binären Java-Funktionen können verwendet werden, wenn ich meinen Kotlin- oder Java-Quellcode kompiliere?

Die Eigenschaften targetCompatibility und jvmTarget bestimmen die Java-Klassenformatversion, die beim Generieren von Bytecode für kompilierten Java- bzw. Kotlin-Quellcode verwendet wird.

Einige Kotlin-Funktionen waren bereits vorhanden, bevor entsprechende Java-Funktionen hinzugefügt wurden. Frühe Kotlin-Compiler mussten eine eigene Möglichkeit erstellen, diese Kotlin-Funktionen darzustellen. Einige dieser Funktionen wurden später zu Java hinzugefügt. Bei späteren jvmTarget-Ebenen kann der Kotlin-Compiler die Java-Funktion direkt verwenden, was zu einer besseren Leistung führen kann.

Verschiedene Android-Versionen unterstützen verschiedene Java-Versionen. Sie können zusätzliche Java-Funktionen nutzen, indem Sie targetCompatibility und jvmTarget erhöhen. Dadurch müssen Sie jedoch möglicherweise auch Ihre Mindestversion des Android SDK erhöhen, um sicherzustellen, dass die Funktion verfügbar ist.

Beachten Sie, dass targetCompatibility größer oder gleich sourceCompatibility sein muss. In der Praxis sollten sourceCompatibility, targetCompatibility und jvmTarget im Allgemeinen denselben Wert verwenden. Sie können sie so festlegen:

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }
    kotlinOptions {
        jvmTarget = "17"
    }
}

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
        targetCompatibility JavaVersion.VERSION_17
    }
    kotlinOptions {
        jvmTarget '17'
    }
}

Wenn diese Eigenschaften nicht angegeben sind, wird standardmäßig die Java-Toolchain Version verwendet. Wenn Sie keine Java-Toolchain verwenden, können sich die Standardwerte unterscheiden und zu Build-Problemen führen. Daher empfehlen wir, diese Werte immer explizit anzugeben oder eine Java-Toolchain zu verwenden.