Go 面向对象，封装、继承、多态

Go 面向对象，封装、继承、多态

经典OO（Object-oriented 面向对象）的三大特性是封装、继承与多态，这里我们看看Go中是如何对应的。

1. 封装

封装就是把数据以及操作数据的方法“打包”到一个抽象数据类型中，这个类型封装隐藏了实现的细节，所有数据仅能通过导出的方法来访问和操作。这个抽象数据类型的实例被称为对象。经典OO语言，如Java、C++等都是通过类(class)来表达封装的概念，通过类的实例来映射对象的。熟悉Java的童鞋一定记得**《Java编程思想》**一书的第二章的标题：“一切都是对象”。在Java中所有属性、方法都定义在一个个的class中。

Go语言没有class，那么封装的概念又是如何体现的呢？来自OO语言的初学者进入Go世界后，都喜欢“对号入座”，即Go中什么语法元素与class最接近！于是他们找到了struct类型。

Go中的struct类型中提供了对真实世界聚合抽象的能力，struct的定义中可以包含一组字段(field)，如果从OO角度来看，你也可以将这些字段视为属性，同时，我们也可以为struct类型定义方法(method)，下面例子中我们定义了一个名为Point的struct类型，它拥有一个导出方法Length：

type Point struct {
    x, y float64
}

func (p Point) Length() float64 {
    return math.Sqrt(p.x * p.x + p.y * p.y)
}

我们看到，从语法形式上来看，与经典OO声明类的方法不同，Go方法声明并不需要放在声明struct类型的大括号中。Length方法与Point类型建立联系的纽带是一个被称为receiver参数的语法元素。

那么，struct是否就是对应经典OO中的类呢? 是，也不是！从数据聚合抽象来看，似乎是这样, struct类型可以拥有多个异构类型的、代表不同抽象能力的字段(比如整数类型int可以用来抽象一个真实世界物体的长度，string类型字段可以用来抽象真实世界物体的名字等)。

但从拥有方法的角度，不仅是struct类型，Go中除了内置类型的所有其他具名类型都可以拥有自己的方法，哪怕是一个底层类型为int的新类型MyInt：

type MyInt int

func(a MyInt)Add(b int) MyInt {
 return a + MyInt(b)
}

2. 继承

就像前面说的，Go设计者在Go诞生伊始就重新评估了对经典OO的语法概念的支持，最终放弃了对诸如类、对象以及类继承层次体系的支持。也就是说：在Go中体现封装概念的类型之间都是“路人”，没有亲爹和儿子的关系的“牵绊”。

谈到OO中的继承，大家更多想到的是子类继承了父类的属性与方法实现。Go虽然没有像Java extends关键字那样的显式继承语法，但Go也另辟蹊径地对“继承”提供了支持。这种支持方式就是类型嵌入(type embedding)，看一个例子：

package main

import "fmt"

type P struct {
	A int
	b string
}

func (P) M1() {
	fmt.Println("P M1")
}

func (P) M2() {
	fmt.Println("P M2")
}

type Q struct {
	c [5]int
	D float64
}

func (Q) M2() {
	fmt.Println("Q M2")
}
func (Q) M3() {
	fmt.Println("Q M3")
}

func (Q) M4() {
	fmt.Println("Q M3")
}

type T struct {
	P
	Q
	E int
}

// M2 重写方法：在 T 中重写 M2 方法，明确调用哪个嵌入结构体的 M2。
func (t T) M2() {
	t.P.M2() // 或者 t.Q.M2()
}

func main() {
	var t T
	t.M1()
	//需要显式调用
	t.P.M2()
	t.Q.M2()
	// 或重写方法
	t.M2()
	t.M3()
	t.M4()
	println(t.A, t.D, t.E)
}

我们看到类型T通过嵌入P、Q两个类型，“继承”了P、Q的导出方法(M1~M4)和导出字段(A、D)。

不过实际Go中的这种“继承”机制并非经典OO中的继承，其外围类型(T)与嵌入的类型(P、Q)之间没有任何“亲缘”关系。P、Q的导出字段和导出方法只是被提升为T的字段和方法罢了，其本质是一种组合，是组合中的代理（delegate）模式的一种实现。T只是一个代理（delegate），对外它提供了它可以代理的所有方法，如例子中的M1~M4方法。当外界发起对T的M1方法的调用后，T将该调用委派给它内部的P实例来实际执行M1方法。

以经典OO理论话术去理解就是T与P、Q的关系不是is-a，而是has-a的关系。

组合大于继承

其实这种继承更应该被称为组合。Go 更愿意将模块分成互相独立的小单元，分别处理不同方面的需求，最后以匿名嵌入的方式组合到一起，共同实现对外接口。也就是组合大于继承的思想。

组合没有父子依赖，不会破坏封装。且整体和局部松耦合，可任意增加来实现扩展。各单元持有单一职责，互不关联，自由灵活组合，实现和维护更加简单。

匿名嵌套

匿名嵌套在编译时会根据嵌套类型生成包装方法，包装方法实际是调用嵌套类型的原始方法。

拓：匿名嵌套的多种玩法

• struct 匿名嵌套 struct（上面已经展示过了）
• interface 匿名嵌套 interface
• struct 匿名嵌套 interface

interface 匿名嵌套 interface

接口可嵌入其他匿名接口，相当于将其声明的方法集导入。

当然，注意只有实现了两个接口的全部的方法，才算实现大接口哈。

Go 标准库中经典用法如下：

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

type ReadWriter interface {
   Reader
   Writer
}

struct 匿名嵌套 interface

编译器自动为 struct 的方法集加上 interface 的所有方法。
（后面是我猜的）如我们通过 struct.M () 调用 interface 的 M 方法，编译器实际为 struct 生成包装方法 struct.interface.M()。

注意：struct 中的 interface 要记得赋值哈，不然调用时会显示 interface nil panic。

type I interface {
	M()
}

type A struct {
	I
}

type B struct {
}

func (B) M() {
	print("B")
}

func main() {
	var a A = A{I: B{}}
	a.M() // B

	// 当然 A 也是 I 接口类型
	var i I = A{I: B{}}
	i.M() // A
}

我们同时验证以下匿名嵌套的同名覆盖问题：

type I interface {
	M()
}

type A struct {
	I
}

type B struct {
}

// 多加这个：验证匿名方法同名覆盖
func (A) M() {
	print("A")
}

func (B) M() {
	print("B")
}

func main() {
	var a A = A{I: B{}}
	a.M() // A
}

Go 标准库中经典用法如下：

context 包中：

type valueCtx struct {
  Context  // 匿名接口
  key, val interface{}
}

// 创建 valueCtx
func WithValue(parent Context, key, val interface{}) Context {
  return &valueCtx{parent, key, val}
}

// 实际重写了 Value() 接口，其他父 context 的方法依旧可以调用
func (c *valueCtx) Value(key interface{}) interface{} {
  if c.key == key {
    return c.val
  }
  return c.Context.Value(key)
}

3. 多态

经典OO中的多态是尤指运行时多态，指的是调用方法时，会根据调用方法的实际对象的类型来调用不同类型的方法实现。

下面是一个C++中典型多态的例子：

#include <iostream>

class P {
  public:
    virtual void M() = 0;
};

class C1: public P {
  public:
    void M();
};

void C1::M() {
  std::cout << "c1.M()\n";
}

class C2: public P {
  public:
    void M();
};

void C2::M() {
  std::cout << "c2.M()\n";
}

int main() {
  C1 c1;
  C2 c2;
  P *p = &c1;
  p->M(); // c1.M()
  p = &c2;
  p->M(); // c2.M()
}

这段代码比较清晰，一个父类P和两个子类C1和C2。父类P有一个虚拟成员函数M，两个子类C1和C2分别重写了M成员函数。在main中，我们声明父类P的指针，然后将C1和C2的对象实例分别赋值给p并调用M成员函数，从结果来看，在运行时p实际调用的函数会根据其指向的对象实例的实际类型而分别调用C1和C2的M。

显然，经典OO的多态实现依托的是类型的层次关系。那么对应没有了类型层次体系的Go来说，它又是如何实现多态的呢？Go使用接口来解锁多态！

和经典OO语言相比，Go更强调行为聚合与一致性，而非数据。因此Go提供了对类似duck typing的支持，即基于行为集合的类型适配，但相较于ruby等动态语言，Go的静态类型机制还可以保证应用duck typing时的类型安全。

Go的接口类型本质就是一组方法集合(行为集合)，一个类型如果实现了某个接口类型中的所有方法，那么就可以作为动态类型赋值给接口类型。通过该接口类型变量的调用某一方法，实际调用的就是其动态类型的方法实现。看下面例子：

type MyInterface interface {
 M1()
 M2()
 M3()
}

type P struct {
}

func (P) M1() {}
func (P) M2() {}
func (P) M3() {}

type Q int 
func (Q) M1() {}
func (Q) M2() {}
func (Q) M3() {}

func main() {
 var p P
 var q Q
 var i MyInterface = p
 i.M1() // P.M1
 i.M2() // P.M2
 i.M3() // P.M3

 i = q
 i.M1() // Q.M1
 i.M2() // Q.M2
 i.M3() // Q.M3
}

Go这种无需类型继承层次体系、低耦合方式的多态实现，是不是用起来更轻量、更容易些呢！

Go 通过接口来实现多态。

Go 的接口类型本质就是一组方法集合 (行为集合)，一个类型如果实现了某个接口类型中的所有方法，那么就可以作为动态类型赋值给接口类型（注意：定义一个接口变量，该变量本质是个 Struct 类型的变量哦）。

Go 的接口是特别重要的东西，通过学习 Go 接口的底层实现可以学到很多东西，例如动态语言的实现，方法动态派发实现等。

4. Gopher的“OO思维”

到这里，来自经典OO语言阵营的小伙伴们是不是已经找到了当初在入门Go语言时“感觉到别扭”的原因了呢！这种“别扭”就在于Go对于OO支持的方式与经典OO语言的差别：秉持着经典OO思维的小伙伴一上来就要建立的继承层次体系，但Go没有，也不需要。

要转变为正宗的Gopher的OO思维其实也不难，那就是“prefer接口，prefer组合，将习惯了的is-a思维改为has-a思维”。

5. 小结

是时候给出一些结论性的观点了：

• Go支持OO，只是用的不是经典OO的语法和带层次的类型体系；
• Go支持OO，只是用起来需要换种思维；
• 在Go中玩转OO的思维方式是：“优先接口、优先组合”。