Que votre code source soit écrit en Java, Kotlin ou les deux, vous devez choisir une version JDK ou Java pour votre compilation à plusieurs endroits.
Glossaire
- Java Development Kit (JDK)
- Le kit de développement Java (JDK) contient les éléments suivants :
- Des outils tels qu'un compilateur, un profileur et un créateur d'archives Ils sont utilisés en arrière-plan lors de la compilation pour créer votre application.
- Bibliothèques contenant des API que vous pouvez appeler à partir de votre code source Kotlin ou Java. Notez que toutes les fonctions ne sont pas disponibles sur Android.
- La machine virtuelle Java (JVM), un interpréteur qui exécute des applications Java. Vous utilisez la JVM pour exécuter l'IDE Android Studio et l'outil de compilation Gradle. La JVM n'est pas utilisée sur les appareils ni sur les émulateurs Android.
- Environnement d'exécution JetBrains (JBR)
- L'environnement d'exécution JetBrains Runtime (JBR) est un JDK amélioré, distribué avec Android Studio. Il inclut plusieurs optimisations à utiliser dans Studio et dans les produits JetBrains associés, mais il peut également servir à exécuter d'autres applications Java.
Comment choisir un JDK pour exécuter Android Studio ?
Nous vous recommandons d'utiliser le JBR pour exécuter Android Studio. Il est déployé avec et utilisé pour tester Android Studio et inclut des améliorations pour une utilisation optimale d'Android Studio. Pour ce faire, ne définissez pas la variable d'environnement STUDIO_JDK
.
Les scripts de démarrage d'Android Studio recherchent une JVM dans l'ordre suivant:
- Variable d'environnement
STUDIO_JDK
- Répertoire
studio.jdk
(dans la distribution Android Studio) jbr
(JetBrains Runtime), dans la distribution Android Studio. Recommandé- Variable d'environnement
JDK_HOME
- Variable d'environnement
JAVA_HOME
- Exécutable
java
dans la variable d'environnementPATH
Comment choisir le JDK qui exécute mes compilations Gradle ?
Si vous exécutez Gradle à l'aide des boutons d'Android Studio, le JDK défini dans les paramètres d'Android Studio est utilisé pour exécuter Gradle. Si vous exécutez Gradle dans un terminal, à l'intérieur ou à l'extérieur d'Android Studio, la variable d'environnement JAVA_HOME
(si elle est définie) détermine le JDK qui exécute les scripts Gradle. Si JAVA_HOME
n'est pas défini, il utilise la commande java
sur votre variable d'environnement PATH
.
Pour obtenir des résultats plus cohérents, veillez à définir votre variable d'environnement JAVA_HOME
et la configuration du JDK Gradle dans Android Studio sur ce même JDK.
Lors de l'exécution de votre compilation, Gradle crée un processus appelé daemon pour effectuer la compilation proprement dite. Ce processus peut être réutilisé, à condition que les builds utilisent la même version du JDK et de Gradle. La réutilisation d'un daemon réduit le temps de démarrage d'une nouvelle JVM et d'initialisation du système de compilation.
Si vous lancez des compilations avec différentes versions de JDK ou de Gradle, des daemons supplémentaires sont créés, ce qui consomme plus de processeur et de mémoire.
Configuration du JDK Gradle dans Android Studio
Pour modifier la configuration JDK Gradle du projet existant, ouvrez les paramètres Gradle depuis File (ou Android Studio sous macOS) > Settings > Build, Execution, Deployment > Build Tools > Gradle (Paramètres > Compilation, exécution, déploiement > Outils de compilation > Gradle). La liste déroulante Gradle JDK (JDK Gradle) contient les options suivantes:
- Macros telles que
JAVA_HOME
etGRADLE_LOCAL_JAVA_HOME
- Entrées de la table JDK au format
vendor-version
, commejbr-17
, qui sont stockées dans les fichiers de configuration Android. - Téléchargement d'un JDK
- Ajouter un JDK spécifique
- JDK détectés localement à partir du répertoire d'installation par défaut du système d'exploitation
L'option sélectionnée est stockée dans l'option gradleJvm
du fichier .idea/gradle.xml
du projet, et sa résolution de chemin d'accès JDK est utilisée pour exécuter Gradle au démarrage via Android Studio.
Les macros permettent la sélection dynamique du chemin d'accès au JDK du projet:
JAVA_HOME
: utilise la variable d'environnement portant le même nom.GRADLE_LOCAL_JAVA_HOME
: utilise la propriétéjava.home
dans le fichier.gradle/config.properties
, qui correspond par défaut à l'environnement d'exécution JetBrains.
Le JDK sélectionné est utilisé pour exécuter votre build Gradle et résoudre les références de l'API JDK lorsque vous modifiez vos scripts de compilation et votre code source. Notez que le compileSdk
spécifié limite davantage les symboles Java disponibles lors de la modification et de la création du code source.
Veillez à choisir une version du JDK supérieure ou égale aux versions du JDK utilisées par les plug-ins que vous utilisez dans votre build Gradle. Pour déterminer la version minimale requise du JDK pour le plug-in Android Gradle (AGP), consultez le tableau de compatibilité dans les notes de version.
Par exemple, le plug-in Android Gradle 8.x nécessite JDK 17. Si vous essayez d'exécuter un build Gradle qui l'utilise avec une version antérieure du JDK, un message du type suivant s'affiche:
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/jdk11
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`.
Quelles API Java puis-je utiliser dans mon code source Java ou Kotlin ?
Une application Android peut utiliser certaines API définies dans un JDK, mais pas toutes. Le SDK Android définit les implémentations de nombreuses fonctions de la bibliothèque Java dans le cadre de ses API disponibles. La propriété compileSdk
spécifie la version du SDK Android à utiliser lors de la compilation de votre code source Kotlin ou Java.
Kotlin
android {
...
compileSdk = 33
}
Groovy
android {
...
compileSdk 33
}
Chaque version d'Android est compatible avec une version spécifique du JDK et un sous-ensemble de ses API Java disponibles. Si vous utilisez une API Java disponible dans un compileSdk
qui n'est pas disponible dans l'minSdk
spécifié, vous pourrez peut-être utiliser l'API dans la version antérieure d'Android via un processus appelé désucrage.
Pour connaître les API compatibles, consultez la section API Java 11 et versions ultérieures disponibles via le désucrage.
Utilisez ce tableau pour déterminer quelle version de Java est compatible avec chaque API Android et où trouver des informations sur les API Java disponibles.
Android | Java | API et fonctionnalités linguistiques compatibles |
---|---|---|
14 (API 34) | 17 | Bibliothèques principales |
13 (API 33) | 11 | Bibliothèques principales |
12 (API 32) | 11 | API Java |
11 et versions antérieures | Versions d'Android |
Quel JDK compile mon code source Java ?
Le JDK de la chaîne d'outils Java contient le compilateur Java permettant de compiler tout code source Java. Ce JDK exécute également des tests javadoc et unitaires pendant la compilation.
La chaîne d'outils utilise par défaut le JDK utilisé pour exécuter Gradle. Si vous utilisez la valeur par défaut et exécutez une compilation sur différentes machines (par exemple, votre ordinateur local et un serveur d'intégration continue distinct), les résultats de votre compilation peuvent différer si différentes versions du JDK sont utilisées.
Pour créer une compilation plus cohérente, vous pouvez spécifier explicitement une version de chaîne d'outils Java. Spécification:
- Localise un JDK compatible sur le système exécutant la compilation.
- Si aucun JDK compatible n'existe (et qu'un résolveur de chaîne d'outils est défini), téléchargez-en un.
- Il expose les API Java de la chaîne d'outils pour les appels à partir du code source.
- Compile le code source Java à l'aide de sa version de langage Java.
- Fournit les valeurs par défaut pour
sourceCompatibility
ettargetCompatibility
.
Nous vous recommandons de toujours spécifier la chaîne d'outils Java et de vous assurer que le JDK spécifié est installé ou d'ajouter un résolveur de chaîne d'outils à votre build.
Vous pouvez spécifier la chaîne d'outils si votre code source est écrit en Java, Kotlin ou les deux. Spécifiez la chaîne d'outils au niveau supérieur du fichier build.gradle(.kts)
de votre module.
Si votre code source n'est écrit qu'en Java, spécifiez la version de la chaîne d'outils Java comme suit:
Kotlin
java {
toolchain {
languageVersion.set(JavaLanguageVersion.of(17))
}
}
Groovy
java {
toolchain {
languageVersion = JavaLanguageVersion.of(17)
}
}
Si votre source est uniquement du Kotlin ou une combinaison de Kotlin et Java, spécifiez la version de la chaîne d'outils Java comme suit:
Kotlin
kotlin {
jvmToolchain(17)
}
Groovy
kotlin {
jvmToolchain 17
}
La version du JDK de la chaîne d'outils peut être identique à celle utilisée pour exécuter Gradle, mais gardez à l'esprit qu'elle a des objectifs différents.
Quelles fonctionnalités sources du langage Java puis-je utiliser dans mon code source Java ?
La propriété sourceCompatibility
détermine les fonctionnalités du langage Java disponibles lors de la compilation du code source Java.
Cela n'affecte pas la source Kotlin.
Si aucune valeur n'est spécifiée, la chaîne d'outils Java ou le JDK utilisés pour exécuter Gradle sont définis par défaut. Nous vous recommandons de toujours spécifier explicitement une chaîne d'outils (recommandé) ou sourceCompatibility
.
Spécifiez sourceCompatibility
dans le fichier build.gradle(.kts)
de votre module.
Kotlin
android {
compileOptions {
sourceCompatibility = JavaVersion.VERSION_17
}
}
Groovy
android {
compileOptions {
sourceCompatibility JavaVersion.VERSION_17
}
}
Quelles fonctionnalités binaires Java peuvent être utilisées lorsque je compile ma source Kotlin ou Java ?
La spécification de targetCompatibility
et jvmTarget
détermine la version au format de classe Java utilisée lors de la génération du bytecode pour les sources Java et Kotlin compilées, respectivement.
Certaines fonctionnalités Kotlin existaient avant l'ajout de fonctionnalités Java équivalentes.
Les premiers compilateurs Kotlin devaient créer leur propre façon de représenter ces caractéristiques Kotlin. Certaines de ces fonctionnalités ont été ajoutées par la suite à Java.
Avec les niveaux jvmTarget
ultérieurs, le compilateur Kotlin peut utiliser directement la fonctionnalité Java, ce qui peut améliorer les performances.
targetCompatibility
est défini par défaut sur la même valeur que sourceCompatibility
, mais, s'il est spécifié, il doit être supérieur ou égal à sourceCompatibility
.
jvmTarget
est défini par défaut sur la version de la chaîne d'outils.
Les différentes versions d'Android prennent en charge différentes versions de Java. Vous pouvez profiter de fonctionnalités Java supplémentaires en augmentant targetCompatibility
et jvmTarget
, mais cela peut vous obliger à augmenter la version minimale du SDK Android pour vous assurer que la fonctionnalité est disponible.
Kotlin
android {
compileOptions {
targetCompatibility = JavaVersion.VERSION_17
}
kotlinOptions {
jvmTarget = "17"
}
}
Groovy
android {
compileOptions {
targetCompatibility JavaVersion.VERSION_17
}
kotlinOptions {
jvmTarget '17'
}
}