接口多重继承的冲突方法

Question

I have the following interfaces (in Java, but it's more of an OO question, not language-specific, I'm interested in answers for any language)

public interface A {
    int foo();
}

and

public interface B {
    char foo();
}

If I now want to make the following class:

public class C implements A,B{
    public int foo() {
        return 0;
    }
    public char foo() {
        return 0;
    }
}

This won't compile because the methods are conflicting. Is there any way to make this work, or something with the same meaning (of course without modifying A or B, that would be trivial)?

Answer 1

No, the return type cannot be a deciding factor in making a method signature unique because you do not need to assign the returned value to anything, the compiler wouldn't know what to do in that case.

Concrete example:

...
C object = new C();
object.foo();
...

Which foo did I just call? Can't tell.

To make this work you'll need to have either different method names or different parameter types in the interface methods.

EDIT: assuming you have no control over the interfaces A and B (library classes or similar) this is the solution I'd take if I wanted to implement them in the same class:

public class C {
    private objectA = new AImpl();
    private objectB = new BImpl();

    // Work with the objects here

    private class AImpl implements A {
        public int foo() {
            // ...
        }
    }

    private class BImpl implements B {
        public char foo() {
            // ...
        }
    }
}

Answer 2

This problem is present because in OOP, is considered the existence of more one method with the same name but with different parameters and not by return type.

The problem is not the interface, the problem is the class.

Answer 3

The common solution is to give each method a different name. Avoid generic names that have a high chance of naming collision with another interface.

Answer 4

重载带有参数。

Answer 5

There are several solutions to this problem in use. I am working on the assumption that these are independent interfaces, that the intention is multiple interface (implementation of two unrelated interfaces on the same object) and that overloading has nothing to do with it.

The solutions I am aware of are: 1. Scoping. A reference to foo() can be qualified as A.foo() or B.foo() to determine which is required. 1. Namespaces. The interfaces are inherited inside a namespace constructed for the purpose, and all references to foo() must be preceded by a namespace, eg A::foo(), B::foo(). 1. Aliasing. One or both of the foo() methods are explicitly renamed when inherited. Calls become something like A_foo() and B_foo().

Ada certainly had a mechanism like this, and I think some variants of Pascal did too. I can find more examples if it's important.