Go 面向对象编程（译）

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

今天接着给大家分享关于 Go 面向对象的好文。原文作者是 William Kennedy，《Go 语言实战》作者，博客 www.ardanlabs.com/blog/ 的维护者。大部分中国的 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 main

import (
    "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 BARK
MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW MEOW

结构体中嵌入接口

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

package main

import (
    "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 中最好的部分，省略了其他部分，为我们提供了编写多态代码的更好方法。

与主题相关联的几篇文章：
1.Methods, Interfaces and Embedded Types in Go
2.How Packages Work in Go
3.Singleton Design Pattern in Go

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

推荐阅读：
1.教女朋友写方法（续）
2.Go 面向对象式编程