func (receiver receiverType) funcName(parameters) (results)
// 1. receiver 为任意名字。
// 2. receiverType为调用者的类型。可以是T或者*T。注意T本身不能是接口或者指针。
例如T=int，但是不能是*int。想要指针可以这样做：T=int后，单独加一个*。
// 代码解释：
// 1. 正确写法
type myint int
func (s *myint) Add() (r int)
// 2. 错误写法。因为T类型本身不能是指针。
type myintp *int
func (s myintp) Add() (r int)
非常简单，就是将函数封装到了一个对象里面，然后通过变量名 + 点的形式进行调用。利用下面的例子。
package main
import "fmt"
// go本身没有long类型
type long int
func Add01(a, b long)long{
return a + b
}
func (t long)Add02(b long)long{
return t + b
}
func main(){
// 1. 面向过程
fmt.Println("Add01 = ", Add01(1, 2))
// 2. 面向对象
var s1 long = 1
fmt.Println("Add02 = ", s1.Add02(5))
}
package main
import "fmt"
type Persion struct {
name string
sex byte
age int
}
// 带有接受者的函数叫方法
func (t Persion) PrintInfo(){
fmt.Println("PrintInfo = ", t)
}
func (t *Persion) SetInfo(n string, s byte, a int){
t.name = n
t.sex = s
t.age = a
}
func main(){
// 1. 普通变量作为隐含实例传参
p := Persion{"hc", 'w', 24}
p.PrintInfo()
// 2. 指针变量作为隐含实例传参
(&p).SetInfo("lqq", 'w', 24)
p.PrintInfo()
}
// 1. 正确的写法
type long int
func (t long)test(){
}
// 2. 错误的写法
// err:Invalid receiver type 'pointer' ('pointer' is a pointer type)
type pointer *int
func (t pointer)test(){
}
type long int
func (t long)test(){
}
type long int
func (t long)test(a int){
}
而下面这样写不会报错，因为接收者类型不一样。可以用C++定义了两个类，类中有同样的成员函数名去理解。
type long int
func (t long)test(){
}
type char byte
func (c char) test(a int){
}
方法集实际上是使用指针可以如何调用方法，以及普通变量如何调用方法而已。变量在调用自己的方法集时，不受变量自己是指针还是普通变量的约束，都可以使用 “变量名 + 点(.) + 方法名” 的形式调用。
例如：
package main
import "fmt"
type Persion struct {
name string
sex byte
age int
}
// 带有接受者的函数叫方法
func (t Persion) SetInfoValue(){
fmt.Println("SetInfoValue")
}
func (t *Persion) SetInfoPointer(){
fmt.Println("SetInfoPointer")
}
func main(){
// 1. 结构体变量是一个指针时，它能调用哪些方法，就是一个方法集
// 指针调用方法的方式
p := &Persion{"hc", 'w', 24}
p.SetInfoPointer()
p.SetInfoValue() // 它内部会自动转换，将指针p转成 (*p).SetInfoValue()，所以下面的调用方式也是可以的，所以调用方法时不需要考虑是指针还是变量
(*p).SetInfoValue()
fmt.Println("===========")
// 2. 普通变量调用方法的方式
p2 := Persion{"lqq", 'w', 24}
p2.SetInfoValue()
p2.SetInfoPointer() // 内部转成(&p2).SetInfoPointer()，所以下面的调用方式也是可以的
(&p2).SetInfoPointer()
}
package main
import "fmt"
type Persion struct {
name string
sex byte
age int
}
// Persion实现了一个方法
func (t *Persion) PrintInfo(){
fmt.Printf("name=%s, byte=%c, age=%d\n", t.name, t.sex, t.age)
}
// 另一个结构体继承了该Persion，它会继承了所有成员及其方法
type Student struct {
Persion // 匿名字段
id int
addr string
}
func main(){
s := Student{Persion{"hc", 'w', 24}, 1, "sz"}
s.PrintInfo()
}
go中方法的重写，实际上就是C++的多态(通过虚基类指针、virtual关键字实现)。
下面的go实现多态的例子。
package main
import "fmt"
type Persion struct {
name string
sex byte
age int
}
// Persion实现了一个方法
func (t *Persion) PrintInfo(){
fmt.Printf("name=%s, byte=%c, age=%d\n", t.name, t.sex, t.age)
}
// 另一个结构体继承了该Persion，它会继承了所有成员及其方法
type Student struct {
Persion // 匿名字段
id int
addr string
}
// Student也添加一个同名的方法PrintInfo
// 注意，因为接收者类型一个是 *Persion、一个是 *Student，它们是不一样的，所以函数名可以同样。
// 这样也叫方法的重写，即实现了多态。
func (t *Student) PrintInfo(){
fmt.Println("stu = ", t)
}
func main(){
s := Student{Persion{"hc", 'w', 24}, 1, "sz"}
// 根据就近原则，调用的是Student.PrintInfo()
s.PrintInfo()
// 显示调用才能调用到Persion的PrintInfo()
s.Persion.PrintInfo()
}
代码例子：
package main
import "fmt"
type Persion struct {
name string
sex byte
age int
}
// 带有接受者的函数叫方法
func (t Persion) SetInfoValue(){
fmt.Println("SetInfoValue")
}
func (t *Persion) SetInfoPointer(){
fmt.Println("SetInfoPointer")
}
func main(){
// 1. 方法值调用
p := &Persion{"hc", 'w', 24}
pFunc := p.SetInfoPointer // 会隐式保存接收者
pFunc()
vFunc := p.SetInfoValue
vFunc()
fmt.Println("==============")
// 2. 方法表达式调用
p2 := Persion{"lqq", 'w', 24}
f := (*Persion).SetInfoPointer // 不会隐式保存接收者，所以调用时需要传对应的实例给接收者。(*Persion)表示传实例时是一个地址而不是普通变量。
f(&p2) // 需要传实例给接收者类型。
f2 := (Persion).SetInfoValue // Persion表示传实例时是一个普通变量而不是地址。
f2(p2) // 需要传实例给接收者类型。
}
