How to write code in Java 11, but target Java 8 and above?

Question

I am working on a small library and for obvious reasons I would like to write code using all the Java 11 features (except modules I guess for now), but I would like the library to be compatible with Java 8 and above.

When I try this:

javac -source 11 -target 1.8 App.java

I get the following message:

warning: source release 11 requires target release 11

...and when I look at the byte code I see that the version of the class is 0x37 (Java 11):

$ xxd App.class
00000000: cafe babe 0000 0037 ...

And Java 8 cannot load it:

Exception in thread "main" java.lang.UnsupportedClassVersionError: App 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
    at java.lang.ClassLoader.defineClass1(Native Method)
    at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
    at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
    at java.net.URLClassLoader.defineClass(URLClassLoader.java:468)
    at java.net.URLClassLoader.access$100(URLClassLoader.java:74)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:369)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:363)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:362)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:349)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    at sun.launcher.LauncherHelper.checkAndLoadMain(LauncherHelper.java:495)

How do people provide such compatibility? I am open to all build tools.

For me it seems easy just to transform high-level language (Java) into low-level (bytecode). It appears to me that when the high-level language changes, the low-level should stay the same. That is why I thought it was possible.

UPDATE

Guys, I don't think that this answer duplicates Move to OpenJDK-11 but compile in Java 8, because there the OP asks how to keep producing the code with Java 8 features, but target Java 11 (which is just a famous backward compatibility). My question is the other way around: I want to produce the code in Java 11, but target Java 8. I came across that question when I was researching the topic before posing the question. I didn't find it applicable to my situation.

The other question Can Java 8 code be compiled to run on Java 7 JVM does look similar to my question, but it was asked in 2013 and the bytecode obviously changed between Java 7 and Java 8.

I didn't think the bytecode changed that much since Java 8 that is why I asked this question.

Julieannjulien

If you want to target and build a java 8 version of your project, you can only use java 8 language features and libraries, not the newer ones. – Brandon

Which Java 11 language features do you need? The differences between Java 8 and Java 11 are minor. – Disband

I think the only (safe) way to do this is to switch to Kotlin, which can produce JVM 1.8 compatible bytecode. This way you get access to modern language features but produce compatible bytecode. Java 11 language features require a new bytecode format that is not supported by JVM 1.8. – Whoremaster

If you use source version 1.8. you can target 1.8. You can also use the --release 8 parameter which will not only generate Java 8-compatible bytecode, but it will also generate a binary which actually works with Java 8. There is a subtle difference, but it is possible to build a bytecode-compatible binary that will fail at runtime because methods in the standard library were chosen by the compiler that don't actually exist in a Java 8 standard library. The --release option should avoid that. – Recipe

Answer 1

While conversion of classes compiled for JDK 11 to JDK 8 would be theoretically possible with a sophisticated tool, it’s not trivial. There are significant changes on the binary level.

First, JDK 11 introduced nest types, which eliminates the need to generate synthetic accessor methods when accessing private members of inner/outer classes. Of course, such access would fail in older versions.

It also introduced dynamic constants, though I don’t know whether the Java language exploits that feature anywhere. This is mainly intended for future versions.

Then, since JDK 9, string concatenation gets compiled using invokedynamic referring to java.lang.invoke.StringConcatFactory which is not present in Java 8.

A feature that could work, is private methods in interfaces, introduced in Java 9 as a language feature, but already handled on the binary level in Java 8.

Java 8 would also be unable to process module definitions, but I suppose, they would be ignored.

Complot

Answer 2

No, you cannot compile Java 11 source to Java 8 binaries.

In javac terms, the -source parameter can't be greater than the -target parameter.

So, if you want to produce Java 8 binaries, your sources should be written in java 8 (or earlier). If you don't use any Java 11 language features, your sources basically already are in Java 8 so this shouldn't be too big a problem.

Note that you can still use a JDK 11 to compile the Java 8 source into Java 8 binaries. The JDK version can be greater than the source and/or target versions.

Note: the javac documentation says nothing about the -source parameter having to be less than or equal to the -target parameter. There's lots of non-official documentation, however. For example, https://mcmap.net/q/276168/-which-jdk-39-s-distributions-can-run-javac-source-1-6-target-1-5

As far as I can tell there's also not a single counter-example of actually getting such a situation to work.

Farron

please give me the link to docs that supports this statement "In javac terms, the -source parameter can't be greater than the -targetparameter." I didn't find anything like this here – Julieannjulien

Your correct that the docs don't mention that. The best resource I have been able to find says that, according to docs, the compiler should be able to do this. However, in practice it seems it won't. I'll add the best source I have been able to find on short notice. – Farron

This is true. Compilation fails if source is 11 and target is 1.8 with the message: "warning: source release 11 requires target release 11" – Actinomycosis

Answer 3

There's a tool called Jabel created by @bsideup, which allows you to do this. It pretends to be an annotation processor so it could be plugged into javac. However, it doesn't do any actual annotation processing. Instead, during the compilation, it hacks into javac internals and makes it believe that newer features like var, diamond in anonymous class creation and even newer ones like text blocks and switch expressions are ok to use in Java 8.

This is a hacky solution without any warranty so use it with caution.

Remscheid

Answer 4

I could be wrong here, but at least up to now, javac isn't meant to be used in that way.

A bit of guessing here: you could try to see if --release 8 --target 8 works (without giving the --source 11 parameter).

But I doubt that this will work. I think there is no support in javac to accept N source code features, and have that compiled backwards to earlier target versions.

Of course, the compiler could have knowledge about the required transformations to turn N source code into (N-m) byte code. But that would make the compiler much more complex, and each release would add to that. It would also add dramatical cost to the testing efforts. I doubt that the compiler maintainers are willing to buy into that. It is really not like this is a widespread use case.

So, the only "solution" I know: branching, and double maintenance. And in order to keep things reasonable, I would simply keep a Java 8 version, and maybe one for Java 11.

Ernesternesta

Thank you for such a detailed answer. For me it seems easy just to transform high-level language (java) into low-level (bytecode). It appears to me that when the high-level language changes, the low-level should stay the same, that is why I thought it was possible. I am thinking about Kotlin now, it might be the way, what do you think? – Julieannjulien

There are significant changes on the binary level. First, JDK 11 introduced nest types, which eliminates the need to generate synthetic accessor methods when accessing private members of inner/outer classes. Of course, such access would fail in older versions. It also introduced dynamic constants, though I don’t know whether the Java language exploits that feature anywhere. Then, since JDK 9, string concatenation gets compiled using invokedynamic referring to java.lang.invoke.StringConcatFactory which is not present in Java 8. Conversion of compiled classes is possible but not trivial. – Complot

Answer 5

Although I didn't see anything explicit in the javadoc for javac, I think you can only state the same version for both -source and -target options. Java 11 features are not supported in Java 8 although the opposite is true, a higher java version can run code compiled in a lower version. So I don't think it is possible to compile code written to Java 11 to be runnable in Java 8.

Hartzke

I think: it is not possible with the tools we have right now (most likely). If you spend enough resources, you probably could create such a compiler. It's just that this might be really expensive, and not much people interested in that feature. – Ernesternesta

@Ernesternesta There are major differences in the class-file format. E.g. CONSTANT_Dynamic and indified String concatenation. I have no idea how these can be translated to Java 8... – Disband

Answer 6

Probably Multi-Release Jar Files is an option - that means the creation of several versions of the same class for different supported Javas

https://docs.oracle.com/en/java/javase/20/docs/specs/jar/jar.html

https://www.baeldung.com/java-multi-release-jar

Juster