Synthetic Constructs in Java

1. Overview

In this tutorial, we’ll take a look at Java’s synthetic constructs, code introduced by the compiler to transparently handle access to members which would be otherwise unreachable due to insufficient visibility or missing references.

Note: starting with JDK 11, synthetic methods and constructors are no longer generated, as they’re superseded by nest-based access control.

2. Synthetic in Java

The best definition of synthetic we could possibly find comes directly from the Java Language Specification (JLS 13.1.7):

Any constructs introduced by a Java compiler that do not have a corresponding construct in the source code must be marked as synthetic, except for default constructors, the class initialization method, and the values and valueOf methods of the Enum class.

There are different kinds of compilation constructs, namely fields, constructors, and methods. On the other hand, although nested classes can be altered by the compiler (i.e. anonymous classes), they aren’t considered synthetic.

Without further ado, let’s delve deep into each of these.

3. Synthetic Fields

Let’s begin with a simple nested class:

public class SyntheticFieldDemo {
    class NestedClass {}
}

When compiled, any inner class will contain a synthetic field which references the top level class. Coincidentally, this is what makes possible to access the enclosing class members from a nested class.

To make sure that this is what’s happening, we’ll implement a test which gets the nested class fields by reflection and checks them using the isSynthetic() method:

public void givenSyntheticField_whenIsSynthetic_thenTrue() {
    Field[] fields = SyntheticFieldDemo.NestedClass.class
      .getDeclaredFields();
    assertEquals("This class should contain only one field",
      1, fields.length);

    for (Field f : fields) {
        System.out.println("Field: " + f.getName() + ", isSynthetic: " +
          f.isSynthetic());
        assertTrue("All the fields of this class should be synthetic", 
          f.isSynthetic());
    }
}

Another way we could verify this would be by running the disassembler through the command javap. In either case, the output shows a synthetic field named this$0.

4. Synthetic Methods

Next up, we’ll add a private field to our nested class:

public class SyntheticMethodDemo {
    class NestedClass {
        private String nestedField;
    }

    public String getNestedField() {
        return new NestedClass().nestedField;
    }

    public void setNestedField(String nestedField) {
        new NestedClass().nestedField = nestedField;
    }
}

In this case, the compilation will generate accessors to the variable. Without these methods, it’d be impossible to access a private field from the enclosing instance.

Once again, we can check this with the same technique which shows two synthetic methods called access$0 and access$1:

public void givenSyntheticMethod_whenIsSynthetic_thenTrue() {
    Method[] methods = SyntheticMethodDemo.NestedClass.class
      .getDeclaredMethods();
    assertEquals("This class should contain only two methods",
      2, methods.length);

    for (Method m : methods) {
        System.out.println("Method: " + m.getName() + ", isSynthetic: " +
          m.isSynthetic());
        assertTrue("All the methods of this class should be synthetic",
          m.isSynthetic());
    }
}

Notice that in order to generate the code, the field must actually be read from or written to, otherwise, the methods will be optimized away. This is the reason why we also added a getter and a setter.

As mentioned above, these synthetic methods are no longer generated starting with JDK 11.

4.1. Bridge Methods

A special case of synthetic methods is bridge methods, which handle type-erasure of generics.

For instance, let’s consider a simple Comparator:

public class BridgeMethodDemo implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2) {
        return 0;
    }
}

Although compare() takes two Integer arguments in the source, once compiled it’ll take two Object arguments instead, due to type erasure.

To manage this, the compiler creates a synthetic bridge which takes care of casting the arguments:

public int compare(Object o1, Object o2) {
    return compare((Integer) o1, (Integer) o2);
}

In addition to our previous tests, this time we’ll also call isBridge() from the Method class:

public void givenBridgeMethod_whenIsBridge_thenTrue() {
    int syntheticMethods = 0;
    Method[] methods = BridgeMethodDemo.class.getDeclaredMethods();
    for (Method m : methods) {
        System.out.println("Method: " + m.getName() + ", isSynthetic: " +
          m.isSynthetic() + ", isBridge: " + m.isBridge());
        if (m.isSynthetic()) {
            syntheticMethods++;
            assertTrue("The synthetic method in this class should also be a bridge method",
              m.isBridge());
        }
    }
    assertEquals("There should be exactly 1 synthetic bridge method in this class",
      1, syntheticMethods);
}

5. Synthetic Constructors

Finally, we’ll add in a private constructor:

public class SyntheticConstructorDemo {
    private NestedClass nestedClass = new NestedClass();

    class NestedClass {
        private NestedClass() {}
    }
}

This time, once we run the test or the disassembler we’ll see that there are actually two constructors, one of which is synthetic:

public void givenSyntheticConstructor_whenIsSynthetic_thenTrue() {
    int syntheticConstructors = 0;
    Constructor<?>[] constructors = SyntheticConstructorDemo.NestedClass
      .class.getDeclaredConstructors();
    assertEquals("This class should contain only two constructors",
      2, constructors.length);

    for (Constructor<?> c : constructors) {
        System.out.println("Constructor: " + c.getName() +
          ", isSynthetic: " + c.isSynthetic());

        if (c.isSynthetic()) {
            syntheticConstructors++;
        }
    }

    assertEquals(1, syntheticConstructors);
}

Similarly to the synthetic fields, this generated constructor is essential to instantiate a nested class with a private constructor from its enclosing instance.

As mentioned above, the synthetic constructor is no longer generated starting with JDK 11.

6. Conclusion

In this article, we discussed synthetic constructs generated by the Java compiler. To test them, we made use of reflection, which you can learn more about here.