Comment réparer java.lang.UnsupportedClassVersionError

1. Introduction

Dans ce court didacticiel, nous allons apprendre ce qui cause l'erreur d'exécution Java java.lang.UnsupportedClassVersionError: version major.minor non prise en charge et comment y remédier.

2. Un regard sur l'erreur

Commençons par regarder un exemple d'erreur:

Exception in thread "main" java.lang.UnsupportedClassVersionError: com/baeldung/MajorMinorApp has been compiled by a more recent version of the Java Runtime (class file version 55.0), this version of the Java Runtime only recognizes class file versions up to 52.0

Cette erreur nous indique que notre classe a été compilée avec une version plus élevée de Java que la version avec laquelle nous avons essayé de l'exécuter. Plus précisément, dans ce cas, nous avons compilé notre classe avec Java 11 et essayé de l'exécuter avec Java 8.

2.1. Numéros de version Java

Pour référence, jetons un coup d'œil aux numéros de version de Java. Cela sera utile au cas où nous aurions besoin de télécharger la version Java appropriée.

Les numéros de version majeurs et mineurs sont stockés dans le bytecode de classe aux octets six et sept.

Voyons comment les numéros de version principaux correspondent aux versions Java:

  • 45 = Java 1.1
  • 46 = Java 1.2
  • 47 = Java 1.3
  • 48 = Java 1.4
  • 49 = Java 5
  • 50 = Java 6
  • 51 = Java 7
  • 52 = Java 8
  • 53 = Java 9
  • 54 = Java 10
  • 55 = Java 11
  • 56 = Java 12
  • 57 = Java 13

3. Correction via la ligne de commande

Voyons maintenant comment nous pouvons résoudre cette erreur lors de l'exécution de Java à partir de la ligne de commande.

Selon notre situation, nous avons deux façons de résoudre cette erreur: compiler notre code pour une version antérieure de Java ou exécuter notre code sur une version plus récente de Java .

La décision finale dépend de notre situation. Si nous devons utiliser une bibliothèque tierce qui a déjà été compilée à un niveau supérieur, notre meilleure option est probablement d'exécuter notre application en utilisant une version plus récente de Java. Si nous emballons une application pour la distribution, il peut être préférable de la compiler vers une version plus ancienne.

3.1. Variable d'environnement JAVA_HOME

Commençons par vérifier comment notre variable JAVA_HOME est définie. Cela nous dira quel JDK est utilisé lorsque nous exécutons javac à partir de notre ligne de commande:

echo %JAVA_HOME% C:\Apps\Java\jdk8-x64

Si nous sommes prêts à passer entièrement à un JDK plus récent, nous pouvons télécharger la version la plus récente et nous assurer que nos variables d'environnement PATH et JAVA_HOME sont définies correctement.

3.2. Exécution d'un nouveau JRE

Revenant à notre exemple, voyons comment nous pouvons résoudre l'erreur en l'exécutant dans une version supérieure de Java. En supposant que nous ayons Java 11 JRE dans C: \ Apps \ jdk-11.0.2 , nous pouvons exécuter notre code avec la commande java fournie avec:

C:\Apps\jdk-11.0.2\bin\java com.baeldung.MajorMinorApp Hello World!

3.3. Compiler avec un ancien JDK

Si nous écrivons une application que nous voulons exécuter jusqu'à une certaine version de Java, nous devons compiler le code pour cette version.

Nous pouvons le faire de trois manières: en utilisant un ancien JDK pour compiler notre code, en utilisant les options -bootclasspath , -source et -target de la commande javac (JDK 8 et plus ancien), ou en utilisant l' option –release (JDK 9 et plus récent).

Let's start by using an older JDK, similarly to how we used a newer JRE for running our code:

C:\Apps\Java\jdk1.8.0_31\bin\javac com/baeldung/MajorMinorApp.java

It's possible to just use -source and -target, but it might still create class files that aren't compatible with an older Java.

To ensure compatibility, we can point -bootclasspath at the rt.jar of the targeted JRE:

javac -bootclasspath "C:\Apps\Java\jdk1.8.0_31\jre\lib\rt.jar" \ -source 1.8 -target 1.8 com/baeldung/MajorMinorApp.java

The above applies mainly to JDK 8 and lower. In JDK 9, the –release parameter was added to replace -source and -target. The –release option supports targets 6, 7, 8, 9, 10, and 11.

Let's use –release to target Java 8:

javac --release 8 com/baeldung/MajorMinorApp.java

Now we can run our code on a Java 8 or higher JRE.

4. Eclipse IDE

Now that we understand the error and the general approach to correcting it, let's take what we've learned and see how we can apply it when working in the Eclipse IDE.

4.1. Changing the JRE

Assuming we already have Eclipse configured with different versions of Java, let's change our project's JRE.

Let's go to our Project properties, then to Java Build Path, and then the Libraries tab. Once there, we'll select the JRE and click Edit:

Now, let's choose Alternate JRE and point to our Java 11 installation:

At this point, our application will run against Java 11.

4.2. Changing the Compiler Level

Let's now look at how we can change our target to a lower level of Java.

First, let's go back to our Project properties, then Java Compiler, and check Enable project specific settings:

Here, we can set our project to compile for earlier versions of Java and customize other compliance settings:

5. IntelliJ IDEA

We can also control the version of Java we're using for compiling and running in IntelliJ IDEA.

5.1. Adding a JDK

Before we do that, we'll see how to add additional JDKs. Let's go to File -> Project Structure -> Platform Settings -> SDKs:

Let's click the plus icon in the middle column, select the JDK from the drop-down, and select our JDK location:

5.2. Changing the JRE

First, we'll look at how to use IDEA to run our project on the newer JRE.

Let's go to Run -> Edit Configurations… and change our JRE to 11:

Now, when we run our project, it will run with the Java 11 JRE.

5.3. Changing the Compiler Level

If we're distributing our application to run on a lower JRE, we need to adjust our compiler level to target the older version of Java.

Let's go to File -> Project Structure… -> Project Settings -> Project and change our Project SDK and Project language level:

We can now build our project, and the class files generated will run on Java 8 and higher.

6. Maven

When we build and package a file in Maven, we can control the version of Java we target.

When using Java 8 or older, we set the source and target for the compiler plugin.

Définissons la source et la cible en utilisant les propriétés du plugin du compilateur:

 1.8 1.8 

Alternativement, nous pouvons définir la source et la cible dans le plugin du compilateur:

  maven-compiler-plugin  1.8 1.8   

Avec l' option –release ajoutée dans Java 9, nous pouvons également configurer cela avec Maven.

Utilisons une propriété de plugin du compilateur pour définir la version :

 8 

Ou nous pouvons configurer le plugin du compilateur directement:

  maven-compiler-plugin  8   

7. Conclusion

Dans ce court article, nous avons appris ce qui cause le message d'erreur java.lang.UnsupportedClassVersionError: Unsupported major.minor version , et comment y remédier.