Go 面向对象编程（译）-白红宇

『就要学习 Go 语言』系列 -- 第 26 篇分享好文

今天接着给大家分享关于 Go 面向对象的好文。原文作者是 William Kennedy，《Go 语言实战》作者，博客的维护者。大部分中国的 Gopher 都是通过这个博客认识了这位 Go 大神。

有些与知识点无关的语句，翻译过来有点拗口，大家一眼带过。但与知识点相关的，都会尽量忠于原文。另外，文章做了简单的排版，方便阅读。翻译水平有限，有误的地方，请大家在下方留言指正。

基础

今天有人在论坛上问我一个问题，如何在不通过嵌入的情况下而获得继承的优点。重要的是，每个人都应该考虑 Go 语言，而不是他们留下的语言。我不能告诉你我从早期的 Go 实现中删除了多少代码，因为这是不必要的。语言设计师有多年的经验和知识，正在帮助创建一种快速、精简且编写代码非常有趣的语言。

我认为 Go 是一门轻量级的面向对象编程语言。是的，它具有封装和类型成员函数，但它缺乏继承，因此缺乏传统的多态性。对我来说，除非想实现多态性，否则继承是无用的。通过在 Go 中实现接口的方式，不需要继承。Go采用 OOP 中最好的部分，而忽略了其他部分，为我们提供了一种编写多态代码的更好方法。

下面是 Go 中的 OOP 快速概览。先从这三个结构体开始。

type Animal struct {    Name string    mean bool}type Cat struct {    Basics Animal    MeowStrength int}type Dog struct {    Animal    BarkStrength int}复制代码

在任何关于 OOP 的示例中，你都可能看到上面三个结构体。一个基础结构体 Animal 和基于 Animal 声明的结构体 Cat 和 Dog。结构体 Animal 拥有所有动物共同的属性。

除了成员 mean，其他所有成员都是公共的、可被外部访问的。结构体 Animal 的 mean 成员以小写字母开头。在 Go 中，变量、结构体、成员、函数等的第一个字母的大小写决定了访问权限。大写字母开头表示公共的，可供外部调用；小写字母开头表示私有的，外部不能调用。

由于 Go 里没有继承，所以组合是你唯一的选择。结构体 Cat 的一个成员是 Basics，类型是 Animal。而结构体 Dog 通过匿名的方式嵌入了结构体 Animal。哪种实现方式更好取决于你，我会展示这两种实现方式。

给结构体 Cat 和 Dog 创建各自的方法：

func (dog *Dog) MakeNoise() {    barkStrength := dog.BarkStrength    if dog.mean == true {        barkStrength = barkStrength * 5    }    for bark := 0; bark < barkStrength; bark++ {        fmt.Printf("BARK ")    }    fmt.Println("")}func (cat *Cat) MakeNoise() {    meowStrength := cat.MeowStrength    if cat.Basics.mean == true {        meowStrength = meowStrength * 5    }    for meow := 0; meow < meowStrength; meow++ {        fmt.Printf("MEOW ")    }    fmt.Println("")}复制代码

使用指针接收者实现各自的方法 MakeNoise()。这两个方法做同样的事情，如果 mean 为 true 话，每个动物会基于吠或喵的强度，用各自的母语说话。很无聊，但它展示了如何访问引用的对象。

我们可以使用 Dog 引用直接调用结构体 Animal 的成员，而 Cat 必须通过成员 Basics 访问到 Animal 的成员。

到目前为止，我们已经讨论了封装、组合、访问规范和成员函数，剩下的就是如何创建多态行为。

通过接口实现多态：

type AnimalSounder interface {    MakeNoise()}func MakeSomeNoise(animalSounder AnimalSounder) {    animalSounder.MakeNoise()}复制代码

上面的代码，我们添加一个接口 AnimalSounder 和一个公共函数 MakeSomeNoise()，该函数接受接口类型的值。实际上，该函数将引用实现此接口的类型的值。接口不是可以实例化的类型，是行为声明，其他类型可以去实现接口声明的行为。

在 Go 中，通过方法实现接口的任何类型都表示接口类型。在我们的例子中，结构体 Dog 和 Cat 都通过指针接收者实现了接口 AnimalSounder，所以它们都可以看成是 AnimalSounder 类型。

这意味着，Dog 和 Cat 的指针可以作为参数传递给函数 MakeSomeNoise()。MakeSomeNoise() 函数通过 AnimalSounder 接口实现多态行为。

进阶

如果你想减少 Cat 和 Dog 的 MakeNoise() 方法中的代码重复，可以为 Animal 类型创建一个方法来处理：

func (animal *Animal) PerformNoise(strength int, sound string) {    if animal.mean == true {        strength = strength * 5    }    for voice := 0; voice < strength; voice++ {        fmt.Printf("%s ", sound)    }    fmt.Println("")}func (dog *Dog) MakeNoise() {    dog.PerformNoise(dog.BarkStrength, "BARK")}func (cat *Cat) MakeNoise() {    cat.Basics.PerformNoise(cat.MeowStrength, "MEOW")}复制代码

现在 Animal 类型有一个处理 noise 的方法，可以被其外部类型调用，例如 Dog、Cat 类型。还有一个好处，我们不需要将 mean 成员作为参数传递，因为它就属于 Animal 结构体。下面是完整代码：

package mainimport (    "fmt")type Animal struct {    Name string    mean bool}type AnimalSounder interface {    MakeNoise()}type Dog struct {    Animal    BarkStrength int}type Cat struct {    Basics Animal    MeowStrength int}func main() {    myDog := &Dog{        Animal{           "Rover", // Name           false,   // mean        },        2, // BarkStrength    }    myCat := &Cat{        Basics: Animal{            Name: "Julius",            mean: true,        },        MeowStrength: 3,    }    MakeSomeNoise(myDog)    MakeSomeNoise(myCat)}func (animal *Animal) PerformNoise(strength int, sound string) {    if animal.mean == true {        strength = strength * 5    }    for voice := 0; voice < strength; voice++ {        fmt.Printf("%s ", sound)    }    fmt.Println("")}func (dog *Dog) MakeNoise() {    dog.PerformNoise(dog.BarkStrength, "BARK")}func (cat *Cat) MakeNoise() {    cat.Basics.PerformNoise(cat.MeowStrength, "MEOW")}func MakeSomeNoise(animalSounder AnimalSounder) {    animalSounder.MakeNoise()}复制代码

输出：

BARK BARKMEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW复制代码

结构体中嵌入接口

有人在后台给出了一个在结构体中嵌入接口的例子：

package mainimport (    "fmt")type HornSounder interface {    SoundHorn()}type Vehicle struct {    List [2]HornSounder}type Car struct {    Sound string}type Bike struct {   Sound string}func main() {    vehicle := new(Vehicle)    vehicle.List[0] = &Car{
   "BEEP"}    vehicle.List[1] = &Bike{
   "RING"}    for _, hornSounder := range vehicle.List {        hornSounder.SoundHorn()        // PressHorn(hornSounder) 这种方式也可以    }}func (car *Car) SoundHorn() {    fmt.Println(car.Sound)}func (bike *Bike) SoundHorn() {    fmt.Println(bike.Sound)}func PressHorn(hornSounder HornSounder) {    hornSounder.SoundHorn()}复制代码

在这个例子中，结构体 Vehicle 维护了一个实现 HornSounder 接口的值列表。在 main 函数中创建了变量 vehicle，并存储了 Car 类型变量和 Bike 变量的指针。这种赋值操作是可以的，因为 Car 和 Bike 都实现了接口。接着就是要一个简单的 loop 操作，循环调用 SoundHorn() 方法。

在你的应用程序中，任何你需要实现面向对象的东西在 Go 语言中都有。正如我之前所说的，Go 采用了 OOP 中最好的部分，省略了其他部分，为我们提供了编写多态代码的更好方法。

与主题相关联的几篇文章：

希望这几个简单的例子能对你的 Go 编程有帮助！