Impossibile incorporare il bytecode creato con il target JVM 1.8 nel bytecode che viene creato con il target JVM 1.6

Quando si tenta di eseguire CorDapp di esempio ( https://github.com/corda/cordapp-example ) tramite IntelliJ, viene visualizzato il seguente errore:

Impossibile incorporare il bytecode creato con il target JVM 1.8 nel bytecode che viene creato con il target JVM 1.6

Come posso modificare le impostazioni IntelliJ in modo che tutto il bytecode sia creato con lo stesso target JVM?

app / build.gradle

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

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

GL

Utilizzare le funzionalità del linguaggio Java 8

È possibile risolvere questo problema come segue:

• Apri le preferenze di IntelliJ
• Vai a Build, Execution, Deployment> Compiler> Kotlin Compiler MA Other Settings > Kotlin compilerse Android Studio>3.4
• Cambia Target JVM versionin1.8
• Clic Apply

dovresti configurare qualcosa come il seguente in build.gradle

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

Nel mio caso, cambiare semplicemente la versione di Target JVM in questo modo: File> Impostazioni> Kotlin Compiler> Target JVM Version> 1.8 non ha aiutato. Tuttavia, ha risolto l'errore di tempo di compilazione. Ma non è riuscito in fase di esecuzione.

Ho anche dovuto aggiungere il seguente file build.gradle per farlo funzionare.

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

Quando le altre soluzioni non hanno funzionato per te (modifica della versione di JVM nelle impostazioni del compilatore e aggiunta jvmTargetalle tue build.gradle), a causa dei tuoi .imlfile che provano a forzare le loro configurazioni, puoi cambiare la piattaforma di destinazione dalle Impostazioni del progetto.

• Aperto File > Project Structure
• Vai a FacetssottoProject Settings
  • Se è vuoto, fai clic sul piccolo +pulsante
• Fai clic sul tuo modulo / moduli Kotlin
• Cambia Target Platformin JVM 1.8(anche è meglio selezionare l' Use project settingsopzione)

Nel mio caso questo codice non ha funzionato finché non mi sono spostato apply plugin: 'kotlin-android'dal basso verso l'alto.

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"
    }
}

In Android Studio 4.3.2 l'aggiunta tramite la procedura seguente non funziona.

1. Apri le preferenze di IntelliJ
2. Vai a Build, Execution, Deployment > Compiler > Kotlin Compiler MA Altre impostazioni> Kotlin compilatore se Android Studio> 3.4
3. Modificare la versione JVM di destinazione su 1.8
4. Fai clic su Applica

Il motivo è che Android Studio non è in grado di aggiungere il codice seguente nel file Gradle a livello di modulo. Si prega di aggiungerlo manualmente.

kotlinOptions {
    jvmTarget = "1.8"
}

Solo per il componente aggiuntivo, cerca la versione Target JVM nella ricerca di Android Studio. Ti porterà direttamente all'opzione.

Un'immagine vale più di mille parole

Febbraio 2020
android 3.4+
Vai a File -> Impostazioni -> Kotlin Compiler -> Target JVM Version> impostato su 1.8 e quindi assicurati di fare File -> Sincronizza progetto con file Gradle

O aggiungi questo in build.gradle (modulo: app) nel blocco Android :

kotlinOptions {
           jvmTarget = "1.8"
         }

Come è scritto nel using-maven documenti dal sito web di Kotlin:

Devi solo mettere <kotlin.compiler.jvmTarget>1.8</kotlin.compiler.jvmTarget>nella sezione delle proprietà del tuo pom.xml

Se disponi di molti sorgenti / moduli, può essere complicato configurare jvmTarget per ciascuno di essi separatamente.

Puoi configurare jvmTarget per tutti in una volta in questo modo:

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

Questo frammento può essere utilizzato al primo livello del file gradle.build

Dopo aver modificato il file gradle Reimport All Gradle Imports. Per verificare se ha funzionato, apri Project Structuree verifica che IntelliJ sia assegnato correttamente JVM 1.8a tutti i moduli Kotlin. Dovrebbe sembrare come questo:

Vorrei non consiglierei cambiare la piattaforma direttamente in IntelliJ, perché chiunque altro clonazione il progetto per la prima volta è probabile che faccia lo stesso problema. Configurarlo correttamente in gradle ha il vantaggio che IntelliJ si comporterà correttamente per loro fin dall'inizio.

Nel mio caso, ho risolto questo seguendo questi due passaggi

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"
        }
    }

Per me il motivo era che questa configurazione nel mio grado di compilazione era in alcuni moduli e in alcuni non lo era

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

Per Gradle con linguaggio Kotlin ( *.gradle.ktsfile), aggiungi questo:

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

nella maggior parte dei casi questo è sufficiente:

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

se hai dichiarato attività Gradle personalizzate come integrationTestad esempio, aggiungi anche una configurazione per compile<YourTaskName>Kotlin:

compileIntegrationTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}

L'impostazione sourceCompatibility = JavaVersion.VERSION_1_8abilita il desugaring, ma al momento non è in grado di desugar tutte le funzionalità Java 8 utilizzate dal compilatore Kotlin.

Correzione: l'impostazione kotlinOptions.jvmTarget to JavaVersion.VERSION_1_8nel modulo app Gradle avrebbe risolto il problema.

Utilizzare le funzionalità del linguaggio 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"
  }
}

Tutte le risposte qui stanno usando il gradle ma se qualcuno come me finisce qui e ha bisogno di una risposta per 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>

Il cambiamento dall'archetipo di jetbrains per kotlin-jvm è la <configuration></configuration>specificazione di jvmTarget. Nel mio caso 11

Nulla ha funzionato per me fino a quando non ho aggiornato la dipendenza del mio plugin kotlin.
Prova questo:
1. Invalida cahce e riavvia.
2. Sincronizza progetto (almeno prova a)
3. Vai a File -> Struttura del progetto -> Suggerimenti
4. Se c'è un aggiornamento su Kotlin, aggiornalo.
Spero che possa aiutare qualcuno.

Se usi Visual Studio Code ** con estensione Kotlin, vai alla gestione plug-in Crtl + Shift + x, digita kotlin e fai clic su gestisci (la piccola attrezzatura) >> Configura impostazioni estensione

su Kotlin >> Compilatore >> Jvm: Target - digita la versione java. Nella mia situazione ho appena digitato 1.8

E quindi riavviare :-)

** vscode o semplicemente 'code' per Linux

Nel mio caso File> Impostazioni> Kotlin Compiler> Target JVM Version> 1.8

Sto usando Kotlin e Gradle per il normale sviluppo di JVM, (non Android) e questo ha funzionato per me in build.gradle:

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

se sei nel progetto Android

nel build.gradle della tua app sotto 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"
    }
}

Se usi Eclipse supponendo di aver scaricato il plugin Kotlin:

Progetto tasto destro del mouse -> Proprietà -> Kotlin Compiler -> Abilita impostazioni specifiche del progetto -> Versione target JVM "1.8"

Per le versioni recenti di Android Studio, se la modifica della sola versione della Kotlin Target VM non ha funzionato.

File ➞ Struttura del progetto ➞ Moduli ( app): imposta "Compatibilità sorgente" e "Compatibilità target" su "1.8 (Java 8)". Premi "OK" e sincronizza il progetto con Gradle.

Utilizzando il DSL Kotlin Gradle, questo ha risolto il problema per me. Ho aggiunto questo a build.gradle.kts. Questo è in aggiunta alla risposta di Joel

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

Un altro suggerimento per gli utenti di Eclipse. Dopo aver ricontrollato le impostazioni della destinazione jvm segnalate da altri utenti, ho ancora avuto lo stesso problema e questo è stato causato dalla mancanza di Kotlin Runtime Library. Ad esempio, quando si crea un progetto con inizializzazione a molla, non viene aggiunto automaticamente. Per aggiungerlo:, right click on your project -> Build path -> Add libraries... -> User Librarye semplicemente aggiungereorg.jetbrains.kotlin.core.KOTLIN_CONTAINER

Assicurati di aggiornare successivamente il tuo progetto Gradle ( right click -> Gradle -> Refresh gradle project)

Se stai affrontando questo messaggio in un progetto Spring Boot / Kotlin, imposta la proprietà "kotlin.compiler.jvmTarget" su "1.8" nel tuo pom.xml.

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

Nel mio caso, jvmTarget era già impostato nel build.gradlefile come di seguito.

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

Ma il mio problema era ancora lì. Infine, viene risolto dopo aver modificato la versione Target JVM da 1.6 a 1.8 in Preferenze> Altre impostazioni> Kotlin Compiler> Target JVM versione. vedi foto allegata,