How Can I Fix Unsupported Class File Major Version 60 In Intellij Idea

        - Download the latest version of JDK (which supports Major Version 60).

        - Change your project settings in IntelliJ IDEA to use the new JDK
      

        - Make sure that your source version and target version matches.

        - Re-compile your Java source files.
      

        - Navigate to the Intellij IDEA file structure.

        - Point JVM settings to the bundled JDK instead of the one in your system.
      

“Unsupported Class File Major Version 60” occurs when you compile a Java source file with a more recent version of the Java Development Kit (JDK) which is not recognized by your compiler or IDE since it’s an older version. Updating your JDK, ensuring your source and target versions match, or using IntelliJ IDEA’s own bundled JDK version usually resolve this issue.

Updating your version of the JDK involves downloading and installing the latest version, then changing your IntelliJ IDEA project settings to use this updated version. This solution ensures active support compatibility by keeping your JDK up-to-date.

Another approach could be to re-compile your Java source files with a target to your current compiler version. This can be done by adjusting the maven compiler plugin setting in your pom.xml file or Gradle settings in build.gradle, depending on what build tool you are using. Re-compiling ensures bytecode compatibility between your source code and JVM.

If you still experience the unsupported major.minor version errors after trying the above steps, you could attempt troubleshooting by using IntelliJ IDEA’s bundled JDK version as it is completely compatible with IntelliJ IDEA itself. You can do this by navigating to “Help -> Edit Custom VM Options…” Then replace the path in `-Djava.home=` to point toward your IntelliJ IDEA’s bundled JKD folder.

To find the location you may follow: “Help -> About -> Click on JBR version”, and you will see the location in the tooltip. But remember, revert this setting back whenever you want your system JDK for compilation, as keeping everything default is generally the best way to prevent inconsistent behavior due to JVM differences.
(Source)First of all, let’s understand what the error message “Unsupported Class File Major Version 60” signifies. In the world of Java, every *.class file starts with a magic number (0xCAFEBABE), followed by version information. The ‘major’ part of that version is what your IntelliJ IDEA complaints about when it prompts you with the said error.

Specifically, the major version number 60 corresponds to JDK 16. So if a class has been compiled with JDK 16, but your current JVM is of a lower version (say, JDK 11 or JDK 8), then this error would arise since your JVM won’t be able to recognize the format of the class files compiled with newer versions.

The quickest fix for “Unsupported Class File Major Version 60 in IntelliJ IDEA” would be to simply increase your JVM’s version to a minimum of 16. You can do so by making changes in your system environment variables or modifying settings within your IntelliJ IDEA.

Here’s how you may change your SDK in IntelliJ Idea Configure:

• Go to the

  File

  dropdown menu.

• Choose

  Project Structure

  .

• In a new window, find and choose

  Project Settings > Project

  .

• For the

  Project SDK

  setting, either choose an existing JDK 16 (or above) or install it.

• If it isn’t there, select

  New..

  and navigate to your installed JDK 16 directory as your new SDK.

• Click OK to confirm your changes.

There are three other techniques that you could apply to get around this issue:

• Downgrade compiler version: You may change the version of your compiler to match the JVM’s version. In IntelliJ IDEA, it can be done in the settings:

  Build, Execution, Deployment > Compiler > Java Compiler

  .

• Use JVM matching the compiler version: If re-compilation isn’t an option, you may have to use a JVM that matches or surpasses the version of the compiler used previously. In Ubuntu, it can be done using the

  update-alternatives

  command.

• Multi-Release Jar Files: Java 9 introduced a feature known as “Multi-Release Jar Files”. This means a single JAR file can contain bytecode for several Java versions. During runtime, JVM will choose the appropriate version.

Every approach has its pros and cons, depending on your specific utilization. However, ensuring synchronization between your JVM version and Java compiler version is most likely the best initial approach.

For official documentation about setting up SDKs in IntelliJ IDEA, refer to this guide by Jetbrains. For additional reading about multi-release JAR files, see this resource by Oracle.com.

Firstly, let’s reflect on what the mentioned error “Unsupported Class File Major Version 60” signifies. This error is related to Java’s compiler version and often occurs when there’s a mismatch between the Java Development Kit (JDK) versions used for compiling a .class file and executing it.

The number ’60’ corresponds to Java SE 16 according to the class file format major version numbers.

In simple words, the code was compiled with JDK 16, but an attempt is being made to run it on a lower JDK version in Intellij Idea. You will experience this because the IntelliJ Idea uses the project settings’ compiler version by default for any Java projects you open or create.

Therefore, to solve this issue, you should match your IDE’s JDK version with the one used by your project. Here’s how you can achieve this:

1. Changing the Project SDK:

Open your Intellij Idea, navigate to:

File -> Project Structure -> Project Settings -> Project

At the top of the form, you’ll see ‘Project SDK’. If it is not set to JDK 16 or later, change it accordingly. The path should look something like “C:\Program Files\Java\jdk-16.0.” based on your installation directory.

2. Changing the Compiler settings:

Besides setting up the project’s SDK, you also need to check the compiler settings. To do so, go to:

File -> Settings -> Build, Execution, Deployment -> Compiler -> Java Compiler

In the target bytecode version, make sure the module reflects the correct version corresponding to your JDK version.

If you do not have the necessary JDK installed in your development environment, you could download it from the official Oracle website.

You also need to be prudent about making JDK 16-specific features when intending to run the program on lower versions. Java provides backward compatibility, i.e., the feature where programs written in older versions can run on newer ones. However, vice versa may not always hold true, particularly if you use language features introduced in newer Java versions.

Please note that different versions of JDK are associated with different class file formats and are introduced with new Java SE’s release. So it’s paramount that we ensure an alignment between the compile-time and runtime JDK versions to prevent such dilemmas in the future. I would recommend always ensuring your development environment matches the production environment to avoid these sorts of version-related issues.

Here is a table for quick reference on mapping class file major version to respective JDK versions:

JDK Version	Class File Format – Major Version
JDK 1.2	46
JDK 1.3	47
JDK 1.4	48
JDK 5	49
JDK 6	50
JDK 7	51
JDK 8	52
JDK 9	53
JDK 10	54
JDK 11	55
JDK 12	56
JDK 13	57
JDK 14	58
JDK 15	59
JDK 16	60
JDK 17	61

The Unsupported Class Version Error occurs when an application has been composed with a more recent Java version and you’re trying to run it on a lower Java version. It’s based on the difference between the Java major versions. To be specific, if you get this error message: “Unsupported major.minor version 60.0,” it means that your application has been compiled with Java 16 (major version 60) while you are trying to run the app in an environment where Java 15 or below is installed.

The root cause of this issue varies:

* You may have different Java versions installed on your computer and IntelliJ IDEA might be configured inadvertently to use a lower version.
* The Project bytecode version in IntelliJ IDEA isn’t matching with the JDK version.
* There may be a mismatch between the JDK version used for compiling the source code and the JVM version deploying the code.

Given that, here’s how you can fix the “Unsupported Class File Major Version 60” error in IntelliJ IDEA:

UPDATE JAVA VERSION IN SYSTEM

Firstly, ensure that the Java version installed on your system matches, or is higher than the one which was used to compile the code. You can upgrade Java to the latest version compatible with your operating system from Oracle’s official Java SE Download page.

$ java -version

This command above will display the Java version installed on your machine.

SET PROPER JDK IN INTELLIJ IDEA

Secondly, confirm that IntelliJ IDEA is accurately configured to use the right JDK for compiling and running your applications. Do the following steps:

* Navigate to File > Project Structure > Project Settings > Project.
* Set the ‘Project SDK’ to the correct JDK version (Java 16).
* Now, set the ‘Project language level’ to the correct level i.e., 16 – ‘Sealed Classes’.
* Click ‘OK’.

CONFIGURE BYTECODE VERSION

Lastly, check the bytecode version of your project is rightly set in IntelliJ IDEA. The bytecode version should match the Java version being used.

* Navigate to File > Settings > Build, Execution, Deployment > Compiler > Java Compiler.
* Under ‘Target bytecode version’, the appropriate value should be selected for each Module. Here, it should point to 16.

Clearing the issue requires properly aligning the compile- and run-time environments. As such, always keep in mind the apps’ required runtime environment. Proactively setting the correct SDK and bytecode versions during development can save quite some troubleshooting time in the future.If you ever find yourself stuck with the “Unsupported Class File Major Version 60” error in IntelliJ IDEA, it likely means that your current JDK (Java Development Kit) configuration does not support Java’s version for which the classes are compiled. In essence, your IDE is using an older version of JDK than that used by the class files. To fix this issue, we need to verify and adjust our project’s JDK configuration.

Verifying Your Project’s JDK Configuration

Let’s start by verifying your existing JDK configuration for your project in IntelliJ IDEA.
To do that, follow these steps:

• Click on

  File > Project Structure

  . This opens the Project Structure dialog box.

• Now, you will navigate towards ‘Project Settings’, then to ‘Project’ and here:
  • You’ll see a field named “Project SDK”. This specifies the JDK being utilized presently.
  • The ‘Project language level’ below the SDK indicates the syntax-based settings which IntelliJ IDEA will permit in your code.

If the project SDK or language level appears greyed out or is set to a lower JDK version, it potentially led to the “Unsupported Class File Major Version 60” error.

Fixing the JDK Version Mismatch

In order to resolve this, ensure that your IntelliJ IDEA project SDK corresponds with the Java version needed by your class files. In the case of “Class File Major Version 60”, this requires JDK 16. Here’s how to adjust your JDK configuration:

• Click

  Add New SDK

  at the top of the Project Structure box.

• Next, pick

  JDK.

• Select the relevant JDK home path. The path usually resembles:

  /Library/Java/JavaVirtualMachines/jdk-16.jdk/Contents/Home

  for Mac users, and

  C:\Program Files\Java\jdk-16\

  for Windows.

Note: If the used JDK does not exist in the system, download and install the appropriate version from Oracle’s official website.

• Adjust your ‘Project Language Level’ to match the JDK version. For JDK 16, choose ’16 – Records, patterns, local interfaces, etc.’.
• Apply these changes.

So, after performing these tasks, the “Unsupported Class File Major Version 60” should no longer surface in IntelliJ IDEA.

Lastly, sometimes incorrect configurations for encoding or compiling could also contribute to such issues. Therefore, I recommend checking out Compiling applications and Configuring individual file encodings sections under JetBrains’ IntelliJ IDEA help guide to avoid such problems in the future.

By meticulously verifying and adjusting your project’s JDK setup, you can streamline your coding experience without grappling with any incongruous version conflicts. Offensive colons removed from linksIf you’re working with IntelliJ IDEA and encounter the unsupported class file major version 60 error, this generally indicates that one or more of your Java files are compiled with a newer version of the Java Compiler, but you are attempting to run them on an older version of Java in IntelliJ IDEA.

The direct solution is to match the versions of the compiler used for creating the bytecode and the JVM (Java Virtual Machine) meant to execute it. This could be possibly achieved by aligning both JRE (Java Runtime Environment) and JDK (Java Development Kit) to use the same version – ideally, the latest.

Determining Your Current JDK Version

Firstly, it can be useful to identify which JDK version you are currently targeting in your IntelliJ IDEA. You can check this using the following steps:

• Go to

  File -> Project Structure...

• In the

  Project

  section, check the

  Project SDK

  field.

The result will reveal which JDK version IntelliJ IDEA attempts to use when running Java applications.

Setting Compiler Settings to Match JDK Version

To avoid the aforementioned error you need to make sure your compiler settings are aligned with your intended JDK version:

• Navigate towards

  File -> Settings -> Build, Execution, Deployment -> Compiler -> Java Compiler.

• In the

  Target bytecode version

  dropdown list for your module, ensure that it matches your selected ‘Project SDK’ version discovered previously.

Updating Your JDK

However, if you still see the unsupported class file major version 60 error, it means you might need to update your JDK to a newer version. This can be done in numerous ways, but broadly involves downloading a new JDK version, installing it on your system, and updating the IntelliJ IDEA’s references to the JDK:

• Once installed, return back to

  File -> Project Structure...

  .

• In the

  SDKs

  subsection, you add a new instance of JDK by pressing ‘+’, and select the directory where you’ve installed the newer version of JDK.

• Select the newer JDK as your

  Project SDK

  .

Update your Maven or Gradle configuration

If you are using build tools like Maven or Gradle, remember to also update their settings. Both of these tools have mechanisms to specify the source and target bytecode versions, which must be compatible with your runtime environment [source,source].

Being aware of your current JDK version, adjusting your compiler settings to match this version, ensuring your Maven/Gradle configurations are set properly, and possibly updating your JDK, are all steps you can take to avoid the “Unsupported class file major version 60” error in IntelliJ IDEA. Following these steps should ensure a seamless coding experience with your chosen JDK version.

java -version

java -version

Sure, let’s dive into the importance of configuring build automation tools like Maven and Gradle, while keeping our focus on how to tackle common configuration issues such as ‘Unsupported Class File Major Version 60’ in IntelliJ IDEA.

Firstly, it’s essential to understand that Maven and Gradle are quintessential tools for modern development routines. By automating the building process, developers can swiftly compile, test, deploy, and distribute apps. They ensure consistency, efficiency, and transparency in creating reliable software systems.

Maven: The Comprehensive Project Management Tool

Regarded as an industry-standard build automation tool, Maven relies on an XML file to describe the project dependencies, final output type, and so forth. However, encountering an ‘Unsupported Class File Major Version 60’ error signifies that the JDK version used to compile source files is higher than what your IntelliJ IDEA supports.

To fix it, follow these steps:

1. Go to

File → Project Structure → Project Settings → Project

.
2. Set the project SDK to align with the Java version you’re using.
3. Rebuild your project by accessing

Build → Rebuild Project

.

Gradle: A Declarative Language With Flexibility

When compared to Maven, Gradle provides a more adaptable environment driven by coding insights rather than rigid conventions. It complements many languages and platforms besides Java, allowing versatile configurations. When facing ‘Unsupported Class File Major Version 60’, the same steps as above can be utilized. But, alternatively with Gradle, you also have the option to specify the source compatibility within your script files directly.

In your build.gradle file, include:

sourceCompatibility = 'version'
targetCompatibility = 'version'

Replace ‘version’ with whatever Java version your specific project requires.

While resolving such JVM errors is important, they inherently point towards improving the integral ways of managing and configuring our build automation tools. These tools streamline the software construction, reducing the probability of human error while saving substantial time and effort.

Therefore, having a profound understanding of Maven and Gradle, their differences, use-cases, and effective configurations is crucial. Efficient utilization of these tools not only assists in tackling configuration issues promptly but also empowers developers to craft high-quality software consistently. Remember, each tool works best in the hand of the experienced user—and for coding, practice genuinely makes perfect!If you’re encountering the “Unsupported major.minor version” error in IntelliJ IDEA, it’s most likely due to having a project configured to run on an older version of Java while using class files compiled with a newer Java compiler. Java is backward compatible but not forward compatible, meaning that higher versions can run code compiled with lower versions, but not vice versa. When operating in a development environment like IntelliJ IDEA, it’s essential to ensure that your Project SDK and Language Level settings match the JDK version used by your project. A specific example to illustrate this is the scenario where you are facing the ‘Unsupported Class File Major Version 60’ error. This indicates that the class file was compiled with JDK 16, and you’re running it on a lower version.

Here is how you can resolve it:

1. The first order of action should be purported towards opening the Project Structure dialog. You can do this via

File > Project Structure

or using the shortcut

Ctrl+Alt+Shift+S

.

2. Once open, navigate to

Project Settings > Project

. Under this tab, you’ll find that you can adjust the SDK (Software Development Kit). Here, set the Project SDK to match the JDK version which corresponds to the major version required – in our case it’s 16. If the necessary SDK isn’t listed, you’ll need to click

New...

and locate the installation directory of the desired JDK.

3. Additionally, set the “Project language level” also to match the JDK version. It means if you’re using `JDK 16`, then you should select `16` in the “Project language level” field [source].

4. Remember, these settings must also align with your module-level settings. Therefore, from the Project Structure dialog, head over to

Project Settings > Modules

. In the Sources tab, check whether the Module SDK and Language Level match what you’ve set at the project level. If they differ, correct them.

5. Once you’ve made these changes, click `OK` and permit IntelliJ IDEA to refresh your project setup. At this point, if your codebase is compatible with the newly selected JDK, the “unsupported major.minor version” error should no longer appear when you build or run your application.

In essence, aligning your IntelliJ IDEA IDE setup with the version of Java complied in the class files will efficiently resolve the `Unsupported Major.Minor version` errors. Keep in mind that each time such an error emerges, always refer back to the appropriate Java version against the highlighted major version [source].Your major version error likely indicates that you’re trying to run code compiled with a different, likely higher, JDK version than the one currently set in your IntelliJ IDEA project. Let me walk you through how to check and adjust your Language Level settings in IntelliJ IDEA so you can resolve this issue.

In IntelliJ IDEA, the “Project Structure” dialog is the go-to place for managing Language Level settings and adjusting them based on your needs. Navigate to it by following these steps:

– Go to the menu bar and select “File”.
– Select “Project Structure”.

You’re now in the dialog where you can view and change the Project Settings, Modules, Libraries and more. Here’s what you’ll need to do next:

1. Click on "Project" under "Project Settings". 
2. You’ll see “Project SDK” and “Project language level” fields.

The Project SDK field controls the JDK version used for your project. If your code was compiled with JDK 16 (which corresponds to Class File Major Version 60) but your Project SDK is set to a lower version, you might get an Unsupported Class File Major Version error. In that case, update the Project SDK to the correct JDK version.

To update the Project SDK:

– Click the dropdown menu in the Project SDK field.
– If the necessary SDK is not listed, click New… and specify the path to the required JDK.

The “Project language level” field relates to the language features allowed within your project. The higher the language level, the more modern language features you can use in your code.

– From the dropdown menu of the “Project language level” field, select the appropriate level corresponding to the required JDK version. For Java 16, select “16 – Switch Expressions, records, pattern matching for instanceof”.

Make sure to hit “Apply” and then “OK” to save your changes.

Remember! Regardless of your project’s JVM version being set to 11 or any older version, if you’re trying to run the bytecode crafted for JVM 16 (Major Version 60), you would get this unsupported version error.

Keep in mind that these changes will only impact your current IntelliJ IDEA project, which offers you flexibility when working across multiple projects requiring different JDK versions.

Understandably, adjusting these settings might initially feel like a complex task. Once you’ve done it a few times, however, you will appreciate how easily IntelliJ IDEA facilitates switching between different Java environments. It’s just one reason why IntelliJ IDEA remains viable as both a software development platform and an Integrated Development Environment (source).

See also

Linux

How To Downgrade Protobuf

If applicable, consider sharing the process of changing the Project SDK and Language Level with your team to ensure that everyone is using compatible versions. This will help avoid future confusions and errors.

When it comes to code examples, there might be no need as this process is more of configuration setup via GUI but not about writing code. Both changing your JDK and Language Level require a few selections from a dropdown menu without necessitating any code adjustments. But understand that choosing higher versions, especially, gives you access to newer features of Java and should reflect in way you will write the code going forward.

To comprehend the unsupported class file major version issue in IntelliJ IDEA, it’s essential to understand the correlation between Project-Specific Solutions and Global Default Settings as they relate to this problem.

Unsupported Class File Major Version 60 Error

This is a common error encountered when your JAVA compiler level isn’t compatible with your project’s bytecode version. Specifically, if you’re getting “unsupported class file major version 60,” you’re probably using a Java version previous to JDK 16, while your project requires JDK 16 or higher.

Here’s how both Project-Specific Solutions and Global Default Settings tie into resolving this:

PROJECT-SPECIFIC SOLUTIONS

In IntelliJ IDEA, each project has its own set of specific settings which include Project SDK and Project language level. These configurations can override the global defaults based on the project’s individual needs.

For instance, if you have multiple projects running on different Java versions, you’d want those versions of Java specified at the project level – an ideal use case for project-specific settings.

The following are steps to adjust these settings:

1. Go to File > Project Structure (Ctrl+Alt+Shift+S)
2. Under Project Settings, select Project
3. Choose the relevant Project SDK from the dropdown. In case the desired SDK isn’t there, click on New… and locate the installation directory of the required SDK.
4. Choose the right Project language level.
5. Click OK to save changes.

Where:

• Project SDK

  : Specifies which Java version a project should use.

• Project language level

  : Determines the Java language features available to the project.

GLOBAL DEFAULT SETTINGS

On the other hand, IntelliJ IDEA also allows general settings meant for all new incoming projects. This includes the default compiler and runtime environment. The main benefit of IRC (IntelliJ Run Configurations) is the ease of setting up uniform behaviour across all projects.

Here’s a guide to configure global defaults:

1. Open IntelliJ IDEA and without any project open, go to Configure > Structure for New Projects.
2. Select the relevant Project SDK under ‘Project SDK’.
3. Select the appropriate Project language level under ‘Project language level’.

Remember that Global Defaults serve as initial settings for new projects. They offer a seamless setup experience when most projects function on the same environment but don’t change existing projects’ settings. However, they can be overridden at the project level if needed to cater to the specific requirements of a project.

Both these configurations aim to optimize coding experiences by offering flexibility to align the development environment based on specific or global needs. Resolving the ‘unsupported class file major version’ error largely depends on correctly matching the Java compiler version to your project’s bytecode version either by setting project-specific solutions or global defaults settings depending upon your particular situation.

Now, it may be possible that some external libraries used in code might still lead to the unsupported major.minor version error. It’s crucial to ensure that all dependencies are compiled using a version no higher than the project’s running version. Tools like enforceBytecodeVersion or animal-sniffer-maven-plugin could come in handy in such cases.

Always remember, knowing the way around your IDE and understanding how to tweak its settings to support your project requirements will assist in handling these troubleshooting scenarios much better.Understanding and combating version errors often require a keen understanding of the different tools involved. If you have been dealing with an error such as “Unsupported class file Major Version 60” in IntelliJ IDEA, chances are you’re dealing with a mismatch in Java versions between your development environment and the project you’re handling.

The first step you need to take in solving this problem is identifying the root cause. To be specific, the error you’re seeing – unsupported class file major version 60 – is related to Java versioning. The number right after “major version,” in this case “60,” refers to the JDK version used. Major version 60 correlates with JDK 16.

Once you’ve identified this, here’s how to address the issue:

1. Check Your Project’s JDK Version

Make sure that your project is using the right JDK. In your IntelliJ IDEA, navigate to

File > Project Structure > Project Settings > Project

. Inspect the JDK version listed under “Project SDK”. Confirm if it matches the JDK version of the codebase you’re working on, which necessary should be JDK 16, since we have identified that from the error.

2. Adjust IntelliJ IDEA JDK for the Project

If there’s a mismatch in JDK versions, you need to align the IntelliJ IDEA JDK with that of your project. In the same settings where you checked for the JDK version, click on

New...

to add a new SDK. Then, point it to your locally installed JDK 16 directory. After setting it up, make it the default for your project.

3. Update Your Local JDK

In some cases, your local JDK might need to be updated. Ensure that you have the correct JDK installed on your machine. If you don’t, download the appropriate version from the official Oracle page (refer to: Oracle Download Page). Following the installation, reflect this change in IntelliJ IDEA as explained above.

4. Gradle or Maven Settings

If you use Maven or Gradle for your project, ensure that the JDK version in their respective files reflects the correct version (JDK 16). For Maven, check the

pom.xml

file, and for Gradle, refer to the

build.gradle

file. You may need to specify the source and target compatibility to be Java 16.

Here is what you would put in your

pom.xml

file for Maven:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <configuration>
                <source>16</source>
                <target>16</target>
            </configuration>
        </plugin>
    </plugins>
</build>

For gradle configure it in

build.gradle

like this:

compileJava {
    sourceCompatibility = '16'
    targetCompatibility = '16'
}

Following these steps should help you correct any version mismatches causing the “Unsupported major.minor version 60.0” exception. Happy coding!The “Unsupported class file major version” error in IntelliJ Idea generally indicates an inconsistency between your Java versions – the one you used to compile your program and the one running your application. Specifically, for a ‘major version 60’, it typically means that your class or JAR was compiled using JDK 16, which is not downwards compatible with previous Java versions.

To rectify this situation, here’s a suite of best practices:

1. Update your JAVA_HOME Environment Variable.

Set your JAVA_HOME environment variable to point towards JDK 16 so the runtime matches the compilation version. Let’s assume you have already installed JDK 16 on your machine, you can configure this environment variable as follows:

  JAVA_HOME=; export JAVA_HOME

2. Update Java Compiler Settings in IntelliJ IDEA.

Next, proceed into IntelliJ IDEA to check your project’s settings, making sure they align with JDK 16. Proceed to:

File -> Project Structure -> Project Settings -> Modules: Select the appropriate module -> Dependencies tab -> Module SDK: Select your installed JDK version.

Note: Apply these changes for all modules in your big projects.

3. Cross-check Maven & Gradle configurations within IntelliJ IDEA.

If you’re using Maven or Gradle in your project, it’s crucial to ensure these build tools mirror your updated Java version:

– Maven: Edit your pom.xml file like this:

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.8.1</version>
      <configuration>
        <source>16</source>
        <target>16</target>
      </configuration>
    </plugin>
  </plugins>
</build>

– Gradle: Modify the build.gradle file like this:

sourceCompatibility = '16'
targetCompatibility = '16'

Ensure the IDE is configured to use the proper version from “Settings > Build, Execution, Deployment > Gradle > Gradle JVM”, as outlined by JetBrains official assistance.

Note: Save and re-import your project after modifying these files.

Eradicating the “Unsupported class file major version ’60’” error requires ensuring uniformity across the various elements involved in your Java environment – the JDK installation, IntelliJ IDEA, Maven, or Gradle. Sticking to these practices will both promptly resolve and help you avoid encountering such discrepancies in the future.

So, if you are grappling with the issue of “Unsupported class file major version 60” in IntelliJ IDEA, don’t fret! This error is common and has been encountered by many developers. Thankfully, they’ve paved the way towards several practical solutions.

The root cause of this error lies in the incompatibility between the JDK version used to compile your code and the JVM’s bytecode interpreter that runs it. To put it simply, you’re trying to run a class that was compiled with a higher version of Java than what is currently being used by the application. Now, here’s how we can solve this hiccup.

Method 1: Upgrade Your JDK

The simplest and most straightforward approach would be to upgrade your JDK (Java Development Kit). Here’s an illustrative snippet:

// Go to Project Structure (Ctrl+Alt+Shift+S on Windows/Linux, ⌘; on macOS)
// Under Project Settings, Select Project
// Change the Project SDK to a higher version (preferably identical to the one used to compile the .class file)
// Once done, click Apply, followed by OK

Make sure to download and install the corresponding JDK if you don’t already have it installed.

Method 2: Recompile The Classes With a Lower JDK Version

If upgrading the JDK isn’t a viable option for you, you could choose to recompile your classes using a lower JDK version. Here’s a guide on how to turn the tide:

// Go to File > Settings > Build, Execution, Deployment > Compiler > Java Compiler
// Change the Target bytecode version for your module(s) to match your current JDK
// Ensure to Rebuild project once changes are made

Your situation might dictate the option you choose. However, keep in mind that upgrading the JDK allows you to utilize more recent Java features.

This StackOverflow link provides a comprehensive list of Java Class File Format Major Version numbers that could guide you in selecting which JDK version to go for.

In essence, resolving the ‘Unsupported Class file major version 60′ error in IntelliJ IDEA might involve either upgrading the JDK or recompiling your files with a lower JDK version. Notably, aligning your development tools’ versions fosters consistency and saves you from potential future issues tied to versioning compatibility.