Go不是纯粹的面向对象语言，和传统的面向对象编程有区别，所以说Go语言支持面向对象编程特性是比较准确的。

Go语言基于结构体struct来实现OOP特性，通过type和struct关键字声明结构体，格式如下：

type 类型名 struct { // 类型名在同一个包内不能重复
  字段1 字段1类型 // 字段名必须唯一
  字段2 字段2类型
}

结构体从本质上讲是一种自定义的数据类型，只不过这种数据类型比较复杂，可以认为结构体是一种聚合类型。

结构体实例化

声明结构体变量再赋值：

type Student struct {
  sid    int      // 字段首字母小写，类似private，其它包不能使用
  course []string // 选修课程
}
func main() {
// 声明一个结构体对象，值类型，默认开辟空间，字段赋予零值
var s Student
fmt.Println("s:", s) // s: {0 []}
// 访问结构体成员使用点号 . 操作符
fmt.Println(s.sid) // 0
// 更改成员变量值
s.sid = 1001
fmt.Println(s.sid) // 1001
// 方式2：键值对赋值
s2 := Student{sid: 1002, course: []string{"chinese", "math"}}
fmt.Println(s2)
// 方式3：多值赋值
s3 := Student{1003, []string{"chinese", "math"}}
fmt.Println(s3)
}

实例化之&结构体：

func initSid(s *Student) {
s.sid = 1001 // 其实是(*s).sid = 1001
}
func main() {
s := Student{course: []string{"chinese", "math"}}
initSid(&s)
fmt.Println(s) // {1001 [chinese math]}
s2 := &Student{course: []string{"chinese", "math"}}
initSid(s2)
fmt.Println(s2) // &{1001 [chinese math]}
}

实例化之new(结构体)：

func main() {
s := new(Student) // 等同于 &Student{}
fmt.Println(s)    // &{0 []}
}

模拟构造函数

Go语言没有构造函数，但可以使用结构体初始化过程来模拟实现构造函数（首字母大写）。

// 自定义工厂函数，返回局部变量地址
func NewStudent(sid int, course []string) *Student {
return &Student{
sid:    sid,
course: course}
}
func main() {
s := NewStudent(1001, []string{"math", "english"})
fmt.Println(s) // &{1001 [math english]}
}

方法接收器

Go语言中的方法（Method）是一种作用于特定类型变量的函数，这种特定类型变量叫做接收者（Receiver）。方法与函数的区别是，函数不属于任何类型，方法属于特定类型。

func (s Student) learn() {
fmt.Printf("%d 正在学习...", s.sid)
}
func main() {
s := NewStudent(1001, []string{"math", "english"})
s.learn()
}

接收者是指针类型：

type Player struct {
Name        string
HealthPoint int
}
func NewPlayer(name string, hp int) *Player {
return &Player{
name,
hp,
}
}
func (p *Player) attack() {
fmt.Printf("%s 发起攻击！\n", p.Name)
}
func (p *Player) attacked() {
fmt.Printf("%s 被攻击！\n", p.Name)
p.HealthPoint -= 10
fmt.Println("HealthPoint:", p.HealthPoint)
}
func main() {
player := NewPlayer("张三", 100)
player.attack()
player.attacked()
}

匿名字段

结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段称为匿名字段。

type Person struct {
string // 其实是string string
int    // 其实是int int
}
func main() {
p := Person{
"张三",
18,
}
fmt.Println(p.string, p.int) // 张三 18
}

结构体也可以作为匿名字段使用：

type Addr struct {
province string
city     string
}
type Person struct {
string
int
Addr // 其实是Addr Addr
}
func main() {
p := Person{
"张三",
18,
Addr{"广东", "深圳"},
}
fmt.Println(p.Addr.province, p.city) // 广东 深圳
}

当结构体中有和匿名字段相同字段时，采用外层优先访问原则。

包和封装

每个目录一个包，main包包含可执行入口。

为结构定义的方法必须放在同一个包内，可以是不同文件。

结构体继承

// Animal 动物
type Animal struct {
name string
}
func (a *Animal) eat() {
fmt.Printf("%s is eating！\n", a.name)
}
// Dog 类型
type Dog struct {
Kind    string
*Animal // 通过嵌套匿名结构体实现继承，直接写类型，没有字段名
}
func (d *Dog) bark() {
fmt.Printf("%s is barking ~\n", d.name)
}
func main() {
d := &Dog{
Kind: "金毛",
Animal: &Animal{ // 注意嵌套的是结构体指针
name: "旺财",
},
}
d.eat()
d.bark()
}

结构体标签

type Stu struct {
Name string json:"name" // 结构体标签
Age  int    json:"-"    // 表示不参与序列化
}
func main() {
stuStruct := Stu{Name: "张三", Age: 18}
// 序列化
jsonStuStruct, _ := json.Marshal(stuStruct)
fmt.Println(string(jsonStuStruct)) // {"name":"张三"}
// 反序列化
var StuStruct Stu
err := json.Unmarshal(jsonStuStruct, &StuStruct)
if err != nil {
return
}
fmt.Println(StuStruct) // {张三 0}
}