Go 面向组合编程

在面向对象的语言如 Java, C++ 中，面向对象的 3 大特性：封装、继承、多态。
而 Go 语言并不是一门面向对象的语言，没有类的概念，接口的出现让结构和方法解耦，因此 Go 诞生了面向组合编程。

封装

封装即实现数据的隐藏，有权限才能访问。

在 Java 中只需要用要 private, protected, public 这三个关键字修饰字段或方法（或不写），即可实现 4 种访问层次控制：类中访问，子类访问，公开访问和包内访问。

而在 Go 语言中，只有 2 种访问层次控制：包内访问和包外访问。
实现方式：字段名、结构体名或方法名开头字母大写则为包外访问，小写则为包内访问。

  1. // hello.go
  2. package hello
  4. type MyHelloWord struct {    // main 包也能使用该结构体名
  5.      Name string                // main 包也能访问该字段
  6.     age int                    // 只能在 hello 包内访问该字段
  7. }
  9. func SayHello(name string) {...}        // main 包也能调用改方法
  10. func myAge(age int) {...}                // 只能在 hello 包内调用
  11. func (this *MyHelloWord) cool() {...}    // 只能在 hello 包内调用
  12. func (this *MyHelloWord) Cool() {...}    // main 包也能调用改方法
  14. // main.go
  15. package main
  17. import "hello"
  19. func main() {
  20.     m := hello.MyHelloWord{Name: "zwjason", age: 22}    // fail
  21.     hello.SayHello(m.Name)    // ok
  22.     hello.myAge(m.age)        // fail
  23. }

其实 hello.go 中 MyHelloWord 结构体的定义，在 main.go 中甚至不能定义 MyHelloWord 和 *MyHelloWord 类型以及与它的变量（如 m） ，因为 age 字段不能在包外访问。

一个比较规范的、包外访问的结构体定义如下：

  1. package person
  3. type Person struct {
  4.     name string
  5.     age  int
  6. }
  8. /* 包外访问方法 */
  10. // 构造函数
  11. func New(name string, age int) *Person {
  12.     return &Person{
  13.         name: name,
  14.         age:  age,
  15.     }
  16. }
  18. // name 的 setter 方法
  19. func (p *Person) SetName(name string) {
  20.     p.name = name
  21. }
  23. // name 的 getter 方法
  24. func (p *Person) Name() string {
  25.     return p.name
  26. }
  28. // age 的 setter 方法
  29. func (p *Person) SetAge(age int) {
  30.     p.age = age
  31. }
  33. // age 的 getter 方法
  34. func (p *Person) Age() int {
  35.     return p.age
  36. }
  38. // 其他包外访问方法
  40. /* 包内访问方法 */
  42. // 自定义一些包内方法，例如写一些辅助方法使得写一些包外方法更简洁
  43. // 如容器 list 的实现中，很多包外方法都用到了相同的逻辑
  44. // 把这部分逻辑抽了出来定义为包内方法，使得包外方法写得更简洁

仔细观察可以发现，getter 方法没有 get 开头，在 Go 中写 getter 方法只需要把字段的首字母大写作为函数名即可（如果字段本身就是首字母大写的，就没必要写 setter 和 getter 了）。

继承

在 Java 中使用 entends 关键字实现继承，implement 关键字实现接口，子类能够继承父类中非 private 的字段和方法以实现代码复用和扩展。

而在 Go 中没有继承机制，但是却可以使用组合实现类似继承的功能，组合即结构体嵌套。

  1. type Student struct {
  2.     Person *person.Person    // 首字母大写
  3.     id string
  4.     score int
  5. }

新定义一个结构体 Student，内嵌一个 *Person 字段，注意 Person 字段首字母大写，否则无法在包外引用 Person 的提供的所有的包外方法和字段。

详细代码如下：

  1. // student.go
  2. package student
  4. import (
  5.     "fmt"
  6.     "person"
  7. )
  9. type Student struct {
  10.     Person *person.Person    
  11.     id string
  12.     score int
  13. }
  15. /* 包外访问方法 */
  16. func New(name string, age int, id string, score int) *Student {
  17.     return &Student{
  18.         Person: person.New(name, age),
  19.         id: id,
  20.         score: score,
  21.     }
  22. }
  24. func (s *Student) ShowInfo() {
  25.     fmt.Println(s.Person.Name())
  26.     fmt.Println(s.Person.Age())
  27.     fmt.Println(s.id)
  28.     fmt.Println(s.score)
  29. }
  32. /* 包内访问方法 */
  33. // 自定义包内访问方法
  35. // main.go
  36. package main
  38. import (
  39.     "student"
  40. )
  42. func main() {
  43.     s := student.New("zwjason", 22, "201826010505", 100)
  44.     s.ShowInfo()            // Student 的方法
  45.     s.Person.ShowInfo()        // Person 的方法
  46. }
  47. 输出如下：
  48. zwjason
  49. 22
  50. 201826010505
  51. 100
  52. bankarian
  53. 20

多态

多态指的是一个实体可以具有多种形式，在 Java 中表现为子类对象可以以父类的身份出现。
以如下继承结构为例：
image.png
在代码中我们可以使用 Person p = new Student() 这样的写法，即把子类对象赋给了它的父类类型变量。

在 Go 中，采用接口来实现类似功能。
实现原理：若一个类型实现了一个接口，那么该类型的实例可以赋给它所实现的接口类型的变量。
我们把上面 person.go 中的 ShowInfo() 方法改为接口：

  1. // person.go
  2. // 接口
  3. type Infoer interface {
  4.     ShowInfo()
  5. }
  7. // main.go
  8. func main() {
  9.     s := student.New("zwjason", 22, "201826010505", 100)
  10.     p := person.New("bankarian", 20)
  11.     var info person.Infoer = s    // Student 实例以 Infoer 的身份出现
  12.     info.ShowInfo()                // 调用的是 Student 实现的 
  13.     info = p                    // Person 实例以 Infoer 的身份出现
  14.     info.ShowInfo()                // 调用的是 Person 实现的
  15. }
  16. 输出如下：
  17. zwjason
  18. 22
  19. 201826010505
  20. 100
  21. bankarian
  22. 20

Person 和 Student 类型都实现了 Infoer 接口，两者的实例都可以赋给 Infoer 变量，而且两者的 ShowInfo() 方法相互独立，互不影响，这可以看作是粗略的方法重载。
多种类型共同实现一种接口类型，每种类型各自拥有一套接口内定义的方法集合，互不影响。
但是要注意如下调用规则：
Go 语言规范定义了接口方法集的调用规则：
类型 T 的可调用方法集包含接受者为 T 或 T 的所有方法集（因为指针可以被解引用）；
类型 T 的可调用方法集包含接受者为 T 的所有方法；
类型 T 的可调用方法集不包含接受者为 *T 的方法（因为存储在接口中的值没有地址）

重载

在面向对象中，字段或方法重载也是经常发生的，那么在 Go 中如何实现呢？

方法一

我们可以看到，在上面介绍多态的过程中，将需要重载的方法定义为接口内的方法，然后让结构体都实现这个接口即可实现方法重载。

方法二

首先明白，在 Go 中是如何处理命名冲突的，即由于组合发生了字段名或方法名相同的情况。
命名冲突处理规则：外层覆盖内层，但保留两者的内存空间。
若把 person.go 和 student.go 中的 ShowInfo() 方法仅定义为包外访问，没有接收者，不属于任何接口，那么
student 的 ShowInfo() 将覆盖掉 Person 的 ShowInfo()。