How to Implement Multiple Interfaces with Identical Method Signatures in Go?

Implementing Multiple Interfaces with Identical Method Signatures

In Go, interfaces offer type safety and support multiple inheritance. However, when two interfaces defined in different packages share the same method signature, implementing both with a single implementation can lead to inconsistencies.

To address this, the Go programming language enforces consistency in method types when implementing interfaces. This ensures clarity and reduces potential confusion.

In the provided scenario, you wish to implement both interfaces, A.Doer and B.Doer, using the same C.Do method. While C.Do satisfies the requirements of A.Doer, it may not adhere to the logic expected by B.Doer.

One solution is to utilize type assertions. By checking if an object satisfies both A.Doer and B.Doer, you can determine which implementation to use.

<code class="go">if _, ok := obj.(A.Doer); ok {
    // Use A.Doer implementation
}
if _, ok := obj.(B.Doer); ok {
    // Use B.Doer implementation
}</code>

However, if the logic for A.Do and B.Do differs significantly, a more robust approach is to create separate wrappers for the object.

Create two new types, DoerA and DoerB, each containing the C object and implementing either A.Doer or B.Doer respectively. By passing the appropriate wrapper to the corresponding function, you can ensure that the expected logic is implemented.

<code class="go">type DoerA struct {
    C C
}

// Implement A.Do() using C.Do()
func (d DoerA) Do() string {
    return "C now implements A as per its logic"
}

type DoerB struct {
    C C
}

// Implement B.Do() using C.Do()
func (d DoerB) Do() string {
    return "C now implements B as per its logic"
}

func main() {
    c := C(0)
    dA := DoerA{C: c}
    dB := DoerB{C: c}
    A.FuncA(dA)
    B.FuncB(dB)
}</code>

By using separate wrappers, you can enforce the correct implementation for each interface method while still utilizing the underlying C object.

The above is the detailed content of How to Implement Multiple Interfaces with Identical Method Signatures in Go?. For more information, please follow other related articles on the PHP Chinese website!