问题

我是一个Python开发者，正在尝试学习Go语言。目前我正在尝试重构我的第一个小项目，但是我不太确定如何在结构体之间共享一个方法。

简而言之，你想在Go语言中实现类似于以下Python代码的功能：

class Super(object):

  def CommonMethod(self):
    print 'I am the common method.'

class One(Super):

  def MethodOne(self):
    self.CommonMethod()
    print 'I am method one.'

class Two(Super):

  def MethodTwo(self):
    self.CommonMethod()
    print 'I am method two.'

one = One()
one.MethodOne()

two = Two()
two.MethodTwo()

请注意，Go语言中没有类的概念，而是使用结构体和方法来实现类似的功能。你可以通过在结构体中定义方法来实现方法的共享。以下是将上述Python代码转换为Go代码的示例：

package main

import "fmt"

type Super struct{}

func (s *Super) CommonMethod() {
    fmt.Println("I am the common method.")
}

type One struct {
    Super
}

func (o *One) MethodOne() {
    o.CommonMethod()
    fmt.Println("I am method one.")
}

type Two struct {
    Super
}

func (t *Two) MethodTwo() {
    t.CommonMethod()
    fmt.Println("I am method two.")
}

func main() {
    one := &One{}
    one.MethodOne()

    two := &Two{}
    two.MethodTwo()
}

希望这可以帮助到你！如果你有任何其他问题，请随时问我。

class Super(object):

  def CommonMethod(self):
    print 'I am the common method.'


class One(Super):

  def MethodOne(self):
    self.CommonMethod()
    print 'I am method one.'


class Two(Super):

  def MethodTwo(self):
    self.CommonMethod()
    print 'I am method two.'

one = One()
one.MethodOne()

two = Two()
two.MethodTwo()

答案1

得分: 7

在Go语言中，方法并不像在其他语言（如Python或Java）中那样通过子类继承来自动继承。你可以定义接口并使用嵌入来实现类似的功能，但你需要为每种类型实现所需的方法。当然，你可以在外部方法中直接调用嵌入类型的方法，但要注意任何更改都将发生在内部对象而不是外部对象上。

根据文档：

嵌入与子类继承有一个重要的区别。当我们嵌入一个类型时，该类型的方法成为外部类型的方法，但当调用这些方法时，方法的接收者是内部类型而不是外部类型。在我们的示例中，当调用bufio.ReadWriter的Read方法时，它与上面编写的转发方法具有完全相同的效果；接收者是ReadWriter的reader字段，而不是ReadWriter本身。

更多信息：

以下是文档中的一些参考资料：

http://golang.org/doc/faq#Is_Go_an_object-oriented_language

Go是一种面向对象的语言吗？

是和否。虽然Go具有类型和方法，并允许面向对象的编程风格，但它没有类型层次结构。Go中的“接口”概念提供了一种不同的方法，我们认为它易于使用，并且在某些方面更通用。还有一些将类型嵌入到其他类型中以提供类似但不完全相同的子类化功能的方法。

因此，你可以定义接口来规定类型应该实现的方法，但你需要为每种类型实现这些方法。

另一个方便之处是嵌入：

http://golang.org/doc/effective_go.html#embedding

Go没有提供典型的、基于类型的子类化概念，但它确实可以通过在结构体或接口中嵌入类型来“借用”实现的部分。

接口嵌入非常简单。我们之前提到过io.Reader和io.Writer接口；以下是它们的定义。

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

io包还导出了其他几个接口，用于指定可以实现多个这样的方法的对象。例如，有一个io.ReadWriter接口，它包含了Read和Write方法。我们可以通过显式列出这两个方法来指定io.ReadWriter，但通过嵌入这两个接口来形成新接口更加简单和具有描述性，如下所示：

// ReadWriter是将Reader和Writer接口组合在一起的接口。
type ReadWriter interface {
    Reader
    Writer
}

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
} 

// ReadWriter is the interface that combines the Reader and Writer interfaces.
type ReadWriter interface {
    Reader
    Writer
}

答案2

得分: 3

注意：最近（2014年11月18日）有一篇名为《在Go中的子类化》的文章介绍了一些在Go中模仿Java或Python等“面向对象”语言行为的技巧。

虽然组合是常见的方式，但如果你需要在运行时解析对方法的调用，你需要让“Parent”类型具有对接口的引用。

请注意，这并不提供“真正”的继承（正如我在“[使用接口进行函数重载的Go语言][2]”中所解释的那样）。
更多信息请参见“[Go中的继承语义][3]”。

示例（play.golang.org）：

type Person interface {
    close() // 定义一个接口以查找方法
    flush()
}
type Parent struct {
    self Person // 保留对自身的引用以进行动态调度
}
func (p *Parent) flush() {
    fmt.Println("parent flush")
}
func (p *Parent) close() {
    p.self.flush() // 调用子类的flush方法。
    fmt.Println("close")
}

这样，你可以使用Child类型（嵌入Parent及其`self`接口引用）来“子类化”parent：

```go
type Child struct {
    Parent
}
func (c *Child) flush() {
    c.Parent.flush()
    fmt.Println("child flush")
}

这意味着如果你创建一个Child实例，并将该实例放入“self”中：

```go
x := new(Child)
x.self = x

那么对`x.close()`的调用将打印：

parent flush
child flush
close

[1]: http://whitane.com/post/oo-in-go/
[2]: https://stackoverflow.com/a/25075999/6309
[3]: http://tech.t9i.in/2014/01/inheritance-semantics-in-go/
[4]: http://play.golang.org/p/jJ87KqMFCu

<details>
<summary>英文:</summary>

Note: a recent (today Nov 18th 2014) article called &quot;[Subclassing in Go][1]&quot; illustrates some techniques for mimicking behaviour of “oo” languages like java or python in go.

While composition is the norm, if you need a &quot;`Parent`&quot; type to resolve a call to a method *at runtime*, you would need said `Parent` type to have a reference to an interface.

Note that this doesn&#39;t provide &quot;true&quot; inheritance though (as I explained in &quot;[Function Over Loading in GO using interfaces][2]&quot;).  
For more see &quot;[Inheritance Semantics in Go][3]&quot;.

[Example (play.golang.org)][4]:

    type Person interface {
        close() // define an interface to lookup methods on
        flush()
    }
    type Parent struct {
        self Person // retain reference to self for dynamic dispatch
    }
    func (p *Parent) flush() {
        fmt.Println(&quot;parent flush&quot;)
    }
    func (p *Parent) close() {
        p.self.flush() // call the flush method of whatever the child is.
        fmt.Println(&quot;close&quot;)
    }

That way, you can &quot;subclass&quot; parent with a Child type (embedding Parent, and its `self` interface reference):

    type Child struct {
        Parent
    }
    func (c *Child) flush() {
        c.Parent.flush()
        fmt.Println(&quot;child flush&quot;)
    }

That means if you create a Child instance *and* put that instance in &quot;self&quot;:

    x := new(Child)
    x.self = x

Then a call to `x.close()` would print:

    parent flush
    child flush
    close


  [1]: http://whitane.com/post/oo-in-go/
  [2]: https://stackoverflow.com/a/25075999/6309
  [3]: http://tech.t9i.in/2014/01/inheritance-semantics-in-go/
  [4]: http://play.golang.org/p/jJ87KqMFCu

</details>



# 答案3
**得分**: 1

根据twotwotwo在我的问题上的评论，我提出了以下在Go语言中的解决方案：

Go playground链接：http://play.golang.org/p/JtPAON93PO

```go
type Super struct{}

type One struct {
    Super *Super
}

type Two struct {
    Super *Super
}

func (s *Super) CommonMethod() {
    fmt.Println("我是公共方法。")
}

func (o *One) MethodOne() {
    o.Super.CommonMethod()
    fmt.Println("我是方法一。")
}

func (t *Two) MethodTwo() {
    t.Super.CommonMethod()
    fmt.Println("我是方法二。")
}

以上是代码的翻译部分。

type Super struct{}

type One struct {
	Super *Super
}

type Two struct {
	Super *Super
}

func (s *Super) CommonMethod() {
	fmt.Println("I am the common method.")
}

func (o *One) MethodOne() {
	o.Super.CommonMethod()
	fmt.Println("I am method one.")
}

func (t *Two) MethodTwo() {
	t.Super.CommonMethod()
	fmt.Println("I am method two.")
}