Go语言的面向对象

Go语言的面向对象

1 基本介绍

（1）Go语言中没有类概念

Go语言没有类，结构体提供了绑定数据和方法的行为，可借助结构体解决面向对象的多态的问题。

（2）Go语言中函数和方法是不同的概念

个人理解，函数是具有独立功能的代码块，方法是对象行为的代码块，方法的本质是函数。在Go语言中两者最明显的区别是方法有接受者，函数无接收者。

（3） Go语言中空接口

Go语言接口是一组方法签名。空接口是指没有定义任何方法的接口，任何类型的数据都可以实现空接口，且它的内部实现了保存对象的类型和指针，因此它能够灵活保存抽象数据。Go语言中空接口很常用。

（4）duck typing

Go属于duck typing类型语言，即”动态类型语言“或者”解释型语言“，类似于python、Javascript、Ruby语言。

2 对象方法

obj_method.go

package main

import (
	"fmt"
)

// 定义结构体
type Person struct {
	name, sex string
}

/*
// 方法定义，官方建议使用“接收者类型”的首字母的小写作为“接收者变量”的名字
// 如果返回值参数列表没有返回值，或者只有一个返回值，可以不要括号“()”
func (接收者变量, 接收者类型) 方法名称(输入参数列表) (返回值参数列表){
}

// 函数定义
func 方法名称(输入参数列表) (返回值参数列表){
}
*/

// 方法
func (p Person) eating(food string) string {
	fmt.Println("方法内：", p.name+" is eating "+food)
	return "Beautiful " + food
}

// 主入口
func main() {
	person := Person{"Mason", "male"}
	msg := person.eating("Apple")
	fmt.Println("返回值：", msg)
}

执行obj_method.go

# go run obj_method.go
方法内： Mason is eating Apple
返回值： Beautiful Apple

3 对象继承

obj_inherit.go

package main

import "fmt"

type Person struct {
	name string
	sex  string
}

// 方法
func (p Person) eating(food string) string {
	fmt.Println("方法内：", p.name+" is eating "+food)
	return "Beautiful " + food
}

// 方法继承，使用定义了方法的匿名字段即可实现继承
type Teacher struct {
	// 继承Person，Person没有属性名称是匿名字段
	Person
	// 老师教的科目
	subject string
}

// 方法继承
type Student struct {
	// 继承Person
	Person
	// 学生作业
	work string
}

func main() {

	// 实现类
	teacher := Teacher{Person{"Teacher", "male"}, "Chinese"}
	student := Student{Person{"Student", "male"}, "Learn Chinese"}

	// 调用方法
	teacher.eating("Apple")
	student.eating("Banana")

}

执行obj_inherit.go

# go run obj_inherit.go  
方法内： Teacher is eating Apple
方法内： Student is eating Banana

4 对象多态(接口)

obj_interface.go

package main

import "fmt"

// 接口是一组方法的集合
/*
// 接口定义，如果返回值参数列表没有返回值，或者只有一个返回值，可以不要括号“()”
type 接口名称  interface {
	方法1(输入参数列表1) (返回值参数列表1)
    方法2(输入参数列表2) (返回值参数列表2)
	……
	方法N(输入参数列表N) (返回值参数列表N)
}

// 接口实现，如果返回值参数列表没有返回值，或者只有一个返回值，可以不要括号“()”
func (接收者变量, 接收者类型) 方法1(输入参数列表1) (返回值参数列表1){

}
func (接收者变量, 接收者类型) 方法2(输入参数列表2) (返回值参数列表2){

}
……
func (接收者变量, 接收者类型) 方法N(输入参数列表N) (返回值参数列表N){

}

*/

// 定义接口
type Person interface {
	eating(food string) string
}

// 定义结构体
type Teacher struct {
	name string
}

type Student struct {
	name string
}

// 使用Teacher结构体实现方法
func (t Teacher) eating(food string) string {
	fmt.Println("The " + t.name + " eating " + food)
	return "Good teacher"
}

// 使用Student结构体实现方法
func (s Student) eating(food string) string {
	fmt.Println("The " + s.name + " eating " + food)
	return "Good student"
}

func main() {

	var person Person

	teacher := Teacher{"Teacher"}
	student := Student{"Student"}

	// 实现多态
	person = teacher
	person.eating("Apple")

	person = student
	person.eating("Banana")

}

执行obj_interface.go

# go run obj_interface.go
The Teacher eating Apple
The Student eating Banana