Inheritance 组合与多重继承

由于Go使用组合系统而不是（多重）继承，我只是想知道这3个代码片段。Go说他们强迫程序员使用合成

A） 应该是（几乎）正确的Go代码， B） 伪 C） 伪

除了B）和C）可以用于更多的东西和A）迫使你坚持写作之外，这三种代码的结果如何总是一样的

即使您假设B）在类中没有sort方法，但是-比方说像A）这样的全局方法也不会产生真正的区别

A） Go代码：

B） 看起来像是继承，但根据编译器的工作方式，imho可以被看作是嵌入的

class Sort

    public sort() { ... }

    abstract Len()
    abstract Less(i, j int) bool
    abstract Swap(i, j int)

（C）

用法B和C：

class MyClass **embed** Sort

    int value

    void Len() { ... }
    bool Less(i, j int) { ... }
    void Swap(i, j int) { ... }

---

不，这不是go的工作方式。下面是一个可以排序的类型的示例（从标准库中提取）

type IntSlice []int

func (p IntSlice) Len() int           { return len(p) }
func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] }
func (p IntSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

实现

排序

接口的类型不会获得新方法。您不能将方法分配给接口，例如示例中的

func（qs*Sort）Sort（）{…}

但是，允许将其传递给需要类型为

Sort

的变量的函数和方法。因此，我可以调用

sort.sort（myIntSlice）

，然后对其进行排序

type IntSlice []int

func (p IntSlice) Len() int           { return len(p) }
func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] }
func (p IntSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

下面是一个示例函数，它接受实现

排序

接口的任何参数：

// Name of interface changed for clarity
type Sort interface {
    Len() int
    Less(i, j int) bool
    Swap(i, j int)
}

func IsSorted(data Sort) bool {
    n := data.Len()
    for i := n - 1; i > 0; i-- {
        if data.Less(i, i-1) {
            return false
        }
    }
    return true
}

在

IsSorted

中，函数不知道数据的真实类型。它可以是

IntSlice

或其他任何东西。它所知道的是，无论您给出什么参数，它都会实现Sort接口中的方法

---

然而，我似乎无法理解你提出的问题。另外，psuedo代码很难理解。使用另一种语言如java会更好。

首先：感谢您的回复，它对我帮助很大。因此，这里的代码示例中缺少的实际上是sort函数，它采用实现sort接口func sort（s sort）{//do the sorting}@SilverBln的结构，我添加了一个示例函数，该函数采用sort接口的类型。我选择不发布实际的排序函数，因为它太长了。Go实际上不允许你这么做。您可能想创建一个将排序接口作为参数的函数。

func IsSorted(data Sort) bool {
    n := data.Len()
    for i := n - 1; i > 0; i-- {
        if data.Less(i, i-1) {
            return false
        }
    }
    return true
}