人们说，Go 不是一种 OO(面向对象)语言；不要在 Go 上使用 OO 术语。好的，让我描述一下我可以用 OO 做什么 --

使用 OO 语言，我可以让不同的动物根据它们的类别说不同的话:

cat.Say() // miao
sheep.Say() // bahh
cow.Say() // moo

同样是从 Shapes 获取 Area()。

然而，this go demo code让我相信这是不可能的。包括在下面的 Exhibit#1 中。

然后今天，我找到了this go demo code ，这使它完全成为可能。包括在下面的 Exhibit#2 中。

所以我的问题是，两者之间有什么根本不同，这使得第一个错误而第二个正确？ 如何让第一个“起作用”？

图表#1:

// Credits: hutch
//          https://groups.google.com/d/msg/golang-nuts/N4MBApd09M8/0ij9yGHK_8EJ
////////////////////////////////////////////////////////////////////////////

/*

https://groups.google.com/d/msg/golang-nuts/N4MBApd09M8/tOO5ZXtwbhYJ

LRN:

Subtype polymorphism: Not applicable (Go doesn't have subtyping).
Although if you embed a struct A implementing interface X into a struct B,
struct B will implement interface X, and can be used instead of struct A in
places where struct A is expected. So, kind of yes.

Robert Johnstone:

interfaces behave similarly to virtual functions, but they are not identical.  See the (following) example program by hutch.

*/

package main

import "fmt"

type A struct {
    astring string
}

type B struct {
    A
    bstring string
}

type Funny interface {
    strange()
    str() string
}

func (this *A) strange() {
    fmt.Printf("my string is %q\n", this.str())
}

func (this *A) str() string {
    return this.astring
}

func (this *B) str() string {
    return this.bstring
}

func main() {
    b := new(B)
    b.A.astring = "this is an A string"
    b.bstring = "this is a B string"

    b.strange()
    // Output: my string is "this is an A string"

    // Many people familiar with OO (and unfamiliar with Go) will be quite
    // surprised at the output of that program.
}

图表#2:

// Credits: https://play.golang.org/p/Zn7TjiFQik
////////////////////////////////////////////////////////////////////////////

/*

Problem (From Polymorphism-Subtype.go):

https://groups.google.com/d/msg/golang-nuts/N4MBApd09M8/tOO5ZXtwbhYJ

LRN: Subtype polymorphism: Not applicable (Go doesn't have subtyping).

Goal:

This is to demo that "polymorphism" is still doable in Go.

*/

package main

import (
    "fmt"
)

type Shape interface {
    Area() float32
}

type Point struct {
    x float32
    y float32
}

// Make sure the structs are different sizes so we're sure it'll work with
// all sorts of types
type Circle struct {
    center Point
    radius float32
}

func (c Circle) Area() float32 {
    return 3.1415 * c.radius * c.radius
}

type Rectangle struct {
    ul Point
    lr Point
}

func (r Rectangle) Area() float32 {
    xDiff := r.lr.x - r.ul.x
    yDiff := r.ul.y - r.lr.y
    return xDiff * yDiff
}

func main() {
    mtDict := make(map[string]Shape)
    // No problem storing different custom types in the multitype dict
    mtDict["circ"] = Circle{Point{3.0, 3.0}, 2.0}
    mtDict["rect"] = Rectangle{Point{2.0, 4.0}, Point{4.0, 2.0}}

    for k, v := range mtDict {
        fmt.Printf("[%v] [%0.2f]\n", k, v.Area())
    }
}

/*

$ go run Polymorphism-Shape.go
[circ] [12.57]
[rect] [4.00]

*/

最佳答案

您的两个展品正在做不同的事情。

在第一个中，B 中嵌入了A，而B 没有实现strange() 方法本身，因此当您调用 b.strange() 时，您将获得为 A 定义的 strange() 的实现。 strange方法的接收者(this)是b.A，不是b，所以值b.A。 astring 被打印出来。如果您希望 strange 打印 bstring，则必须为 B 定义 strange。

这指出了 Go 和其他 OO 语言之间的差异之一:将 A 嵌入到 B 中并不意味着 B 是一个“A 的子类”，因此不能在需要 A 类型的对象的地方使用 B 类型的对象。但是，由于 B 继承了 A 的字段和方法，因此由 A 实现的任何接口(interface)也由 B 实现>，并且，除非这些方法是专门为 B 定义的，否则它们在 B 中的 A 上运行，而不是 B 本身。

在第二个展览中，您有 Shape 接口(interface)，它由 Circle 和 Rectangle 类型实现。 map 的元素类型是 Shape，因此实现该接口(interface)的任何类型都可以是 map 中的元素。当您在循环中使用接口(interface)类型的值时，您可以调用该值接口(interface)中定义的任何方法，并且将调用与该值的实际类型对应的定义。

关于oop - 转到 "polymorphism"，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/40195682/