Gradle, "sourceCompatibility" vs "targetCompatibility"?

Question

What is the relationship/difference between sourceCompatibility and targetCompatibility? What happens when they are set to different values?

According to Gradle documentation:

sourceCompatibility is "Java version compatibility to use when compiling Java source." targetCompatibility is "Java version to generate classes for."

My understanding is that targetCompatibility will generate java bytecode that is compatible with a specific version of Java, is this a subset of the functionality of sourceCompatibility?

score 104 · Accepted Answer · edited Jul 03 '20 at 14:51

104

targetCompatibility and sourceCompatibility maps to -target release and -source release in javac. Source is basically the source language level and target is the level of the bytecode that is generated.

More details can be found in the javac the cross compilation section.

edited Jul 03 '20 at 14:51

Ben Butterworth

13,650
4
61
95

answered May 21 '13 at 09:07

Matt

8,039
4
27
58

1

The above link is pointing to doc for Java 7. I wonder if you want something like https://docs.oracle.com/en/java/javase/11/tools/javac.html#GUID-AEEC9F07-CB49-4E96-8BC7-BCC2C7F725C9 ? – Brian Agnew Feb 11 '20 at 10:09

score 84 · Answer 2 · edited May 12 '16 at 07:43

84

Be careful when you use these; we've been bitten by people making assumptions.

Just because you use sourceCompability (or targetCompatibility) of 1.5 doesn't mean you can always compile your code with JDK 1.6 and expect it to work under JDK 1.5. The issue is the available libraries.

If your code happens to call some method that is only available in JDK 1.6 it will still compile with the various Compatibility options for the target VM. But when you run it, it will fail because the offending method is not present (you'll get a MethodNotFoundException or ClassNotFoundException).

For this reason, I always compare the Compatibility setting to the actual Java version I'm building under. If they don't match, I fail the build.

edited May 12 '16 at 07:43

peterh

1
15
76
99

answered Mar 11 '14 at 13:22

user1644873

941
7
5

4

This is a subtle, but very important observation. – Natix Apr 08 '16 at 13:23
1

How do you compare them? – secondbreakfast Sep 20 '16 at 18:00
Why do you fail the build? The "bootstrap classpath" option is given just for mitigating this issue. You can always use the proper bootstrap and it should work just fine. – Codebender Nov 09 '16 at 15:30
10

`if(JavaVersion.current() != JavaVersion.VERSION_1_8) throw new GradleException("This project requires Java 8, but it's running on "+JavaVersion.current())` This is how I sort this issue out, right in the beginning of the build.gradle file. – xeruf Nov 06 '17 at 10:28
3

Since Java 9 there is now a new `javac` option `--release` intended to address this problem, by only allowing use of API available in the specified Java version. For more on this see https://stackoverflow.com/a/43103038/4653517 – James Mudd Mar 29 '19 at 09:05
@JamesMudd Wait, so before Java 9 we could use a method only available on Java 8 even though the compatibility was set to Java 1, for example, and the IDE wouldn't warn about that!? – DADi590 Sep 01 '21 at 00:04
Typically yes. When the IDE has a setting for language level it typically means the language constructs i.e. is a lambda valid etc. It does not know which methods were added to the standard libraries in which Java version. So it will just compile against the JVM in use by the IDE. If you want to ensure this use a JVM of the version you are targeting, and don't rely on these version options. – James Mudd Sep 01 '21 at 09:05

score 41 · Answer 3 · answered Apr 08 '15 at 15:33

sourceCompatibility = specifies that version of the Java programming language be used to compile .java files. e.g sourceCompatibility 1.6 =specifies that version 1.6 of the Java programming language be used to compile .java files.

By default sourceCompatibility = "version of the current JVM in use" and targetCompatibility = sourceCompatibility

targetCompatibility = The option ensures that the generated class files will be compatible with VMs specified by targetCompatibility . Note that in most cases, the value of the -target option is the value of the -source option; in that case, you can omit the -target option.

Class files will run on the target specified by targetCompatibility and on later versions, but not on earlier versions of the VM

how do we figure out which ones our project is using ? – isJulian00 Jun 15 '19 at 19:49 — isJulian00, Jun 15 '19 at 19:49

score 0 · Answer 4 · answered Apr 07 '20 at 12:24

In my opinion, “sourceCompatibility” means the what feature you can use in your source code.For example,if you set sourceCompatibility to 1.7, then you can't use lambda expression which a new feature in java 8 even though you jdk version is 1.8.
As for “targetCompatibility”, it means which version of jre the generated class file can be run on, if you set it to 1.8,it may not run successfully on jdk 1.7, but it can usually run on higher version of jdk.

score 0 · Answer 5 · answered May 14 '20 at 11:45

These are the flags for the javac command.

javac [options] [sourcefiles]

Options:
...
-source release - Specifies the version of source code accepted.
...
-target release - Generates class files for a specific VM version.
...

In other words: you write a code in a source version and compile your classes to the target VM version. In order to run it e.g. on other workstation with older java version.

According to: https://docs.oracle.com/en/java/javase/11/tools/javac.html

Gradle, "sourceCompatibility" vs "targetCompatibility"?

5 Answers5

Linked