理解 Go 中的多态性

Question

我想我陷入了思考以下问题的多态性解决方案中：

假设我有BaseTX struct一个交易字段。现在我有两种特殊类型的交易：RewardTX struct和AllowanceTX struct。

RewardTX struct此刻只有 的组成BaseTX struct。

AllowanceTX struct具有BaseTX struct和 的组成AddField。

我还有一个函数logicAndSaveTX()，它对来自的字段有一些逻辑，BaseTX但最后是使用序列化整个对象json.Marshal()并将其保存在byte[]某处。

type TXapi interface {
    logicAndSaveTX()
}

type BaseTX struct {
    Field1 string
    Field2 string
}

type RewardTX struct {
    BaseTX 
}

type AllowanceTX struct {
    BaseTX 
    AddField string
}

func (tx BaseTX) logicAndSaveTX() {
    // logic on BaseTX fields; simplified:
    tx.Field1 = "overwritten"
    tx.Field2 = "logic done"

    // here would be marshal to json and save; simplified to print object:
    fmt.Printf("saved this object: %+v \n", tx)
}

func SaveTX(tx TXapi) {
    tx.logicAndSaveTX()
}


func main() {
    rewardTX := RewardTX{BaseTX : BaseTX{Field1: "Base info1", Field2: "Base info2"}}
    SaveTX(rewardTX) // should print rewardTX with fields from BaseTX
    allowanceTX := AllowanceTX{BaseTX : BaseTX{Field1: "Base info1", Field2: "Base info2"}, AddField: "additional field"}
    SaveTX(allowanceTX) // would like to print allowanceTX with fields from BaseTX + AdditionalField >>> instead only printing fields from BaseTX
}

https://play.golang.org/p/0Vu_YXktRIk

我试图弄清楚如何实现结构和功能来对两种交易进行操作，但最后正确地序列化两种结构。我的问题是，AddField在我当前的实现中没有看到。

也许我在这里遇到了一些大脑故障——我真的很想以“正确的 Go 方式”来实现这一点。:)

Answer 1

Go 不是面向对象的。该只多态性围棋的形式是接口。

来自其他面向对象的语言可能很困难，因为您必须摆脱许多可能尝试继承的想法 - 例如“基本”类/类型。只需从您的设计思维中删除“基础”即可；你试图将组合转化为继承，这只会给你带来麻烦。

在这种情况下，也许你有一个合法的组合案例；您有一些由多种类型使用的公共共享字段，但它不是“基本”类型。它可能是“元数据”或其他东西-鉴于您的示例非常抽象，我无法说出如何称呼它，但是您明白了。

所以也许你有：

type TXapi interface {
    logicAndSaveTX()
}

type Metadata struct {
    Field1 string
    Field2 string
}

type RewardTX struct {
    Metadata 
}

func (tx RewardTX) logicAndSaveTX() {
    // logic on BaseTX fields; simplified:
    tx.Field1 = "overwritten"
    tx.Field2 = "logic done"

    // here would be marshal to json and save; simplified to print object:
    fmt.Printf("saved this object: %+v \n", tx)
}

type AllowanceTX struct {
    Metadata 
    AddField string
}

func (tx AllowanceTX) logicAndSaveTX() {
    // logic on BaseTX fields; simplified:
    tx.Field1 = "overwritten"
    tx.Field2 = "logic done"
    tx.AddField = "more stuff"

    // here would be marshal to json and save; simplified to print object:
    fmt.Printf("saved this object: %+v \n", tx)
}

如果元数据（或其他）字段的处理在所有用途中都是相同的，也许您可​​以为该类型提供自己的logicTX方法来填充这些字段，该方法可以由logicAndSaveTX嵌入它的结构调用。

这里的关键是考虑一个类型的行为（方法）要限定在那个类型的范围内，而不是认为它能够以某种方式对“子类型”进行操作。子类型不存在，嵌入在另一种类型中的类型无法对其容器进行操作。