阅读 983

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 面向对象式编程

关注下面的标签,发现更多相似文章
评论