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 ein JDK oder eine Java-Sprachversion für Ihren Build auswählen.

Abbildung 1. JDK-Beziehungen in einem Build

Glossar

Java Development Kit (JDK)

Das Java Development Kit (JDK) enthält:

• Tools wie Compiler, Profiler und Archivierungstool. Sie 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 auf Android verfügbar.
• 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 auf Android-Geräten oder ‑Emulatoren nicht verwendet.

JetBrains Runtime (JBR)

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

Wie wähle ich ein JDK für die Ausführung von Android Studio aus?

Wir empfehlen, Android Studio mit dem JBR auszuführen. Es wird mit Android Studio bereitgestellt und zum Testen von Android Studio verwendet. Außerdem enthält es Verbesserungen für die 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. studio.jdk-Verzeichnis (in der Android Studio-Distribution)
3. jbr-Verzeichnis (JetBrains-Laufzeit) in der Android Studio-Distribution. Empfohlen.
4. Umgebungsvariable JDK_HOME
5. Umgebungsvariable JAVA_HOME
6. java-Ausführungsdatei in der Umgebungsvariable PATH

Wie wähle ich aus, welche JDK für meine Gradle-Builds verwendet wird?

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

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

Hinweis :Wenn Sie einen Gradle-Befehl im Android Studio-Terminal ausführen, indem Sie mit der rechten Maustaste klicken und Hervorgehobenen Befehl ausführen auswählen, wird das JDK in den Android Studio-Einstellungen verwendet, nicht JAVA_HOME.

Wenn Sie Ihren Build ausführen, erstellt Gradle einen Prozess, der als Daemon bezeichnet wird, 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 beanspruchen.

Tipp :Wenn Sie gleichzeitig an mehreren Projekten arbeiten, sollten Sie nach Möglichkeit dieselbe Gradle-Version in der gradle-wrapper.properties-Datei angeben, um die Anzahl der erstellten Gradle-Daemons zu reduzieren.

Gradle-JDK-Konfiguration in Android Studio

Wenn Sie die Gradle-JDK-Konfiguration des vorhandenen Projekts ändern möchten, öffnen Sie die Gradle-Einstellungen über Datei (oder Android Studio unter macOS) > Einstellungen > Build, Execution, Deployment > 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 Format vendor-version 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 .idea/gradle.xml-Datei des Projekts gespeichert. Der zugehörige JDK-Pfad wird verwendet, um Gradle auszuführen, wenn es über Android Studio gestartet wird.

Abbildung 2. Gradle JDK-Einstellungen in Android Studio.

Die Makros ermöglichen die dynamische Auswahl des Projekt-JDK-Pfads:

• 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-Laufzeit festgelegt ist.

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

Hinweis :In den meisten Fällen empfehlen wir die Verwendung von GRADLE_LOCAL_JAVA_HOME, da dies die Standardeinstellung für neu erstellte Projekte ist. So können Sie ein projektspezifisches JDK definieren, ohne das Projekt zuerst zu öffnen.

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

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

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-Anwendung kann einige der in einem JDK definierten APIs verwenden, aber nicht alle. Das Android SDK definiert Implementierungen vieler Java-Bibliotheksfunktionen als Teil seiner verfügbaren APIs. Mit dem Attribut compileSdk wird angegeben, welche Android SDK-Version beim Kompilieren Ihres Kotlin- oder Java-Quellcodes verwendet werden soll.

Kotlin

android {
    ...
    compileSdk = 33
}

Groovy

android {
    ...
    compileSdk 33
}

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

In dieser Tabelle sehen Sie, welche Java-Version von den einzelnen Android-APIs unterstützt wird und wo Sie Details zu den verfügbaren Java-APIs finden.

Android	Java	Unterstützte API- und Sprachfunktionen
14 (API 34)	17	Kernbibliotheken
13 (API 33)	11	Kernbibliotheken
12 (API 32)	11	Java API
11 und niedriger		Android-Versionen

Welches JDK wird zum Kompilieren meines Java-Quellcodes verwendet?

Das JDK der Java-Toolchain enthält den Java-Compiler, der zum Kompilieren von Java-Quellcode verwendet wird. Mit diesem JDK werden während des Builds auch javadoc- und Unit-Tests ausgeführt.

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 auf einem separaten Server für die kontinuierliche Integration), können sich die Ergebnisse Ihres Builds unterscheiden, wenn verschiedene JDK-Versionen verwendet werden.

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

• Sucht auf dem System, auf dem der Build ausgeführt wird, nach einem kompatiblen JDK.
  • Wenn kein kompatibles JDK vorhanden ist (und ein Toolchain-Resolver definiert ist), wird eines heruntergeladen.
• Stellt die Toolchain-Java-APIs für Aufrufe aus dem Quellcode bereit.
• Kompiliert Java-Quellcode mit der entsprechenden Java-Sprachversion.
• Liefert Standardwerte für sourceCompatibility und targetCompatibility.

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:

Kotlin

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

Groovy

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

Das funktioniert, wenn Ihre Quelle Kotlin, Java oder eine Mischung aus beidem ist.

Die JDK-Version der Toolchain kann mit der JDK-Version übereinstimmen, die zum Ausführen von Gradle verwendet wird. Sie dienen jedoch unterschiedlichen Zwecken.

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

Mit der Eigenschaft sourceCompatibility wird festgelegt, welche Java-Sprachfunktionen während der Kompilierung von Java-Quellcode verfügbar sind. Dies hat keine Auswirkungen auf den Kotlin-Quellcode.

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

Kotlin

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
    }
}

Groovy

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
    }
}

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

Hinweis :Ab Android Studio Giraffe wird die Option sourceCompatibility beim Importieren von Projekten auch standardmäßig für die IDE-Codeunterstützung und das Linting beim Schreiben von Java-Quellcode verwendet. Für einige Java-Sprachfunktionen ist eine Bibliotheksunterstützung erforderlich und sie sind auf Android nicht verfügbar. Mit der Option compileSdk wird festgelegt, welche Bibliotheken verfügbar sind. Für andere Funktionen wie Switch-Ausdrücke ist nur der Java-Compiler erforderlich und sie funktionieren unter Android.

Welche Java-Binärfunktionen können verwendet werden, wenn ich meinen Kotlin- oder Java-Quellcode kompiliere?

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

Einige Kotlin-Funktionen gab es, bevor entsprechende Java-Funktionen hinzugefügt wurden. Frühe Kotlin-Compiler mussten eine eigene Möglichkeit schaffen, diese Kotlin-Funktionen darzustellen. Einige dieser Funktionen wurden später in Java eingeführt. 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 aber möglicherweise auch die Mindest-Android-SDK-Version erhöhen, damit die Funktion verfügbar ist.

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

Kotlin

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

Groovy

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

Wenn nichts angegeben ist, wird standardmäßig die Version der Java-Toolchain verwendet. Wenn Sie keine Java-Toolchain verwenden, können die Standardwerte abweichen und Build-Probleme verursachen. Daher empfehlen wir, diese Werte immer explizit anzugeben oder eine Java-Toolchain zu verwenden.