当只有一个实现时，为什么反射返回两个方法？

Question

Suppose I have this code:

public interface Address {
    public int getNo();
}

public interface User<T extends Address> {
    public String getUsername();
    public T getAddress();    
}

public class AddressImpl implements Address {
    private int no;
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
}

public class UserImpl implements User<AddressImpl> {
    private String username;
    private AddressImpl addressImpl;

    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }

    public AddressImpl getAddress() {
        return addressImpl;
    }

    public void setAddress(AddressImpl addressImpl) {
        this.addressImpl = addressImpl;
    }
}

Running the code:

int getAddressMethodCount = 0;
for (Method method : UserImpl.class.getMethods()) {
    if (method.getName().startsWith("getAddress")) {
        getAddressMethodCount++;
    }
}

would yield 2 for getAddressMethodCount variable; why is this so?

Answer 1

It's the way covariant return types are implemented. javap -private will show you more conveniently than reflection.

The subclass with have a synthetic bridge method that handles forwarding to the more specific method. As far the JVM is concerned methods have a name, a sequence of raw typed parameters and a raw type return. You can overload on return type in bytecode.

A System.err.println(mehtod.getReturnType()); should give you different results for the two methods.