我目前正在学习 Go 中的接口(interface)，但我被这段代码卡住了:

package main

import (
    "fmt"
    "math"
)

// CommonMath is a common interface for math types
type CommonMath interface {
    Abs() float64
}

// Float64 is a custom float64 type
type Float64 float64

// Abs returns the modulus of objects implementing CommonMath
func (f Float64) Abs() float64 {
    if f < 0 {
        return -float64(f)
    }
    return float64(f)
}

// AbsSquared returns the square of objects implementing CommonMath
func AbsSquared(num CommonMath) float64 {
    return num.Abs() * num.Abs()
}

func main() {
    var f Float64
    f = -5

    type newF Float64
    var newFloat newF
    newFloat = 10.5

    fmt.Println(f)
    fmt.Println(f.Abs())
    fmt.Println(AbsSquared(newFloat))
}

事实证明，它无法编译，因为 newFloat 没有实现接口(interface) CommonMath。 newF 类型是实现接口(interface)的自定义 Float64 类型，我不知道发生了什么。为了让事情变得更奇怪，我将 newF 和 newFloat 的声明替换为以下内容，它们实现相同但作为结构:

type newF struct {
    Float64
}
newFloat := newF{10.5}

突然间，代码构建得非常好。这是否意味着只有结构可以实现父类型的接口(interface)，因此不允许将类型 newF 直接声明为 Float64？

最佳答案

首先，Go 中根本没有继承。网络上有几篇文章讨论了 Go 的设计决策，它放弃了 oop 的许多功能，但这确实超出了这个答案。

进入你的案例。很明显，Float64 实现了 CommonMath。它具有 CommonMath 所需的方法集，因此适合接口(interface)。

但是，当您声明另一种类型时，type newF Float64，新类型不会复制方法集，只会复制数据结构。这在 spec 中指定:

A type definition creates a new, distinct type with the same underlying type and operations as the given type, and binds an identifier to it.

The new type is called a defined type. It is different from any other type, including the type it is created from.

A defined type may have methods associated with it. It does not inherit any methods bound to the given type, but the method set of an interface type or of elements of a composite type remains unchanged:

// A Mutex is a data type with two methods, Lock and Unlock.
type Mutex struct         { /* Mutex fields */ }
func (m *Mutex) Lock()    { /* Lock implementation */ }
func (m *Mutex) Unlock()  { /* Unlock implementation */ }

// NewMutex has the same composition as Mutex but its method set is empty.
type NewMutex Mutex
// The method set of the base type of PtrMutex remains unchanged,
// but the method set of PtrMutex is empty.
type PtrMutex *Mutex

// The method set of *PrintableMutex contains the methods
// Lock and Unlock bound to its embedded field Mutex.
type PrintableMutex struct {
    Mutex
}

// MyBlock is an interface type that has the same method set as Block.
type MyBlock Block

接下来是 type NewF struct { Float64 }。乍一看，这看起来很像继承，但 Go 中又没有这样的东西。它被称为嵌入 或组合。同样，spec :

A field declared with a type but no explicit field name is called an embedded field. An embedded field must be specified as a type name T or as a pointer to a non-interface type name *T, and T itself may not be a pointer type. The unqualified type name acts as the field name.

A field or method f of an embedded field in a struct x is called promoted if x.f is a legal selector that denotes that field or method f.

Promoted fields act like ordinary fields of a struct except that they cannot be used as field names in composite literals of the struct.

Given a struct type S and a type named T, promoted methods are included in the method set of the struct as follows:

• If S contains an embedded field T, the method sets of S and *S both include promoted methods with receiver T. The method set of *S also includes promoted methods with receiver *T.

• If S contains an embedded field *T, the method sets of S and *S both include promoted methods with receiver T or *T.

所以，这里的诀窍是促销。 Float64 的方法被提升为 NewF。同样，它在某种程度上可能看起来像继承，但它是不同的。请注意，提升的方法仍然属于嵌入类型，接收者将始终是原始方法。以下代码打印 4。

package main

import (
    "fmt"
)

type A struct {}

type B struct {A}

func (A) P() int {
    return 4
}

func (B) P() int {
    return 5
}

func (a A) S() {
    fmt.Println(a.P())
}

func main() {
    B{}.S()
}

Playground :https://play.golang.org/p/BuBL69LqeY6

关于inheritance - 非结构类型中的接口(interface)继承，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/48480612/