人有的时候真的很贱，忙的时候想闲下来，闲的时候又很怀念忙的日子。疫情的这段时间待在家里远程办公，晚上空闲的时间相对较多，突然有种想学习一门新语言的冲动，选择什么好呢？记得年前出差的产品部兄弟告诉我，年后他想学习一下go语言，不纠结，撸起袖子搞搞看。鼓捣了一周多，发现这个语言真有特点，这里谈谈go的面向对象实现的奇特感受。
什么是面向对象，满足三大特性，封装、继承和多态。严格来讲，go语言是没有面向对象，但就像动态语言的世界里一直流传着一种叫做鸭子类型的风格，“如果它走起来像鸭子，叫起来像鸭子，那它就是一只鸭子”，golang就是这样的，没有类，只有struct，且struct只拥有变量，不能带有method，只能通过struct+method的巧妙方式去实现，使其看起来具备OOP风格的“鸭子”。
- 封装和继承
封装从字面上来理解就是包装的意思，专业点就是信息隐藏，圈内的行话就是封装属性和方法。继承就是子类继承父类的的属性和方法，比较好理解。go语言里面的封装和继承，通过另外一种方式实现，比较奇特，来一段代码看看。
package main
import (
"fmt"
)
/*
Person结构体当成类
属性：age name
方法：setName getName setAge printInfo
是不是有点奇怪和变态 struct+method
*/
type Person struct {
age int
name string
}
func (this *Person)setName(tName string){
this.name=tName
}
func (this *Person)getName()(string){
return this.name
}
func (this *Person)setAge(tAge int){
this.age=tAge
}
func (this *Person)printInfo(){
fmt.Printf("Hello,my name is %s,I'm %d years old.\n",this.name,this.age);
}
/*
1.Student继承Person同时拥有 Person下的所有的函数etName getName setAge printInfo
2.同时重载printInfo方法
*/
type Student struct {
Person
grad int
class int
}
func (s *Student)printInfo(){
fmt.Printf("Hello,I'm a student,my name is %s,I'm %d years old,I'm in class %d, grad %d .\n",s.name,s.age,s.class,s.grad);
}
func main(){
p:=Person{36,"Ap" }
p.printInfo()
p.setName("Yuki")
p.setAge(7)
p.printInfo()
s:=Student{p,1,3}
s.printInfo()
s.setName("Tom")
s.setAge(12)
s.printInfo()
}
##########go run main.go##########
Hello,my name is Ap,I'm 36 years old.
Hello,my name is Youki,I'm 7 years old.
Hello,I'm a student,my name is Yuki,I'm 7 years old,I'm in class 3, grad 1 .
Hello,I'm a student,my name is Tom,I'm 12 years old,I'm in class 3, grad 1 .
- 多态
go没有 implements, extends 关键字，严格来说，多态与继承、重载并不是孤立的，它们之间存在着紧密的联系。在百度百科中的多态解释，“在面向对象语言中，接口的多种不同的实现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作；java中当子类拥有和父类同样的函数，当通过这个父类对象的引用调用这个函数的时候，调用到的是子类中的函数”(哇，好复杂！好绕口！)，能不能简单化一点，我的理解是，同一个函数定义接受为父类，调用时为子类的实例而执行传入实例下的动作。菜鸟教程解释为，同一个接口，使用不同的实例而执行不同操作（还是菜鸟说得好啊）。直接撸代码，如下：
package main
import (
"fmt"
)
//相当于父类或者超类
type Human interface{
HelloWord()
}
func printfHello(h Human){
h.HelloWord()
}
//Student实现了Human的HellWord
type Student struct {
name string
}
func (s *Student)HelloWord(){
fmt.Printf("Hello ,I'm a student,my Name is %s.\n",s.name);
}
//Man实现了Human的HellWord
type Man struct {
name string
}
func (s *Man)HelloWord(){
fmt.Printf("Hello ,I'm a workman,my Name is %s.\n",s.name);
}
func main(){
s:=&Student{"Yuki"}
m:=&Man{"Ap"}
//多态
printfHello(s)
printfHello(m)
}
######go run main.go########
Hello ,I'm a student,my Name is Yuki.
Hello ,I'm a workman,my Name is Ap.
Human 是个接口，这里可以理解为其它语言中的父类，用interface来模仿superclass。 Student和Man实现了HelloWord方法，但是Human 怎么知道Student和Man已经实现了它呢？ 原因在于Student、Man实现了Human 中的全部方法， 这个时候就会认为子类。
golang社区很多数人认为，少了其它语言的implements/extends，让go显得更加优雅。但是如果没有implements 关键字，怎么知道man和student，实现了human的接口，如果没有文档，又不熟悉接口类库的话，感觉程序维护代码的工作量会加重很多，优雅从何谈起呢？
