所谓的面向对象其实就是找一个专门做这个事的人来做，不用关心具体怎么实现的。所以说，面向过程强调的是过程，步骤。而面向对象强调的是对象，也就是干事的人。
Go语言：面向对象语言特性
方法
嵌入
接口
没有类
支持类型。 特别是， 它支持structs。 Structs是用户定义的类型。 Struct类型(含方法)提供类似于其它语言中类的服务。
Structs
一个struct定义一个状态。 这里有一个strudent struct。 它有一个Name属性和一个布尔类型的标志Real，告诉我们它是一个真实的strudent还是一个虚构的strudent。 Structs只保存状态，不保存行为。
type Creature struct {
Name string
Real bool
}
为结构体添加方法
方法是对特定类型进行操作的函数。 它们有一个接收器条款，命令它们对什么样的类型可进行操作。 这里是一个Hello()方法，它可对student结构进行操作，并打印出它们的状态：
func (s Student) Hello() {
fmt.Printf("Name: '%s', Real: %t\n", s.Name, s.Real)
}
func (s Student) func_name(){}一般在定义方法时，需要定义为结构体的指针，值类型的在修改结构体属性时，无法修改其内容
package main
import "fmt"
type human struct {
Name string
Real bool
}
type Student struct {
human
Id int
}
func (h human) Hello() {
fmt.Printf("姓名：%s\n", h.Name)
}
func (s Student) PrintId() {
fmt.Printf("学号：%d\n", s.Id)
}
func (s Student) EditId(id int) {
s.Id = id
}
func main() {
zhangsan := Student{
human: human{"zhangsan", true},
Id: 10,
}
zhangsan.Hello()
zhangsan.EditId(101)
zhangsan.PrintId()
}
嵌入（继承）
strudenthumanstudenthunmanpackage main
import "fmt"
type human struct {
Name string
Real bool
}
type Student struct {
human
Id int
}
func (h *human) Hello() {
fmt.Printf("姓名：%s", h.Name)
}
func main() {
zhangsan := &Student{
human: human{"zhangsan", true},
Id: 10,
}
zhangsan.Hello()
}
重写
就是子类(结构体)中的方法，将父类中的相同名称的方法的功能重新给改写了
注意：在调用时，默认调用的是子类中的方法
方法值和表达式值
方法表达式，即方法对象赋值给变量，方法表达式有两种使用方式：
- 隐式调用：方法值，调用函数时，无需再传递接收者，隐藏了接收者
- 显式调用：方法表达式，显示的把接收者*Student传递过去
实例：
package main
import "fmt"
type human struct {
Name string
Real bool
}
type Student struct {
human
Id int
}
func (h *human) Hello() {
fmt.Printf("姓名：%s\n", h.Name)
}
func (s Student) PrintId() {
fmt.Printf("学号：%d\n", s.Id)
}
func (s Student) EditId(id int) {
s.Id = id
}
func main() {
zhangsan := Student{
human: human{"zhangsan", true},
Id: 10,
}
// 常规调用
zhangsan.Hello()
// 方法值 无需传递接收者
hello := zhangsan.Hello
hello()
// 方法表达式，调用函数式，传递接收者
hello1 := (*Student).Hello // 括号是因为 . 的优先级要高于取指符，需要做特殊处理
hello1(&zhangsan)
}
Go语言：面向对象的设计
接口
implements接口的定义
type 接口名字 interface {
方法声明
}
接口的继承
package main
import "fmt"
type Fooer interface {
Foo1()
}
type Fooerson interface {
Fooer
Foo2()
}
type Foo struct {
}
type Fooson struct {
}
func (f Fooson) Foo1() {
fmt.Println("Foo1() here")
}
func (f Fooson) Foo2() {
fmt.Println("Foo2() here")
}
func (f Foo) Foo1() {
fmt.Println("Foo1() here")
}
func main() {
var fooerson Fooson
var fooson Fooerson
fooson = &fooerson
fooson.Foo1()
fooson.Foo2()
var foo Fooer
foo = fooson
fooson = foo // 这样是不允许的，fooson为Fooerson接口的实现，而foo是一个Fooer接口类型的变量，可以子转换为父不能反之
foo.Foo1()
}
空接口
空接口(interface{})不包含任何的方法，正因为如此，所有的类型都实现了空接口，因此空接口可以存储任意类型的数值
package main
import "fmt"
func main() {
var arr []interface{}
arr = append(arr, 1, "zhangsan", 3.3)
fmt.Println(arr)
}
类型断言
通过类型断言，可以判断空接口中存储的数据类型。
value, ok := m.(T)m:表空接口类型变量
T:是断言的类型
value: 变量m中的值。
ok: 布尔类型变量，如果断言成功为true,否则为false
func main() {
var a interface{}
a = 10
ok, value := a.(int)
fmt.Println(ok, value)
ok1, value1 := a.(string)
fmt.Println(ok1, value1)
}
封装
Go语言在包的级别进行封装。 以小写字母开头的名称只在该程序包中可见。 可以隐藏私有包中的任何内容，只暴露特定的类型，接口和工厂函数。
例如，在这里要隐藏上面的Foo类型，只暴露接口，你可以将其重命名为小写的foo，并提供一个NewFoo()函数，返回公共Fooer接口：
type foo struct {
}
func (f foo) Foo1() {
fmt.Println("Foo1() here")
}
func (f foo) Foo2() {
fmt.Println("Foo2() here")
}
func (f foo) Foo3() {
fmt.Println("Foo3() here")
}
func NewFoo() Fooer {
return &Foo{}
}
NewFoo()f := NewFoo()
f.Foo1()
f.Foo2()
f.Foo3()
继承
Go语言没有任何类型层次结构。 它允许你通过组合来共享实现的细节。 但Go语言，允许嵌入匿名组合。
通过嵌入一个匿名类型的组合等同于实现继承，这是它所有意图和目的。 一个嵌入的struct与基类一样脆弱。 你还可以嵌入一个接口， 如果嵌入类型没有实现所有接口方法，它甚至可能导致产生在编译时未被发现的运行错误。
这里SuperFoo嵌入Fooer接口，但是SuperFoo没有实现Foo的方法。 Go编译器会愉快地让你创建一个新的SuperFood并调用Fooer的方法，但很显然这在运行时会失败。 这会编译：
package main
import "fmt"
type Fooer interface {
Foo1()
Foo2()
Foo3()
}
type Foo struct {
}
func (f Foo) Foo1() {
fmt.Println("Foo1() here")
}
func (f Foo) Foo2() {
fmt.Println("Foo2() here")
}
func (f Foo) Foo3() {
fmt.Println("Foo3() here")
}
type SuperFooer struct {
Fooer
}
func main() {
s := SuperFooer{}
s.Foo3()
}
多态
多态性是面向对象编程的本质：只要对象坚持实现同样的接口，Go语言就能处理不同类型的那些对象。 Go接口以非常直接和直观的方式提供这种能力。
Golang当中的接口解决了这个问题，只要接口中定义的方法能对应的上，那么就可以认为这个类实现了这个接口。同一个接口，使用不同的实例而执行不同操作
package main
import (
"fmt"
)
type animal interface {
Say()
}
type human struct {
}
type cat struct {
}
func (h human) Say() {
fmt.Println("人类")
}
func (c cat) Say() {
fmt.Println("猫")
}
func main() {
var a animal
a = cat{}
a.Say()
a = human{}
a.Say()
}
