Question

I have a question about the compliance mode.
What happens with my class which extends a basic java class, for example Properties and is compiled with JDK5 and packaged into a jar. Now I use this jar in a project which gets build with JDK 6 but in compliance mode 5.
Can someone now use the new method stringPropertyNames() – which is new in JDK6 – on my class in the JDK6 project?

Answer 1

It works, as long as you run your project on JRE 6 JVM. And you don’t need your project to be compiled with compliance to Java 1.5. That is, when compiling your project, you don’t need to use either -source 1.5 nor -target 1.5 options.

On the other hand, when running you project on JRE 5 JVM, it will fail with

java.lang.NoSuchMethodError:B.stringPropertyNames()Ljava/util/Set;

regardless of the options used on compilation of your project.

What happens in runtime, is that the JVM searches corresponding execution bytecode for Properties.stringPropertyNames(). When running on JRE 6, such code exists (no matter what options were used in compilation). When running on JRE 5, it doesn’t exist.

I checked the scenario you suggested:

B.java:

public class B extends Properties {

    public B() {
        setProperty("a", "aaa");
        setProperty("b", "bbb");
    }
}

C.java:

public class C {

    public static void main(String[] args) {
        B b = new B();
        System.out.println(b.stringPropertyNames());
    }
}

The following output resulted the same, compiling with JDK 6, either using -source 1.5 and/or -target 1.5 or not.

Output on JVM 6:

[b, a]

Output on JVM 5:

Exception in thread "main" java.lang.NoSuchMethodError: B.stringPropertyNames()Ljava/util/Set;
        at C.main(C.java:17)

So, why use -source and -target on compilation at all?

This site explains succinctly that you can use -source options to make the compiler fail if certain features of releases later than the specified are used. E.g., -source 1.4 ensures you don’t use generics (which would otherwise fail only at runtime).

The -target options is, according to the official docs, for enabling executing the compiled code on other (earlier) JVMs. E.g, if I use JDK 6 to compile my code but I need it to run on JVM 5, I’d use -target 5 on compilation. If I don’t, I’ll get java.lang.UnsupportedClassVersionError: Bad version number in .class file.

I hope you’re not overwhelmed by the answer ;)…