Impossible d'utiliser le bytecode intégré avec la cible JVM 1.8 dans le bytecode qui est construit avec la cible JVM 1.6

Lorsque j'essaie d'exécuter l'exemple CorDapp ( https://github.com/corda/cordapp-example ) via IntelliJ, je reçois l'erreur suivante:

Impossible d'utiliser le bytecode intégré avec la cible JVM 1.8 dans le bytecode qui est construit avec la cible JVM 1.6

Comment puis-je modifier les paramètres IntelliJ pour que tout le bytecode soit construit avec la même cible JVM?

app / build.gradle

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

    kotlinOptions {
        jvmTarget = JavaVersion.VERSION_1_8.toString()
    }
}

GL

Utiliser les fonctionnalités du langage Java 8

Vous pouvez résoudre ce problème comme suit:

• Ouvrez les préférences IntelliJ
• Aller à Build, Execution, Deployment> Compiler> Kotlin Compiler MAIS Other Settings > Kotlin compilersi Android Studio>3.4
• Remplacez le Target JVM versionpar1.8
• Cliquez sur Apply

vous devez configurer quelque chose comme suit dans build.gradle

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Dans mon cas, changer simplement la version JVM cible comme ceci: Fichier> Paramètres> Compilateur Kotlin> Version JVM cible> 1.8 n'a pas aidé. Cependant, il résout l'erreur de compilation. Mais a échoué à l'exécution.

J'ai également dû ajouter ce qui suit dans le fichier build.gradle de l'application pour le faire fonctionner.

 android {
     // Other code here...
     kotlinOptions {
        jvmTarget = "1.8"
     }
 }

Lorsque les autres solutions n'ont pas fonctionné pour vous (modification de la version de la JVM sur les paramètres du compilateur et ajout jvmTargetà votre build.gradle), en raison de vos .imlfichiers essayant de forcer leurs configurations, vous pouvez changer la plate-forme cible à partir des paramètres du projet.

• Ouvert File > Project Structure
• Aller FacetssousProject Settings
  • S'il est vide, cliquez sur le petit +bouton
• Cliquez sur votre / vos module (s) Kotlin
• Changez le Target Platformen JVM 1.8(il est également préférable de cocher l' Use project settingsoption)

Dans mon cas, ce code n'a pas fonctionné jusqu'à ce que je passe apply plugin: 'kotlin-android'de bas en haut.

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'

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

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Dans Android Studio 4.3.2, l'ajout via la procédure ci-dessous ne fonctionne pas.

1. Ouvrez les préférences IntelliJ
2. Accédez à Build, Execution, Deployment > Compiler > Kotlin Compiler BUT Other Settings> Kotlin compiler if Android Studio> 3.4
3. Changez la version de la JVM cible en 1.8
4. Cliquez sur Appliquer

La raison en est qu'Android Studio n'est pas en mesure d'ajouter le code ci-dessous dans le fichier Gradle au niveau du module. Veuillez l'ajouter manuellement.

kotlinOptions {
    jvmTarget = "1.8"
}

Juste pour l'addon, recherchez la version JVM cible dans la recherche de studio Android. Cela vous amènera directement à l'option.

une image vaut mieux que mille mots

Feb 2020
android 3.4+
Allez dans Fichier -> Paramètres -> Compilateur Kotlin -> Version JVM cible> défini sur 1.8 puis assurez-vous de faire Fichier -> Projet de synchronisation avec les fichiers Gradle

Ou ajoutez-le dans build.gradle (module: app) dans le bloc Android :

kotlinOptions {
           jvmTarget = "1.8"
         }

Comme il est écrit dans les documents using-maven du site Web de Kotlin:

Il vous suffit de mettre <kotlin.compiler.jvmTarget>1.8</kotlin.compiler.jvmTarget>dans la section des propriétés de votre pom.xml

Si vous avez de nombreux jeux de sources / modules, il peut être fastidieux de configurer jvmTarget pour chacun d'eux séparément.

Vous pouvez configurer jvmTarget pour chacun d'eux à la fois comme ceci:

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Cet extrait peut être utilisé au niveau supérieur de votre fichier gradle.build

Après avoir modifié le fichier gradle Reimport All Gradle Imports. Pour vérifier si cela a fonctionné, ouvrez Project Structureet vérifiez que IntelliJ est correctement attribué JVM 1.8à tous les modules Kotlin. Ça devrait ressembler à ça:

Je ne recommanderais pas de changer la plate-forme directement dans IntelliJ, car quiconque clonant votre projet pour la première fois est susceptible de rencontrer le même problème. Le configurer correctement dans gradle a l'avantage qu'IntelliJ va se comporter correctement pour eux dès le début.

Dans mon cas, j'ai résolu cela en suivant ces deux étapes

1. Go to android studio preferences -> other settings -> kotlin compiler -> set Target JVM version = 1.8 
   if it doesn't work then go to the second option.

2. In your module-level build.gradle file add 
   compileOptions {
        sourceCompatibility = 1.8
        targetCompatibility = 1.8
    }
    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
        kotlinOptions {
            jvmTarget = "1.8"
        }
    }

Pour moi, la raison était que cette configuration dans ma version était dans certains modules et dans certains, ce n'était pas

android {  
...      
kotlinOptions {
        val options = this as KotlinJvmOptions
        options.jvmTarget = "1.8"
    }
...
android {

Pour Gradle avec la langue Kotlin ( *.gradle.ktsfichiers), ajoutez ceci:

android {
    [...]
    kotlinOptions {
        this as KotlinJvmOptions
        jvmTarget = "1.8"
    }
}

dans la plupart des cas, cela suffit:

compileKotlin {
    kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}

si vous avez déclaré des tâches Gradle personnalisées comme integrationTestpar exemple, ajoutez également une configuration pour compile<YourTaskName>Kotlin:

compileIntegrationTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}

Le paramètre sourceCompatibility = JavaVersion.VERSION_1_8permet de désugarer, mais il est actuellement incapable de désugarer toutes les fonctionnalités Java 8 que le compilateur Kotlin utilise.

Fix - Le réglage kotlinOptions.jvmTarget to JavaVersion.VERSION_1_8dans le module d'application Gradle résoudrait le problème.

Utilisez les fonctionnalités du langage Java 8: https://developer.android.com/studio/write/java8-support

android {
  ...
  // Configure only for each module that uses Java 8
  // language features (either in its source code or
  // through dependencies).
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
  // For Kotlin projects
  kotlinOptions {
    jvmTarget = "1.8"
  }
}

Toutes les réponses ici utilisent gradle mais si quelqu'un comme moi se retrouve ici et a besoin d'une réponse pour maven:

    <build>
        <sourceDirectory>src/main/kotlin</sourceDirectory>
        <testSourceDirectory>src/test/kotlin</testSourceDirectory>

        <plugins>
            <plugin>
                <groupId>org.jetbrains.kotlin</groupId>
                <artifactId>kotlin-maven-plugin</artifactId>
                <version>${kotlin.version}</version>
                <executions>
                    <execution>
                        <id>compile</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>test-compile</id>
                        <phase>test-compile</phase>
                        <goals>
                            <goal>test-compile</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <jvmTarget>11</jvmTarget>
                </configuration>
            </plugin>
        </plugins>
    </build>

Le changement de l'archétype jetbrains pour kotlin-jvm est la <configuration></configuration>spécification de jvmTarget. Dans mon cas 11

Rien n'a fonctionné pour moi jusqu'à ce que je mette à jour ma dépendance de plugin kotlin.
Essayez ceci:
1. Invalidez cahce et redémarrez.
2. Projet de synchronisation (essayez au moins)
3. Aller fichier -> Structure du projet -> Suggestions
4. S'il y a une mise à jour concernant Kotlin, mettez-la à jour.
J'espère que cela aidera quelqu'un.

Si vous utilisez Visual Studio Code ** avec l'extension Kotlin, allez dans la gestion des plugins Crtl + Shift + x, tapez kotlin et cliquez sur gérer (le petit engrenage) >> Configurer les paramètres d'extension

sur Kotlin >> Compilateur >> Jvm: Target - tapez la version java. Dans ma situation, je viens de taper 1,8

Et puis redémarrez :-)

** vscode ou simplement 'code' pour linux

Dans mon cas, Fichier> Paramètres> Compilateur Kotlin> Version JVM cible> 1.8

J'utilise Kotlin et Gradle pour le développement normal de la JVM, (pas Android) et cela a fonctionné pour moi dans build.gradle:

allprojects {
    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
        kotlinOptions.jvmTarget = JavaVersion.VERSION_11.toString()
    }
}

si vous êtes dans un projet android

dans le build.gradle de votre application sous Android {}

android{
//other configs...
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Si vous utilisez Eclipse en supposant que vous avez téléchargé le plugin Kotlin:

Cliquez avec le bouton droit sur le projet -> Propriétés -> Kotlin Compiler -> Activer les paramètres spécifiques au projet -> Version cible JVM "1.8"

Pour les versions récentes d'Android Studio, si la modification de la version de Kotlin Target VM ne fonctionnait pas.

Fichier Structure Structure du projet ➞ Modules ( app): définissez "Compatibilité source" et "Compatibilité cible" sur "1.8 (Java 8)". Appuyez sur "OK" et synchronisez le projet avec Gradle.

En utilisant le DSL Kotlin Gradle, cela a résolu le problème pour moi. J'ai ajouté ceci au build.gradle.kts. Ceci s'ajoute à la réponse de Joel

val compileKotlin: KotlinCompile by tasks
compileKotlin.kotlinOptions.jvmTarget = JavaVersion.VERSION_1_8.toString()

Un autre indice pour les utilisateurs d'Eclipse. Après avoir revérifié les paramètres cibles jvm signalés par d'autres utilisateurs, j'ai toujours eu le même problème, et cela était dû à la bibliothèque Kotlin Runtime manquante. Par exemple, lors de la création d'un projet avec Spring Initializr, il n'est pas ajouté automatiquement. Pour l'ajouter:, right click on your project -> Build path -> Add libraries... -> User Libraryet ajoutez simplementorg.jetbrains.kotlin.core.KOTLIN_CONTAINER

Assurez-vous de rafraîchir votre projet Gradle par la suite ( right click -> Gradle -> Refresh gradle project)

Si vous êtes confronté à ce message dans un projet Spring Boot / Kotlin, définissez simplement la propriété "kotlin.compiler.jvmTarget" sur "1.8" dans votre pom.xml.

    <properties>
        <kotlin.version>1.3.70</kotlin.version>
        <kotlin.compiler.jvmTarget>1.8</kotlin.compiler.jvmTarget>
    </properties>
    ...

Dans mon cas, jvmTarget était déjà défini dans le build.gradlefichier comme ci-dessous.

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Mais mon problème était toujours là. Enfin, il est résolu après avoir changé la version JVM cible de 1.6 à 1.8 dans Préférences> Autres paramètres> Compilateur Kotlin> Version JVM cible. voir photo ci-jointe,