当它们具有相同接口的相同实现时，将执行哪个方法？

Question

There is an interface with a method called

foo(boolean arg1, String arg2);

Additionally I have two classes which implement this method. Now when I call the foo method from the interface, how does it decide which implementation to pick?

The 2 implementations take the same parameters and return the same object but differ in the implementation.

Answer 1

When you call

a.foo(b, c);

it looks at the type of the object a points to, not the type of the reference and calls the method that type implements.

Initially, it uses a virtual lookup table, which as you can image is expensive, so in the Oracle/OpenJDK JVM, it can inline up to two virtual methods dynamically based on usage so it looks more like this.

if (a instanceof Type1) {
    ((Type1) a).foo(b, c);
} else (a instanceof Type2) {
    ((Type2) a).foo(b, c);
} else {
    a.foo(b, c); // do a full vtable lookup.
}

Answer 2

You cannot call methods on an interface... You need to call them on an object (an instance of a class implementing your interface). and that is the code that is called.

Answer 3

I believe you asking about using interface methods in othere (default) interface methods.

Method will be chosen based on instance referenced by interface variable. Here is small example

class Scratch {
    public static void main(String[] args) {
        ClassA varClassA = new ClassA();
        ClassB varClassB = new ClassB();
        Bar interfaceVar = varClassA;
        interfaceVar.foo("firstCall");
        interfaceVar = varClassB;
        interfaceVar.foo("secondCall");
        varClassA.foo("call from A");
        varClassB.foo("call from B");
        interfaceVar = new Bar() { // or just interfaceVar = System.out::println
            @Override
            public void printParam(String params) {
                System.out.printf("Anonimus class: %s%n", params);
            }
        };
        interfaceVar.foo("Anonimus call");
    }

    public interface Bar {
        default void foo(String param) {
            printParam(param);
        }

        void printParam(String params);
    }

    public static class ClassA implements Bar {
        @Override
        public void printParam(String params) {
            System.out.println(String.format(
                    "Called from %s wth params: %s",
                    this.getClass().getName(),
                    params)
            );
        }
    }

    public static class ClassB implements Bar {
        @Override
        public void printParam(String params) {
            System.out.printf("param from ClassB:%s%n", params);
        }
    }
}

Output:

Called from Scratch$ClassA wth params: firstCall
param from ClassB:secondCall
Called from Scratch$ClassA wth params: call from A
param from ClassB:call from B
Anonimus class: Anonimus call

Process finished with exit code 0