Go 继承

1.前言

面向对象编程的三大特性：封装、继承、多态。可见继承是面向对象程序设计中一个重要的概念。Go 作为面向对象的编程语言，自然也支持继承。

比较特殊的是 Go 实现继承的方式与其他传统 OOP 语言所有不同，不像 C++ 有专门的继承语法，或者像 Java 中有专门的关键字 extends。

C++ 的继承：

// 基类
class Animal {
public:
    void eat(); 
	void sleep();
};


// 子类
class Dog : public Animal {
public:
    void bark();
};

Java 的继承：

// 基类
public class Animal {
	public void eat(){};
	public void sleep(){};
}

// 子类
public class Dog extends Animal {
	public void bark(){};
}

2.嵌入式继承机制

Go 使用匿名嵌套实现继承。

我们用很容易理解的动物-猫来举例子。

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

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

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

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

Cat 结构体本身没有 Name 字段，也没有去实现 Eat() 方法。唯一有的就是匿名嵌套的方式继承了 Animal 父类。至此，我们证明了 Go 通过匿名嵌套的方式实现了继承。

上面是嵌入类型实例，同样地也可以嵌入类型指针。

type Cat struct {
	*Animal
}

cat := &Cat{
	Animal: &Animal{
		Name: "cat",
	},
}

3.嵌入式继承机制的局限

相比于 C++ 和 Java， Go 的继承机制的作用是非常有限的，因为没有抽象方法，有很多的设计方案可以在 C++ 和 Java 中轻松实现，但是 Go 的继承却不能完成同样的工作。

package main

import "fmt"

// Animal 动物基类
type Animal struct {
	name string
}

func (a *Animal) Name() string {
	return a.name
}

func (a *Animal) Speak() string {
	return fmt.Sprintf("my name is %v", a.name)
}

func (a *Animal) Play() {
	fmt.Println(a.Speak())
}

// Dog 狗子类
type Dog struct {
	Animal
	Gender string
}

func (d *Dog) Speak() string {
	return fmt.Sprintf("%v and my gender is %v", d.Animal.Speak(), d.Gender)
}

func main() {
	d := Dog{
		Animal: Animal{name: "Hachiko"},
		Gender:  "male",
	}
	fmt.Println(d.Name())
	fmt.Println(d.Speak())
	d.Play() // Play() 中调用的是基类方法 Animal.Speak()，而不是 Dog.Speak()
}

运行输出：

Hachiko
my name is Hachiko and my gender is male
my name is Hachiko

上面的例子中，Dog 类型重写了 Speak() 方法。然而如果父类型 Animal 有另外一个方法 Play() 调用 Speak() 方法，但是 Dog 没有重写 Play() 的时候，Dog 类型的 Speak() 方法则不会被调用，因为 Speak() 方法不是抽象方法，此时继承无法实现多态。

4.使用接口封装方法

为了解决上面的问题，我们应该使用接口封装方法，通过实现接口方法来实现多态。

package main

import (
    "fmt"
)

type Animal interface {
    Name() string
    Speak() string
    Play()
}

type Dog struct {
    name string
    gender string
}

func (d *Dog) Play() {
    fmt.Println(d.Speak())
}

func (d *Dog) Speak() string {
    return fmt.Sprintf("my name is %v and my gender is %v", d.name, d.gender)
}

func (d *Dog) Name() string {
    return d.name
}

func Play(a Animal) {
    a.Play()
}

func main() {
    d :=&Dog{"Hachiko", "male"}
    fmt.Println(d.Name())
    fmt.Println(d.Speak())
    Play(d)
}

运行输出：

Hachiko
my name is Hachiko and my gender is male
my name is Hachiko and my gender is male

注意：Go 中某个类型需要实现接口中的所有方法才算作实现了接口。

5.小结

如果一个 struct 匿名嵌套另一个结构体，那么这个 struct 可以直接访问匿名结构体的属性和方法，从而实现继承。

如果一个 struct 有名嵌套了另一个结构体，那么这个模式叫做组合。

如果一个 struct 匿名嵌套了多个结构体，那么这个 struct 可以直接访问多个匿名结构体的属性和方法，从而实现多重继承。

参考文献

掘金.两分钟让你明白Go中如何继承
The Go Programming Language Specification.Struct types
Hackthology.Golang中的面向对象继承
Go语言中的代码重用 - 继承还是组合？