乐趣区

两分钟让你明白Go中如何继承

jiezi

最近在重构代码的时候，抽象了大量的接口。也使用这些抽象的接口做了很多伪继承的操作，极大的减少了代码冗余，同时也增加了代码的可读性。

然后随便搜了一下关于 Go 继承的文章，发现有的文章的代码量过多，并且代码 format 极其粗糙，命名极其随意，类似于 A、B 这种，让人看着看着就忘了到底是谁继承谁，我又要回去看一遍逻辑。

虽然只是样例代码，我认为仍然需要做到简洁、清晰以及明了。这也是我为什么要写这篇博客的原因。接下里在这里简单分享一下在 Go 中如何实现继承。

1. 简单的组合

说到继承我们都知道，在 Go 中没有 extends 关键字，也就意味着 Go 并没有原生级别的继承支持。这也是为什么我在文章开头用了 伪继承 这个词。本质上，Go 使用 interface 实现的功能叫组合，Go 是使用组合来实现的继承，说的更精确一点，是使用组合来代替的继承，举个很简单的例子。

1.1 实现父类

我们用很容易理解的 动物 – 猫来举例子，废话不多说，直接看代码。

type Animal struct {Name string}

func (a *Animal) Eat() {fmt.Printf("%v is eating", a.Name)
    fmt.Println()}

type Cat struct {*Animal}

cat := &Cat{
    Animal: &Animal{Name: "cat",},
}
cat.Eat() // cat is eating

1.2 代码分析

首先，我们实现了一个 Animal 的结构体，代表动物类。并声明了 Name 字段，用于描述动物的名字。

然后，实现了一个以 Animal 为 receiver 的 Eat 方法，来描述动物进食的行为。

最后，声明了一个 Cat 结构体，组合了 Cat 字段。再实例化一个猫，调用 Eat 方法，可以看到会正常的输出。

可以看到，Cat 结构体本身没有 Name 字段，也没有去实现 Eat 方法。唯一有的就是组合了 Animal 父类，至此，我们就证明了已经通过组合实现了继承。

2. 优雅的组合

熟悉 Go 的人看到上面的代码可能会发出如下感叹

这也太粗糙了吧 — By 鲁迅：我没说过这句话

的确，上面的仅仅是为了给还没有了解过 Go 组合的人看的。作为一个简单的例子来理解 Go 的组合继承，这是完全没有问题的。但如果要运用在真正的开发中，那还是远远不够的。

举个例子，我如果是这个抽象类的使用者，我拿到 animal 类不能一目了然的知道这个类干了什么，有哪些方法可以调用。以及，没有统一的初始化方式，这意味着凡是涉及到初始化的地方都会有重复代码。如果后期有初始化相关的修改，那么只有一个一个挨着改。所以接下来，我们对上述的代码做一些优化。

2.1 抽象接口

接口用于描述某个类的行为。例如，我们即将要抽象的动物接口就会描述作为一个动物，具有哪些行为。常识告诉我们，动物可以进食（Eat），可以发出声音（bark），可以移动（move）等等。这里有一个很有意思的类比。

接口就像是一个招牌，比如一家星巴克。星巴克就是一个招牌（接口）。

你看到这个招牌会想到什么？美式？星冰乐？抹茶拿铁？又或者是拿铁，甚至是店内的装修风格。

这就是一个好的接口应该达到的效果，同样这也是为什么我们需要抽象接口。

// 模拟动物行为的接口
type IAnimal interface {Eat() // 描述吃的行为
}

// 动物 所有动物的父类
type Animal struct {Name string}

// 动物去实现 IAnimal 中描述的吃的接口
func (a *Animal) Eat() {fmt.Printf("%v is eating\n", a.Name)
}

// 动物的构造函数
func newAnimal(name string) *Animal {
    return &Animal{Name: name,}
}

// 猫的结构体 组合了 animal
type Cat struct {*Animal}

// 实现猫的构造函数 初始化 animal 结构体
func newCat(name string) *Cat {
    return &Cat{Animal: newAnimal(name),
    }
}

cat := newCat("cat")
cat.Eat() // cat is eating

在 Go 中其实没有关于构造函数的定义。例如我们在 Java 中可以使用构造函数来初始化变量，举个很简单的例子，Integer num = new Integer(1)。而在 Go 中就需要使用者自己通过结构体的初始化来模拟构造函数的实现。

然后在这里我们实现子类 Cat，使用组合的方式代替继承，来调用 Animal 中的方法。运行之后我们可以看到，Cat 结构体中并没有 Name 字段，也没有实现 Eat 方法，但是仍然可以正常运行。这证明我们已经通过组合的方式了实现了继承。

2.2 重载方法

// 猫结构体 IAnimal 的 Eat 方法
func (cat *Cat) Eat() {fmt.Printf("children %v is eating\n", cat.Name)
}

cat.Eat()
// children cat is eating

可以看到，Cat 结构体已经重载了 Animal 中的 Eat 方法，这样就实现了重载。

2.3 参数多态

什么意思呢？举个例子，我们要如何在 Java 中解决函数的参数多态问题？熟悉 Java 的可能会想到一种解决方案，那就是通配符。用一句话概括，使用了通配符可以使该函数接收某个类的所有父类型或者某个类的所有子类型。但是我个人认为对于不熟悉 Java 的人来说，可读性不是特别友好。

而在 Go 中，就十分方便了。

func check(animal IAnimal) {animal.Eat()
}

在这个函数中就可以处理所有组合了 Animal 的单位类型，对应到 Java 中就是上界通配符，即一个可以处理任何特定类型以及是该特定类型的派生类的通配符，再换句人话，啥动物都能处理。

3. 总结

凡事都有两面性，做优化也不例外。大量的抽象接口的确可以精简代码，让代码看起来十分优雅、舒服。但是同样，这会给其他不熟悉的人 review 代码造成理解成本。想象你看某段代码，全是接口，点了好几层才能看到实现。更有的，往下找着找着突然就在另一个接口处断掉了，必须要手动的去另一个注册的地方去找。

这就是我认为优化的时候要面临的几个问题：

  • 优雅
  • 可读
  • 性能

有的时候我们很难做到三个方面都兼顾，例如这样写代码看起来很难受，但是性能要比优雅的代码好。再例如，这样写看起来很优雅，但是可读性很差等等。

还是引用我之前博客中经常写的一句话

适合自己的才是最好的

这种时候只能根据自己项目的特定情况，选择最适合你的解决方案。没有万能的解决方案。

分享一句最近弹吉他看到的毒鸡汤，学习也是一样的。

练琴的路上没有捷径，全是弯路

往期文章：

  • Go 中使用 Seed 得到重复随机数的问题
  • 游戏服务器和 Web 服务器的区别
  • go 源码解析 -Println 的故事
  • 用 go-module 作为包管理器搭建 go 的 web 服务器
  • WebAssembly 完全入门——了解 wasm 的前世今身
  • 小强开饭店 - 从单体应用到微服务

相关：

  • 微信公众号：SH 的全栈笔记（或直接在添加公众号界面搜索微信号 LunhaoHu）
退出移动版