关于Go中多态性的另一个问题，引用:Embedding instead of inheritance in Go , https://medium.com/@adrianwit/abstract-class-reinvented-with-go-4a7326525034

动机:有一个接口(interface)(带有一些处理“外部世界”的方法)和该接口(interface)的一堆实现结构。

其中一些方法有一个“标准”实现，其中公共(public)逻辑应该放在一个地方，并委托(delegate)给结构实现接口(interface)中的(新)方法(“子类”不是一个词) .

我已经阅读了上面的媒体链接并编写了一些测试代码。唉，它并没有像我期望的那样工作，当对接口(interface)的调用是间接的时，结构的实际类型就会丢失。

在 C++ 中，这称为“基于类 slice ”，在按值传递多态类时发生。在我的 Go 测试代码中，我小心地通过引用传递，然后 Go 不是 C++(或 Java)。

代码:https://play.golang.org/p/lxAmw8v_kiW

内联:

package main

import (
    "log"
    "reflect"
    "strings"
)

// Command - interface

type Command interface {
    Execute()

    getCommandString() string
    onData(data string)
}

// Command - implementation

type Command_Impl struct {
    commandString string
    conn Connection
}

func newCommand_Impl(conn Connection, data string, args ...string) Command_Impl {
    var buf strings.Builder
    buf.WriteString(data)
    for _, key := range args {
        buf.WriteString(" ")
        buf.WriteString(key)
    }

    return Command_Impl {
        conn: conn,
        commandString: buf.String(),
    }
}

func (self *Command_Impl) Execute() {
    log.Printf("Command Impl Execute: %s", reflect.TypeOf(self))
    self.conn.execute(self)
}

func (self *Command_Impl) getCommandString() string {
    return self.commandString
}

func (self *Command_Impl) onData(data string) {
    log.Printf("Command Impl onData: %s", data)
}

// Command - subclass

type Command_Login struct {
    Command_Impl

    onDataCalled bool
}

func newCommand_Login(conn Connection) *Command_Login {
    return &Command_Login{
        Command_Impl: newCommand_Impl(conn, "LOGIN", "user@foo.com", "pa$$w0rd"),
    }
}

func (self *Command_Login) onData(data string) {
    log.Printf("Command Login onData: %s", data)

    self.onDataCalled = true
}

// Connection - interface

type Connection interface {
    execute(command Command)
}

// Connection - impelementation

type Connection_Impl struct {
}

func newConnection_Impl() *Connection_Impl {
    return &Connection_Impl{}
}

func (self *Connection_Impl) execute(command Command) {
    log.Printf("Connection execute: %s, %s", command.getCommandString(), reflect.TypeOf(command))
    command.onData("some data")
}

func main() {
    conn := newConnection_Impl()
    command := newCommand_Login(conn)

    // I expect command.Execute to preserve actual type of command all the way through
    // command.conn.execute(self) and then the callback onData from connection to command
    // to use the onData in Command_Login
    //
    // This does not happen however, the test fails
    command.Execute()

    // This does preserve actual type of command, but isn't how I'd like to connect
    // commands and connections...
    //
    //conn.execute(command)

    if command.onDataCalled {
        log.Printf("*** GOOD: Command_Login onData ***was*** called")
    } else {
        log.Printf("*** ERROR: Command_Login onData ***not*** called")
    }
}

有一个 Command 接口(interface)，它定义了一些方法。

有一个 Command_Impl 结构，我想在其中实现一些通用代码，这些代码将进一步委托(delegate)给实现相同接口(interface)(“子类不是一个词”)的更多结构中更细粒度的方法，类似于:

https://stackoverflow.com/a/1727737/2342806

问题:

调用 command.Execute() 进而调用 conn.execute(self) 最终“slice ”Command_Login 对象并在内部Connection.execute 变成了Command_Impl。因此，不会调用为 Command_Login 定义的 onData 接口(interface)方法。

如果我调用 conn.execute(command) 然后正确的 onData 会被调用，但这不是我想要连接我的对象的方式(例如 Command 已经有一个 Connection，但基本上就是我上面写的关于重用实现的内容)。

在 Go 术语中，我试图想出一种通过嵌入来委托(delegate)实现的方法，并有一种方法让委托(delegate)回调到封闭类型 em>(微调代理的逻辑)。

唉，Go 似乎不支持它(至少我找不到办法)——一旦你委托(delegate)给一个嵌入式结构，你的调用就完全保留在嵌入式结构中，它“不知道”它是一个更大对象的一部分，该对象可能想要覆盖某些嵌入式结构的方法。

最佳答案

通过在您需要的最浅层实现 Execute 接口(interface)来委托(delegate)实现怎么样？

func (self *Command_Login) Execute() {
    self.Command_Impl.Execute()
    log.Printf("Command Login Execute: %s", reflect.TypeOf(self))
    self.onDataCalled = true
}

https://play.golang.org/p/HvaKHZWIO5W

关于oop - 实际类型在通话中丢失，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/53988017/