Is the C# “explicit implementation” of the interface present in Java?

Question

In C#, if you have two base interfaces with the same method (say, F()) you can use explicit implementation to perform different impl. for F(). This alloes you to differently treat the object, corresponding to the current point of view: as IMyInterface1 or IMyInterface2. Is this possible in Java?

Answer 1

No, there's nothing like C#'s explicit interface implementation in Java.

On the plus side, Java has covariant return types, so if you want to provide a more strongly typed implementation than the interface specifies, that's okay. For instance, this is fine:

interface Foo
{
    Object getBar();
}

public class Test implements Foo
{
    @Override
    public String getBar()
    {
        return "hi";
    }
}

C# wouldn't allow that - and one of the ways around it is typically to implement the interface explicitly and then have a more specific public method (usually called by the interface implementation).

Answer 2

You can achieve similar effect using the mechanism of anonymous interface implementation in Java.

See example:

interface Foo {

    void f();
}

interface Bar {

    void f();
}

public class Test {

    private String foo = "foo", bar = "bar";

    Foo getFoo() {
        return new Foo() {

            @Override
            public void f() {
                System.out.println(foo);
            }
        };
    }

    Bar getBar() {
        return new Bar() {

            @Override
            public void f() {
                System.out.println(bar);
            }
        };
    }

    public static void main(String... args) {
        Test test = new Test();
        test.getFoo().f();
        test.getBar().f();
    }
}

Answer 3

You can only do this if the methods are overloaded. If you have two method which are expected to do different things, they should have different names IMHO.

Answer 4

No and it should never be present in Java. It's just another bone to throw at people who can't be bothered with good design.

Explicit implementation of an interface should never be needed or used. There are better ways to solver the problem that this tries to solve.