在Go语言中没有了class 类关键字，但是这并不代表Go语言不能使用面向对象编程，在Go语言中使用了struct关键和interface 关键字来定义对象和方法接口。具体如下：
面向对象
Go中使用struct来定义类，假如我们需要定义一个person类，其中包含姓名、年龄等信息。我们可以使用struct关键字来定义（这个和c语言中的struct一样，只不过Go的struct支持的特性更多）。
package main import ( "fmt" ) type person struct { # 定义结构体包含信息 name string age int } func main() { s1 := person{"aa", 22} # 初始化信息 fmt.Println(s1) }
类的继承，现在假如在添加一个学生类（包含姓名、年龄、学校、班级号），我们可以使用使用类似于类中的继承的概念来使用刚才定义的person结构体。
package main import ( "fmt" ) type Person struct { name string age int } type student struct { Person # 匿名字段， 相当于继承了person的信息 school string class_num int } func main() { p1 := Person{"aa", 22} fmt.Println(p1) s1 := student{ Person{"aa", 12}, "school", 12} # 初始化 fmt.Println(s1) }
在Go语言中多继承也是可以的，就是用在需要继承的结构体中将继承的结构体添加进就完成了。例如我们定义两个基类表示信息和父母类，子类继承这两个类。
package main
import (
"fmt"
)
type Person struct {
name string
age int
}
type partent struct {
fater string
mother string
}
type SpeciStudent struct {
Person
partent
info string
}
func main() {
ss := SpeciStudent{Person{"bb", 35}, partent{"bb_father", "bb_mother"}, "bb is good student"}
fmt.Println(ss)}
既然是类，则自然有类方法，在Go语言中方法的定义为
func (变量 结构体名) 方法名() { # 定义方法
方法内容
}
package main
import (
"fmt"
)
type Person struct {
name string
age int
}
func (p Person) printInfo() {
fmt.Println(p.name, p.age)
}
func main() {
p1 := Person{"aa", 22}
p1.printInfo()
}
在面向对象中，子类可以继承父类的方法，父类不能使用子类特有的方法。在Go语言也同样遵守这个规则。
package main import ( "fmt" ) type Person struct { name string age int } func (p *Person) printInfo() { fmt.Println(p.name, p.age) } type student struct { Person school string class_num int } func(s student) printinfo(){ fmt.Println(s.name, s.age, s.class_num,s.school) } func main() { p1 := Person{"aa", 22} p1.printInfo() s1 := student{ Person{"aa", 12}, "school", 12} # 初始化子类 s1.printInfo() # 调用父类的方法 s1.printinfo() # 调用自己的方法 }
在面向对象编程中经常使用接口， 接口好比一种模版，这个模版定义了对象必须实现的方法，其目的就是让这些方法可以作为接口实例被引用。接口不能被实例化。类可以实现多个接口并且通过这些实现的接口被索引。接口变量只能索引实现该接口的类的实例。
/ * 接口定义
type 接口名 interface {
方法() 返回类型
}
注意： 接口不能实例化、类中只有实现了接口的全部方法才能赋值给接口变量(否则会报错)、
*/
package main import ( "fmt" ) type Personer interface { // 定义接口 printInfo() } type Person struct { name string age int } func (p *Person) printInfo() { fmt.Println(p.name, p.age) } func main() { var interp Personer p1 := Person{"aa", 22} interp = &p1 interp.printInfo() }
多态的实现，在面向对象中如果传入的类型不同，函数执行的结果也不同。这里我们可以利用接口来实现多态。
package main
import (
"fmt"
)
type Personer interface {
printInfo()
}
type Person struct {
name string
age int
}
func (p *Person) printInfo() {
fmt.Println(p.name, p.age)
}
type student struct {
Person
school string
class_num int
}
func(s student) printInfo(){
fmt.Println(s.name, s.age, s.class_num,s.school)
}
func printinfo(p Personer) { // 定义函数，其中参数为接口类型，意味着如果传入参数的不同，我们调用的方法也将不同
p.printInfo()
}
func main() {
p1 := Person{"aa", 22}
printinfo(&p1)
s1 := student{Person{"bb", 24}, "bb_school", 13 }
printinfo(&s1)
}
关于接口的继承，就像和对象的继承是一样的，通过匿名字段来紧凑型设置，注意的是父接口不能转换成子接口， 但是子接口可以转换成父接口
type Personer interface { printInfo() } type Personer2 interface { // 这时 person2中拥有person中的方法， Personer setInfo() }
最后还有一个空接口类型，空接口就是里面花括号里面什么都没有，在Go语言中空接口变量可以接收任意类型的数据，包括整数、浮点数、函数、字符串等等。另外可以看一一下fmt.Println()函数，你会看到参数就是一个接口类型。
package main import "fmt" func main() { type i interface {} // 空接口类型 var L1 i // 定义空接口变量 L1 = 10 // 赋值 fmt.Println(L1) L1 = 1.2 fmt.Println(L1) L1 = "aaaa" fmt.Println(L1) }