实现从具有不同返回类型的两个接口继承的类方法

Question

I have two interfaces and one class which implements those two interfaces :

interface A {
    int test();
}

interface B {
    void test();
}

class X implements A, B {
    public void test()  { // ==> Error

    }

    public int test() { // ==> Error
        return 10;
    }
}

Why can't i implement method "test" in my class X ?

NB : this case cannot be correct by design or by logic, but i want to know what shall i do in this case, because i'm in the middle of learning java language, and i want to understand this case :)

Answer 1

The return type alone isn't enough for the compiler to discern between one method or another. Consider code which calls that method:

instanceOfX.test();

Which one should be invoked? void because the result isn't being assigned? What if I wanted to call the int method but just don't care about the result?

The method signature itself (name and parameters) needs to be different for the compiler to discern one from the other.

Answer 2

Return type doesn't come in method signature. A method signature comprise of:

• Method Name
• Format Parameters
• Type Parameters if any.

Since both the methods have same name and no parameters, they have same signature. And you can't have two methods with same signature in a class.

You can only resolve this issue by changing either of the 3 things about that method.

Answer 3

because return type isn't enough to differentiate two method signature,

resolution:

either change method name, or argument list

Answer 4

One cannot have multiple methods of the same signature in the same class, and the signature consists of the name of the method and its parameter types.

To have X implement both A and B , one of the methods in A or B needs to have a different name and/or signature, OR they need to have the same return type and one test method would be enough.

Answer 5

If you really get this problem in real life, and you can't modify A or B , then I think I'd have X implement just one of those, and define a new method in X to return the other:

class X implements A {
    public int test() { 
        return 10;
    }

    private void testForB() {
        // do whatever you'd do to implement B's "void test()"
    }

    public B asB() {
        return new B () {
            @Override
            public void test() {
                testForB();
            }
        };
    }

}

Then any client that has an object x of type X , and that needs to use it as a B , would have to say x.asB() . Not ideal, perhaps, but it would be a way to make things work.

However, I think that this problem is unlikely to show up in real life.