Java-Versionen in Android-Builds

Unabhängig davon, ob Ihr Quellcode in Java, Kotlin oder beidem 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 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. Nicht alle Funktionen sind auf Android-Geräten 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 nicht auf Android-Geräten oder -Emulatoren verwendet.

JetBrains Runtime (JBR)

Die JetBrains Runtime (JBR) ist ein erweitertes JDK, das mit Android Studio bereitgestellt wird. Es 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, die JBR zum Ausführen von Android Studio zu verwenden. Er wird mit Android Studio bereitgestellt und zum Testen verwendet. Außerdem enthält er Verbesserungen für die optimale Nutzung von Android Studio. Legen Sie dazu die Umgebungsvariable STUDIO_JDK nicht fest.

Die Startscripts 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 Runtime) in der Android Studio-Distribution. Empfohlen.
4. Umgebungsvariable JDK_HOME
5. Umgebungsvariable JAVA_HOME
6. Ausführbare java-Datei in der Umgebungsvariablen 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 innerhalb oder außerhalb von Android Studio ausführen, bestimmt die Umgebungsvariable JAVA_HOME (falls festgelegt), welches JDK die Gradle-Skripts ausführt. Wenn JAVA_HOME nicht festgelegt ist, wird der Befehl java für die Umgebungsvariable PATH verwendet.

Die besten Ergebnisse erzielen Sie, wenn Sie die Umgebungsvariable JAVA_HOME und die Gradle-JDK-Konfiguration in Android Studio auf dasselbe JDK festlegen.

Wenn Sie den Build ausführen, erstellt Gradle einen Prozess, der als Daemon bezeichnet wird, um den eigentlichen Build auszuführen. Dieser Prozess kann wiederverwendet werden, solange die Builds dieselbe JDK- und Gradle-Version verwenden. Durch die Wiederverwendung eines Daemons wird die Zeit zum Starten einer neuen JVM und zum Initialisieren des Build-Systems verkürzt.

Wenn Sie Builds mit unterschiedlichen 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 Datei (oder Android Studio unter macOS) > 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 Format vendor-version wie jbr-17, die in den Android-Konfigurationsdateien gespeichert sind
• JDK herunterladen
• Bestimmtes JDK hinzufügen
• Lokal erkannte JDKs aus dem Standard-JDK-Installationsverzeichnis des Betriebssystems

Die ausgewählte Option wird in der Option gradleJvm in der Datei .idea/gradle.xml des Projekts gespeichert. Die JDK-Pfadauflösung 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 das Attribut java.home in der Datei .gradle/config.properties, die standardmäßig die JetBrains-Laufzeit 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 die Java-Symbole, die beim Bearbeiten und Erstellen Ihres Quellcodes verfügbar sind, weiter einschränkt.

Wählen Sie eine JDK-Version aus, die höher als oder gleich den JDK-Versionen ist, die von Plug-ins in Ihrem Gradle-Build verwendet werden. 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, der diese Version verwendet, 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. Mit dem Attribut compileSdk wird angegeben, 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 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 Entzuckerung verwenden. Eine Liste der unterstützten APIs findest du unter Über Entzuckerung verfügbare Java 11+-APIs.

In dieser Tabelle sehen Sie, welche Java-Version von der jeweiligen 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 Unittests 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 die Ergebnisse Ihres Builds abweichen, wenn unterschiedliche JDK-Versionen verwendet werden.

Wenn Sie einen konsistenteren Build erstellen möchten, können Sie explizit eine Java-Toolchain-Version angeben. Wenn Sie Folgendes angeben:

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

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

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

Geben Sie die Java-Toolchain-Version so an:

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

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. Beachten Sie jedoch, dass sie unterschiedliche Zwecke erfüllen.

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

Das Attribut sourceCompatibility bestimmt, welche Java-Sprachfunktionen während der Kompilierung der Java-Quelle verfügbar sind. Dies wirkt sich nicht auf Kotlin-Quellcode aus.

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

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
    }
}

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 vom Android-Gradle-Plug-in ausgewählte Version verwendet (z. B. Java 8 oder höher).

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

Mit dem Attribut targetCompatibility wird die Java-Klassenformatversion festgelegt, die beim Generieren von Bytecode für kompilierten Java- und Kotlin-Quellcode verwendet wird.

Einige Kotlin-Funktionen gab es bereits, bevor entsprechende Java-Funktionen hinzugefügt wurden. Frühe Kotlin-Compiler mussten eine eigene Methode zur Darstellung dieser Kotlin-Funktionen entwickeln. Einige dieser Funktionen wurden später in Java hinzugefügt. Bei höheren targetCompatibility-Stufen verwendet der Kotlin-Compiler möglicherweise direkt das Java-Feature, was zu einer besseren Leistung führen kann.

Verschiedene Android-Versionen unterstützen unterschiedliche Java-Versionen. Sie können zusätzliche Java-Funktionen nutzen, indem Sie targetCompatibility erhöhen. Möglicherweise müssen Sie dann aber auch die Android SDK-Mindestversion erhöhen, damit die Funktion verfügbar ist.

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

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }
}

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
        targetCompatibility JavaVersion.VERSION_17
    }
}

Wenn Sie eine Kotlin-Version vor 2.2 verwenden, müssen Sie auch kotlinOptions festlegen:

android {
    kotlinOptions {
        jvmTarget = "17"
    }
}

android {
    kotlinOptions {
        jvmTarget = "17"
    }
}

Wenn nichts angegeben ist, werden diese Attribute standardmäßig auf die Version der Java-Toolchain gesetzt. 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.