Java interface synthetic method generation while narrowing return type

Question

I have 2 interfaces, and 2 return types.

interface interfaceA {
   Publisher<String> doSomething();
}

interface interfaceB extends interfaceA {
   Flow<String> doSomething();
}

interface Publisher<T>{}
class Flow<T> implements Publisher<T>{}

So at runtime, I can see 2 methods of interfaceB.class.getMethods()

public default my.package.Publisher my.package.interfaceB.doSomething()
public abstract my.package.Flow my.package.interfaceB.doSomething()

Regarding the first one, it is Synthetic. (method.getModifiers() & 0x00001000 > 0) == true

Does java autogenerate this synthetic methods?

How does it work in general?

Those things are called bridge methods. They are needed because for the JVM the method type consists of all arguments and it's return type. — Johannes Kuhn
– Johannes Kuhn, Commented Sep 23, 2019 at 15:39
Possibly related: docs.oracle.com/javase/tutorial/java/generics/… — Pshemo
– Pshemo, Commented Sep 23, 2019 at 15:40
For a very in-depth talk about bridge methods you can watch this Video with Dan Heidinga and Brian Goetz: youtube.com/watch?v=kOBHtmqavXc — Johannes Kuhn
– Johannes Kuhn, Commented Sep 23, 2019 at 15:42

Johannes Kuhn · Accepted Answer · 2019-09-23 16:31:03Z

2

What you see here is called a bridge method.

To understand why this is needed, we have to look at how the JVM determines if two methods are different:

Every method has a name. Different name -> different method.
Every method has a descriptor. Different descriptor-> different method.

The descriptor contains all arguments and the return type (with generics, it's erasure).

From the JVM perspective Flow doSomething() is a different method than Publisher doSomething(), so when it is asked to do a invokeinterface call to Publisher doSomething() it won't call Flow doSomething().

This can happen if the target at the callsite is of type interfaceA:

intefaceA foo = ...;
foo.doSomething();

But from the language perspective, both methods are the same, and one overrides the other.

To restore this relationship, javac adds a bridge method with the original method type that just calls the overloaded method.

edited Sep 23, 2019 at 16:31

answered Sep 23, 2019 at 16:18

Johannes Kuhn

15.3k6 gold badges53 silver badges80 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Community · Accepted Answer · 2020-06-20 09:12:55Z

0

The Java Language Specification specifies the following:

A construct emitted by a Java compiler must be marked as synthetic if it does not correspond to a construct declared explicitly or implicitly in source code, unless the emitted construct is a class initialization method

Another definition I've seen from Java Papers is:

When an enclosing class accesses a private attribute of a nested class, Java compiler creates synthetic method for that attribute.

EDIT: It was pointed out that some of what this article states applies to an older Java version (SE7), so be mindful when reading online papers.

So for example:

import static java.lang.System.out;

public class Synthetic {

  public static void main(String[] arguments) {
      Synthetic.NestedClass nested = new Synthetic.NestedClass();
      out.println("Age: " + nested.age);
  }

  private static final class NestedClass {
      
      private String myName = "Tom";

      private int age = 42;

  }

}

The compiler will create synthetic methods for every private attribute being accessed. So, it'll create synthetic method (static int access$000(Synthetic$NestedClass)) for age, but not myName

edited Jun 20, 2020 at 9:12

CommunityBot

11 silver badge

answered Sep 23, 2019 at 16:03

Ambro-r

9391 gold badge5 silver badges14 bronze badges

7 Comments

Johannes Kuhn Over a year ago

This example won't create any synthetic methods with Java 11+.

Holger Over a year ago

@JohannesKuhn the default constructor is not synthetic. So starting with JDK 11, this example will indeed not have synthetic members. This answer is wrong anyway, as it says that “NestedClass will be marked as synthetic” whereas only the generated accessor method would be marked. And the linked paper’s statement “If there is a getter method available in source then this synthetic method will not be created” is wrong as well, as the compiler will not convert a field access to a getter call.

Ambro-r Over a year ago

@Johannes, regarding your statement about Java 11, I ran two tests. In the first I complied the code with Java 8 and then used the Java class file disassembler (javap) on Synthetic$NestedClass.class and for NestedClass age to de-complies to create static int access$000(Synthetic$NestedClass);. If I run the same steps but using JDK 11, the result is exactly the same. so in essence it is creating a synthetic method to access age (even it seems with Java 11).

Ambro-r Over a year ago

@Holger, I can see how the statement about the getter is confusion. Did some reading on this as I've have seen that before and it turns out that it was something occurred in SE7. Similarly regarding what is marked as synthetic. Will just update the answer above accordingly. Tx (TIL)

Holger Over a year ago

It’s not clear why you still have the synthetic method in JDK 11. Did you use a -target or --release option, resp. an IDE setup for an older version or Eclipse’s compiler? I just verified that with the right setup, there are no synthetic accessor methods in Java 11. This also applies to the additional synthetic constructor of NestedClass.

|

Collectives™ on Stack Overflow

Java interface synthetic method generation while narrowing return type

2 Answers 2

Comments

7 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

7 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related