Getting Android Studio+jdk working correctly starts with choosing Java versions that match your project’s build tools. Installing another JDK without checking compatibility can leave you with the same error—or introduce a new one.
Android Studio includes JetBrains Runtime, an enhanced JDK. However, the Java runtime used by the editor and the one selected for your project’s build can differ. Google recommends the bundled runtime for running Android Studio itself. developer.android.com
This guide explains how to check your configuration, choose a compatible JDK, and troubleshoot Java-related build failures without repeatedly reinstalling your development environment.
Understand What Each Component Does
Before changing settings, identify which part of the development environment needs attention.
| Component | Purpose |
|---|---|
| Android Studio | The application where you edit and manage your Android project |
| JDK | Java development tools, including a compiler and runtime |
| JetBrains Runtime | The enhanced JDK bundled with Android Studio |
| Gradle | The build system that executes project tasks |
| Android Gradle Plugin | The plugin that adds Android-specific build functionality |
| Java toolchain | The JDK selected for supported compilation and testing tasks |
These components work together, but their version numbers do not need to match.
A useful distinction is between running the build system and compiling your application. Gradle’s Java toolchains let you select a compiler independently of the JVM running Gradle. Changing source or target compatibility alone does not change Gradle’s runtime. docs.gradle.org
How to Choose a Compatible JDK
Start with your existing project’s requirements.
Check:
- The Android Gradle Plugin version.
- The Gradle version specified by the project’s wrapper.
- The Java versions supported by both.
The wrapper configuration is normally located at:
gradle/wrapper/gradle-wrapper.propertiesLook for the version inside distributionUrl. The Android Gradle Plugin version may appear in the project’s build configuration or a version catalog.
Check Gradle Compatibility Before Upgrading Java
The official Gradle Java compatibility matrix distinguishes Java support for running Gradle from support for compilation through toolchains.
For example:
| Java version | Gradle support for running on that version |
|---|---|
| Java 17 | Gradle 7.3 and later |
| Java 21 | Gradle 8.5 and later |
These entries describe Gradle runtime compatibility. Your Android Gradle Plugin and other plugins impose additional requirements. A compatible Java–Gradle pairing does not automatically make the complete Android project compatible. docs.gradle.org
Treat JDK 17 as a Version-Specific Requirement
Android Gradle Plugin 8.0 requires JDK 17 and Gradle 8.0 as minimum versions. That provides a concrete example of why upgrading only one component can break a build. developer.android.com
For a project using another AGP release, check that release’s requirements. Avoid treating “install Java 17” or “install the newest Java” as a universal solution.
For existing applications, my recommendation is to restore a documented compatible combination first. Plan broader upgrades after the project builds successfully.
Configure Android Studio+jdk for Your Project
Select the Project’s Gradle JDK
For projects using the traditional Gradle JDK setting:
- Open your project in Android Studio.
- Open Settings.
- Navigate to Build, Execution, Deployment → Build Tools → Gradle.
- Select a compatible Gradle JDK.
- Apply the change and sync the project.
On macOS, open Settings from the Android Studio menu.
Consult Google’s Java versions in Android builds documentation for the available options. New projects created with Android Studio Panda 1 or later use Gradle Daemon JVM criteria by default, so their configuration can differ from older tutorials. developer.android.com
Check Daemon JVM Criteria
If your project contains:
gradle/gradle-daemon-jvm.propertiesinspect it before repeatedly changing environment variables.
Configured Daemon JVM criteria take precedence over both JAVA_HOME and org.gradle.java.home. This explains why changing your terminal’s Java installation may not change the JVM that performs the build. docs.gradle.org
Keep the project’s intended configuration consistent across developer computers and continuous integration environments.
Set JAVA_HOME and Verify the Result
JAVA_HOME identifies the Java installation used to launch Gradle’s client. A separate Gradle property or Daemon JVM criteria can select a different build JVM. docs.gradle.org
Point JAVA_HOME to the JDK’s root directory, rather than its bin directory.
The examples below use placeholder paths. Replace them with your actual compatible JDK location.
Windows PowerShell
For the current PowerShell session:
$env:JAVA_HOME = "C:\Path\To\Your\JDK"
$env:Path = "$env:JAVA_HOME\bin;$env:Path"
java -version
javac -version
.\gradlew.bat --versionRun the wrapper command from the project root.
For a persistent configuration, update Windows environment variables and reopen your terminal afterward.
macOS and Linux
For the current shell session:
export JAVA_HOME="/path/to/your/jdk"
export PATH="$JAVA_HOME/bin:$PATH"
java -version
javac -version
./gradlew --versionOn macOS, a JDK installation may use a home directory ending in Contents/Home.
Compare the Java information reported by the shell with the JVM information reported by Gradle. A successful java -version check alone does not establish which runtime performs your build.
For property overrides and environment precedence, refer to the official Gradle build environment documentation. docs.gradle.org
Keep the Compiler Configuration Separate
A Java toolchain makes the compiler requirement explicit. For example, a project that intentionally compiles with Java 17 can declare:
java {
toolchain {
languageVersion = JavaLanguageVersion.of(17)
}
}Use this only where the project’s plugin configuration supports the Java toolchain DSL. Merge it into the existing configuration rather than creating conflicting declarations.
Gradle must be able to locate a suitable installation. Automatic provisioning requires an appropriate toolchain download resolver; declaring a language version alone does not guarantee a download. docs.gradle.org
Keep Kotlin’s JVM target consistent with the project’s intended Java bytecode target. Also remember that Android API availability depends on Android platform settings and supported desugaring, not simply on the desktop JDK you installed. developer.android.com
Fix Common Java and Gradle Errors
Start with the first meaningful error in the build output. The final “build failed” message rarely identifies the underlying cause.
The Plugin Requires Java 17
For an AGP 8.0 project, this usually means the build is running with a Java version below its requirement.
Select a compatible build JDK, then retry. Changing your application’s sourceCompatibility will not replace the runtime executing the plugin. developer.android.com
JAVA_HOME Points to an Invalid Directory
Check whether the configured directory still exists. A JDK update, uninstall, or moved installation may leave an outdated path.
Confirm that the installation contains the expected executables, and correct the path before trying another build.
The IDE Builds Successfully but the Terminal Fails
Compare the IDE’s project configuration with the terminal environment.
Check for:
- A different
JAVA_HOME. - Another Java executable earlier in
PATH. - An
org.gradle.java.homeoverride. - Project-level Daemon JVM criteria.
The goal is to explain the difference between the two environments before making further changes.
Unsupported Class File Version
Identify which component reports the error. Possible causes include a runtime that cannot load newer bytecode or build tooling that cannot process it.
Check the failing plugin or dependency, the selected Java runtime, and the wrapper version together. Installing a newer JDK may help one incompatibility while exposing another.
Restart Gradle After Correcting the Configuration
After resolving a runtime mismatch, stop existing daemons and rerun the failing task:
./gradlew --stop
./gradlew assembleDebug --stacktraceOn Windows PowerShell:
.\gradlew.bat --stop
.\gradlew.bat assembleDebug --stacktraceUse assembleDebug when your project defines that task; otherwise, substitute the task that failed.
Stopping daemons is a troubleshooting step, not a substitute for correcting incompatible versions. Gradle reuses daemon processes according to their compatibility with the requested build environment. docs.gradle.org
Choose a Setup You Can Maintain
For a new project, begin with the generated configuration and verify a basic build before customizing Java settings.
For an existing application, record the working AGP, Gradle, and JDK versions. Change one part at a time, review the resulting error output, and retain a recoverable copy of the previous configuration.
For a team, document the required runtime and compiler versions alongside the project’s setup instructions. Avoid relying on an undocumented absolute path that exists only on one developer’s computer.
Once the development setup works, you can address the app’s supporting website and launch content. TRIDLO’s Hostinger review, TubeMagic review, SEOWriting review, and Rank in ChatGPT review cover separate publishing and promotion topics. None is required to configure Java or build an Android application.
Frequently Asked Questions
Does Android Studio include a JDK?
Yes. It includes JetBrains Runtime, an enhanced JDK. Whether it also fits an existing project’s build requirements depends on that project’s configuration.
Do I need a separate Java installation?
Only when your build requirements or development environment call for one. Check the selected runtime before downloading another installation.
Can I use JDK 21?
Yes, with compatible tooling. Running Gradle on Java 21 requires Gradle 8.5 or later, and the rest of the Android build stack must also support your chosen combination. docs.gradle.org
Why does Gradle ignore JAVA_HOME?
A higher-priority configuration may select the build JVM. Check org.gradle.java.home and Daemon JVM criteria before assuming the environment variable failed.
Does changing sourceCompatibility change Gradle’s Java version?
No. It controls Java source compatibility for compilation. It does not select the JVM that runs Gradle. docs.gradle.org
Should I reinstall Android Studio to fix a Java error?
Begin by identifying the incompatible version or invalid path. Reinstallation may leave the project configuration and environment variables unchanged, so it is a poor first troubleshooting step.
Get Your First Successful Build
A dependable Android Studio+jdk setup starts with compatible versions and a clear understanding of which setting selects each runtime. Check the project’s requirements, verify the JVM Gradle actually uses, and rerun the failing task after each focused change.
Once the build succeeds, record the working configuration so you can reproduce it on another computer.
