Home > Backend Development > Golang > How to Implement Multiple Interfaces with Identical Method Signatures in Go?

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

Susan Sarandon
Release: 2024-11-02 22:12:30
Original
789 people have browsed it

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>
Copy after login

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>
Copy after login

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!

source:php.cn
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Latest Articles by Author
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template