golang中并没有明确的面向对象的说法，实在要扯上的话，可以将struct比作其它语言中的class。
类声明
type Book struct {
Title string
Author string
intro string
}
这样就声明了一个类，其中没有public、protected、private的的声明。golang用另外一种做法来实现属性的访问权限：属性的开头字母是大写的则在其它包中可以被访问，否则只能在本包中访问。类的声明和方法亦是如此。
类方法声明
// 类方法声明-传递值对象
func (b Book) B1() {
b.Title = "Book001"
b.Author = "ErWan"
}
// 类方法声明-传递指针对象
func (b *Book) B2() {
b.Title = "Book002"
b.Author = "Tinywan"
}
和其它语言不一样，golang声明方法和普通方法一致，只是在func后增加了b Book这样的声明。加和没有加*的区别在于一个是传递指针对象（加*），一个是传递值对象。
传递指针和对象的区别
package main
import "fmt"
// 类声明
type Book struct {
Title string
Author string
DateTime string
}
// 类方法声明-传递值对象
func (b Book) B1() {
b.Title = "Book001"
b.Author = "ErWan"
}
// 类方法声明-传递指针对象
func (b *Book) B2() {
b.Title = "Book002"
b.Author = "Tinywan"
}
func main() {
/*声明一个 Book 类型的变量 b ，并调用 B1() 和 B2()*/
b := Book{"Def-Book", "Def-Author", "Def-DateTime"}
fmt.Println("B1 调用前：", b.Title, b.Author, b.DateTime)
b.B1()
fmt.Println("B1 调用后：", b.Title)
fmt.Println("------------------
")
fmt.Println("B2 调用前：", b.Title)
b.B2()
fmt.Println("B2 调用后：", b.Title)
}
执行结果：
B1() 的接收者是值类型 Book, B2() 的接收者是值类型 *Book , 两个方法内都是改变Name值。
小结：
1、接收者可以看作是函数的第一个参数，即这样的： func B1(b Book), func B2(b *Book)。 go不是面向对象的语言，所以用那种看起来像面向对象的语法来理解可能有偏差。
2、当调用 b.B1() 时相当于 B1(b) ，实参和行参都是类型 Book，可以接受。此时在B1()中的b只是 "Def-Book" 的值拷贝，所以B1()的修改影响不到" Def-Book"。
3、当调用 b.B2() => B2(b1)，这是将 Book 类型传给了 *Book 类型，go可能会取 b 的地址传进去： B2(&b)。所以 B2() 的修改可以影响 b 。
例如在一个beego 框架中我们要修改一个action的值，是这么定义的（为了修改内部结构的值。而不是传递一下）
func (this *InputController) InputGet(){
// Get 方式接受 name := this.GetString("name") // 不使用模版，直接用 this.Ctx.WriteString 输出字符串 this.Ctx.WriteString(name) }
值类型不可以改变值，而指针类型则是可以的
匿名结构体
p := struct {
Name string
Gender string
Age uint8
}{"Robert", "Male", 33}
匿名结构体最大的用处是在内部临时创建一个结构以封装数据，而不必正式为其声明相关规则。
实例化对象
实例化对象有好几种方式：
package main
// 类声明
type Person struct {
Name string
Age int
Doc []string // slice切片
}
// 类方法声明-传递值对象
func (p *Person) P1() {
p.Name = "Tinywan"
p.Age = 24
}
// 类方法声明-传递指针对象
func (p *Person) P2() {
p.Name = "Tinyaiai"
p.Age = 22
}
func main() {
// 实例化对象 实例化的时候可以初始化属性值，如果没有指明则默认为系统默认值
p1 := &Person{}
p1.Name = "ShaoBo Wan"
p1.Age = 20
p2 := &Person{Name:"HaHa"}
p3 := new(Person)
p3.Name = "New Name"
p4 := Person{}
p4.Name = "Name 001"
p4.Age = 26
p5 := Person{Name:"Name 002",Age:28}
// 使用中如果包含数组(动态数组 slice切片)，结构体的实例化需要加上类型如上如果intro的类型是[]string
p6 := &Person{
"zhangsan",
25,
[]string{"lisi", "wangwu"},
}
}
注意，最后一个实例化
p6 := &Person{
"zhangsan",
25,
[]string{"lisi", "wangwu"},
}
小结：
1、使用中如果包含数组，结构体的实例化需要加上类型如上如果Doc的类型是[]string。
2、实例化的时候可以初始化属性值，如果没有指明则默认为系统默认值。
3、加&符号和new的是指针对象，没有的则是值对象，这点和php、java不一致，在传递对象的时候要根据实际情况来决定是要传递指针还是值。
4、当对象比较小的时候传递指针并不划算。
继承
确切的说golang中叫做组合（composition）
1、先初始化为空再赋值
// 先初始化为空再赋值
s1 := &Student{}
s1.schoole = "QiHua"
2、直接赋值
// 直接赋值
s2 := &Student{
Persons: Persons{
Name:"Tinywan",
Age:24,
Doc:[]string{"H1","h2"},
},
schoole:"BeiJin Schoole",
}
3、完整代码
package main
import (
"fmt"
)
// 类声明
type Persons struct {
Name string
Age int
Doc []string // slice切片
}
// 获取Name
func (p *Persons) getName() {
fmt.Println("Name is ",p.Name)
}
type Student struct {
// Student 属性中声明了 Persons，表示组合了Persons 的属性和方法(属性和方法都会被继承)
Persons
Name string
schoole string
}
func main() {
// 先初始化为空再赋值
s1 := &Student{}
// 当访问Name的时候默认为ProsePoem的 Name，如果需要访问Persons 的 Name 属性可以使用 s1.Persons.Name 来访问方法同理。
s1.Name = "Tinywan"
s1.Persons.Name = "Persons Name"
s1.schoole = "QiHua"
fmt.Println("s1 = ",s1)
fmt.Println("
")
// 直接赋值
s2 := &Student{
Persons: Persons{
Name:"Tinywan",
Age:24,
Doc:[]string{"s2-Doc","s2-Doc"},
},
Name:"ErWan",
schoole:"BeiJin-Schoole",
}
fmt.Println("s2 = ",s2)
}
方法的继承和属性一致
参考
1、https://segmentfault.com/a/1190000012325027
2、