golang 方法和方法集
方法
概述: 在面向对象编程, 一个对象其实也就是一个简单的值或者一个变量, 在这个对象中会包含一些函数, 这种带有接收者的函数, 我们称为为方法(method)。
本质上, 一个方法则是一个和特殊类型关联的函数。
一个面向对象的程序会用方法来表达其属性和对应的操作, 这样使用这个对象的用户就不需要直接去操作对象, 而是借助方法来做这些事情。
在Go语言中, 可以给任意自定义类型(包括内置类型, 但不包括指针类型)添加相应的方法。
方法总是绑定对象实例, 并隐式将实例作为第一实参(receiver), 方法的语法如下:
func (receiver ReceiverType) funcName(paramters) (results)
参数receiver可任意命名。 如方法中未曾使用, 可省略参数名。 receiver: 接收者 [rɪˈsiːvə(r)]
参数receiver类型可以是 T 或 *T。 基类型 T 不能是接口或指针
不支持重载方法, 也就是说, 不能定义名字相同但是不同参数的方法。
注意:
每个方法只能有一个 receiver 参数, 不支持多 receiver 参数列表或变长 receiver 参数。
一个方法只能绑定一个基类型, Go 语言不支持同时绑定多个类型的方法。
receiver 参数的基类型本身不能是指针类型或接口类型。
如: 下面的 receiver参数是无效的
type MyInt *int
func (r MyInt) String() string { // invalid receiver type MyInt (MyInt is a pointer type)
return fmt.Sprintf("%d", *(*int)(r))
}
type MyReader io.Reader
func (r MyReader) Read(p []byte) (int, error) { // invalid receiver type MyReader (MyReader is an interface type)
return r.Read(p)
}
Go 方法具有如下特点：
方法名的首字母是否大写决定了该方法是否是导出方法 ；
方法定义要与类型定义放在同一个包内。
由于方法定义与类型定义必须放在同一个包下面, 因此我们可以推论得到：我们不能为原生类型(诸如：int、float64、map 等)添加方法, 只能为自定义类型定义方法。
错误的作法：
func (i int) String() string { // cannot define new methods on non-local type int
return fmt.Sprintf("%d", i)
}
正确的作法：
type MyInt int
func (i MyInt) String() string {
return fmt.Sprintf("%d", int(i))
}
常见的问题: cannot define new methods on non-local type int
原因: go语言不允许为简单的内置类型添加方法, 一般用于自定义结构体 struct, 其他数据类型不推荐使用;
为类型添加方法
基础类型作为接收者
package main //必须有个main包
import "fmt"
type MyInt int //自定义类型, 给int改名为MyInt, 定义方法必须使用自定义类型或者结构体
//在函数定义时, 在其名字之前放上一个变量, 即是一个方法
func (a MyInt) Add(b MyInt) MyInt { //面向对象
return a + b
}
//传统方法定义
func Add(a, b MyInt) MyInt {
return a + b
}
func main(){
var a MyInt = 1
var b MyInt = 1
//调用func (a MyInt) Add(b MyInt)
fmt.Println("a.Add(b) = ", a.Add(b)) //a.Add(b) == 2
//调用func Add(a, b MyInt)
fmt.Println("Add(a, b) = ", Add(a, b)) //Add(a, b) = 2
}
通过上面的例子可以看出, 面向对象只是换了一种语法形式来表达。方法是函数的语法糖, 因为receiver其实就是方法所接收的第1个参数。
注意: 虽然方法的名字一模一样, 但是如果接收者不一样, 那么方法就不一样。
package main //必须有个main包
import "fmt"
type MyInt int //自定义类型, 给int改名为MyInt, 定义方法必须使用自定义类型或者结构体
//在函数定义时, 在其名字之前放上一个变量, 即是一个方法
func (a MyInt) Add(b MyInt, c MyInt) MyInt { //面向对象 参数可以多出一个, 不会报bug
return a + b
}
//传统方法定义
func Add(a, b, c MyInt) MyInt { // 参数可以多出一个, 不会报bug
return a + b
}
func main() {
var a MyInt = 1
var b MyInt = 1
//调用func (a MyInt) Add(b MyInt)
fmt.Println("a.Add(b) = ", a.Add(b, 10)) //a.Add(b) == 2
//调用func Add(a, b MyInt)
fmt.Println("Add(a, b) = ", Add(a, b, 10)) //Add(a, b) = 2
}
注意: 函数和方法多出的参数没有使用, 不会报bug(如: 参数c);
结构体作为接收者
方法里面可以访问接收者的字段, 调用方法通过点(.)访问, 就像struct里面访问字段一样:
package main //必须有个main包
import "fmt"
type Person struct {
name string
sex byte
age int
}
func (p Person) PrintInfo(){
fmt.Println(p.name, p.sex, p.age)
}
func main(){
p := Person{"mike", 'm', 18} //初始化
p.PrintInfo() //调用func (p Person) PrintInfo()
}
输出结果:
mike 109 18
值语义和引用语义
package main //必须有个main包
import "fmt"
type Person struct {
name string
sex byte
age int
}
//指针作为接收者, 引用语义
func (p *Person) SetInfoPointer(){
//给成员赋值
(*p).name = "yoyo"
p.sex = 'f'
p.age = 22
}
//值作为接收者, 值语义
func (p Person) SetInfoValue(){
//给成员赋值
p.name = "yoyo"
p.sex = 'f'
p.age = 22
}
func main(){
//指针作为接收者, 引用语义
p1 := Person{"mike", 'm', 18} //初始化
fmt.Println("函数调用前 = ", p1) //函数调用前 = {mike 109 18}
p1.SetInfoPointer() // 这里没有使用指针不会改变接收者(receiver)是引用语义, p 会转换成 &p
fmt.Println("函数调用后 = ", p1) //函数调用后 = {yoyo 102 22}
(&p1).SetInfoPointer()
fmt.Println("函数调用后 = ", p1) //函数调用后 = {yoyo 102 22}
fmt.Println("==========")
//值类型作为接收者, 值语义
p2 := Person{"mike", 'm', 18} //初始化
fmt.Println("函数调用前 = ", p2) //函数调用前 = {mike 109 18}
p2.SetInfoValue()
fmt.Println("函数调用后 = ", p2) //函数调用后 = {mike 109 18} 值语义不会改变原有的值
(&p2).SetInfoValue() // 这里的 "&" 不会改变接收者(receiver)是值语义, &p 会转换成 p
fmt.Println("函数调用后 = ", p2) //函数调用后 = {mike 109 18} 值语义不会改变原有的值
}
由此可见: 决定值语义还是引用语义, 在于定义方法是否作为指针作为接收者;
接收者(receiver)究竟是指针(引用语义)还是值(值语义)类型, 是在定义时候决定, 而不是在使用的时候决定;
值语义和引用语义的区别:
Go 语言中的大多数类型都是值语义。值语义和引用的区别在于赋值之后, 重新赋值, 是否会改变原值。
如果不改变原值, 则是值语义。否则是引用语义, 引用语义比值语义拥有更复杂的存储结构。比如分配内存、指针、长度、容量等。
总结:
值接收者(值语义) vs 指针接收者(引用语义)
要改变内容必须使用指针接收者
结构过大也考虑使用指针接收者
一致性: 如有指针接收者, 最好都是指针接收者
值接收者是go语言特有
值/指针接收者均可接收值/指针
方法集
类型的方法集是指可以被该类型的值调用的所有方法的集合。
用实例 value 和 pointer 调用方法(含匿名字段)不受方法集约束, 编译器总是查找全部方法, 并自动转换 receiver 实参。
类型 *T 方法集
一个指向自定义类型的值的指针, 它的方法集由该类型定义的所有方法组成, 无论这些方法接受的是一个值还是一个指针。
如果在指针上调用一个接受值的方法, Go语言会聪明地将该指针解引用, 并将指针所指的底层值作为方法的接收者。
类型 *T 方法法集包含全部 receiver T + *T 方法：
package main //必须有个main包
import "fmt"
type Person struct {
name string
sex byte
age int
}
//指针作为接收者, 引用语义
func (p *Person) SetInfoPointer() {
(*p).name = "yoyo"
p.sex = 'f'
p.age = 22
fmt.Println("SetInfoPointer")
}
//值作为接收者, 值语义
func (p Person) SetInfoValue(){
p.name = "xxx"
p.sex = 'm'
p.age = 33
fmt.Println("SetInfoValue")
}
func main(){
//p为指针类型
var p *Person = &Person{"mike", 'm', 18} // 此时的"*"代表指针类型
p.SetInfoPointer() //SetInfoPointer 内部将p转化为*p, 再调用
(*p).SetInfoPointer() //SetInfoPointer 等同于 p.SetInfoPointer(), 但是效率高, 此时的"*"代表操作符, 因为 p 传递的是指针数据类型
p.SetInfoValue() //SetInfoValue 同于 (*p).SetInfoValue(), 但是效率高
(*p).SetInfoValue() //SetInfoValue 内部将*p转化为p, 再调用
}
类型 T 方法集
一个自定义类型值的方法集则由为该类型定义的接收者类型为值类型的方法组成, 但是不包含那些接收者类型为指针的方法。
但这种限制通常并不像这里所说的那样, 因为如果我们只有一个值, 仍然可以调用一个接收者为指针类型的方法, 这可以借助于Go语言传值的地址能力实现。
package main //必须有个main包
import "fmt"
type Person struct {
name string
sex byte
age int
}
//指针作为接收者, 引用语义
func (p *Person) SetInfoPointer() {
(*p).name = "yoyo" // * 代表操作符
p.sex = 'f'
p.age = 22
fmt.Println("SetInfoPointer")
}
//值作为接收者, 值语义
func (p Person) SetInfoValue(){
p.name = "xxx"
p.sex = 'm'
p.age = 33
fmt.Println("SetInfoValue")
}
func main(){
//p为普通类型
p := Person{"mike", 'm', 18}
(&p).SetInfoPointer() //SetInfoPointer //代表传址
(p).SetInfoPointer() //SetInfoPointer 内部先把p转化为&p后, 再调用
p.SetInfoValue() //SetInfoValue
(&p).SetInfoValue() //SetInfoValue 内部先把&p转化为p后, 再调用
//(*p).SetInfoPointer() //err, invalid indirect of s (type Person)
//(*s).SetInfoValue() //err, invalid indirect of s (type Person)
fmt.Println(p.name, p.age, p.sex) //yoyo 22 102
}
匿名字段
方法的继承
如果匿名字段实现了一个方法, 那么包含这个匿名字段的struct也能调用这个方法
package main //必须有个main包
import "fmt"
type Person struct {
name string
sex byte
age int
}
//Person定义了方法
func (p *Person) PrintInfo() {
fmt.Printf("%s, %c, %d\n", p.name, p.sex, p.age)
}
type Student struct {
Person //匿名字段, 那么 Student 包含了 Person 的所有字段
id int
addr string
}
func main(){
p := Person{"mike", 'm', 18}
p.PrintInfo() //mike, m, 18
s := Student{Person{"yoyo", 'f', 20}, 2, "sz"}
s.PrintInfo() //yoyo, f, 20
}
方法的重写
package main //必须有个main包
import "fmt"
type Person struct {
name string
sex byte
age int
}
//Person定义了方法
func (p *Person) PrintInfo() {
fmt.Printf("Person: %s, %c, %d\n", p.name, p.sex, p.age)
}
type Student struct {
Person //匿名字段, 那么 Student 包含了 Person 的所有字段\
id int
addr string
}
func (s *Student) PrintInfo() {
fmt.Printf("Student: %s, %c, %d\n", s.name, s.sex, s.age)
}
func main(){
p := Person{"mike", 'm', 18}
p.PrintInfo() //Person: mike, m, 18
s := Student{Person{"yoyo", 'f', 20}, 2, "sz"}
s.PrintInfo() //Student: yoyo, f, 20
s.Person.PrintInfo() //Person: yoyo, f, 20
}
表达式
类似于我们可以对函数进行赋值和传递一样, 方法也可以进行赋值和传递。
根据调用者不同, 方法分为两种表现形式, 方法值和方法表达式。 两者都可像普通函数那样赋值和传参, 区别在于方法值绑定实例, 而方法表达式则须显式传参。
方法值
package main //必须有个main包
import "fmt"
type Person struct {
name string
sex byte
age int
}
//Person定义了方法
func (p *Person) PrintInfoPointer() {
fmt.Printf("%p, %v\n", p, p)
}
func (p Person) PrintInfoValue() {
fmt.Printf("%p, %v\n", &p, p)
}
func main(){
p := Person{"mike", 'm', 18}
p.PrintInfoPointer() //0xc0000640c0, &{mike 109 18}
pFunc1 := p.PrintInfoPointer //方法值, 隐式传递receiver
pFunc1() //0xc0000640c0, &{mike 109 18}
pFunc2 := p.PrintInfoValue
pFunc2() //0xc000064140, {mike 109 18}
}
方法表达式
package main //必须有个main包
import "fmt"
type Person struct {
name string
sex byte
age int
}
//Person定义了方法
func (p *Person) PrintInfoPointer() {
fmt.Printf("%p, %v\n", p, p)
}
func (p Person) PrintInfoValue() {
fmt.Printf("%p, %v\n", &p, p)
}
func main(){
p := Person{"mike", 'm', 18}
p.PrintInfoPointer() //0xc0000640c0, &{mike 109 18}
//方法表达式, 须显式传参
pFunc1 := (*Person).PrintInfoPointer
pFunc1(&p) //0xc000004460, &{mike 109 18}
pFunc2 := Person.PrintInfoValue
pFunc2(p) //0xc0000044e0, {mike 109 18}
}
总结:
结构体的方法集和非结构体的方法集区别
结构体的方法集
package main
import (
"fmt"
)
type T struct {
int
}
func (t T) test() {
fmt.Println("类型 T 方法集包含全部 receiver T 方法。")
}
func main() {
t1 := T{1}
fmt.Printf("t1 is : %v\n", t1)
t1.test()
}
非结构体的方法集
package main
import (
"fmt"
)
type T int
func (t T) test() {
fmt.Println("类型 T 方法集包含全部 receiver T 方法。")
}
func main() {
var t1 T
t1 = 10
fmt.Printf("t1 is : %v\n", t1)
t1.test()
}
隐式传递和显示传递区别
package main
import "fmt"
type User struct {
id int
name string
}
func (self *User) Test() {
fmt.Printf("%p, %v\n", self, self)
}
func main() {
u := User{1, "Tom"}
u.Test()
mValue := u.Test
mValue() // 隐式传递 receiver
mExpression := (*User).Test
mExpression(&u) // 显式传递 receiver
}
立即复制 receiver, 因为不是指针类型, 不受后续修改影响。
package main
import "fmt"
type User struct {
id int
name string
}
func (self User) Test() {
fmt.Println(self)
}
func main() {
u := User{1, "Tom"}
mValue := u.Test // 立即复制 receiver，因为不是指针类型，不受后续修改影响。
u.id, u.name = 2, "Jack"
u.Test()
mValue()
}
Go 方法的本质：一个以方法所绑定类型实例为第一个参数的普通函数;
Go 语法甜头使得我们通过类型实例调用类型方法时无需考虑实例类型与 receiver 参数类型是否一致, 编译器会为我们做自动转换；
receiver 参数类型选择时要看是否要对类型实例进行修改; 如有修改需求, 则选择*T; 如无修改需求, T 类型 receiver 传值的性能损耗也是考量因素之一。
[注：本文部分图片来自互联网！未经授权，不得转载！每天跟着我们读更多的书]
互推传媒文章转载自第三方或本站原创生产，如需转载，请联系版权方授权，如有内容如侵犯了你的权益，请联系我们进行删除！
如若转载，请注明出处：http://www.hfwlcm.com/info/251325.html
相关文章
-
我们小时候，几乎没有“性启蒙”的教育，但随着时代的发展，这些我们总是羞于启齿的教育话题，越来越成为孩子教育的必要内容。那，如何开启“性启蒙”教育呢？如有侵权 联系删
-
学龄前儿童的启蒙教育至关重要，如果能多方面进行启蒙，不管孩子当时能不能理解，将来对孩子的学习兴趣都有深远的影响，甚至对一生都有积极的影响。学龄前儿童的启蒙主要有语
-
随着社会的发展，现在很多没有任何英文基础的成人学员在逐渐增多，尤其是一些全职父母希望今后能出国陪伴孩子来读书，这样的成人学员完全没有任何的英语基础，但是他们学习英
-
随着我国经济的高速发展，国际化程度也越来越高，而作为世界通用性语言的英语就变得越来越重要了。特别是像我们这些进入了职场的成人，深切体会到英语好能在职场上带来很多的
-
最近很多问office培训经常会问这么一个问题：怎么提高办公效率？今天就给大家讲一下提高办公效率需要学习什么？培训内容:1、计算机基础：12次课程主要讲解电脑的基础知识，包括电
-
对于英语不好的成人来说，如因为某种原因需要学好英语甚至精通英语，那一定要找到高质量学习英语的办法。在讲高质量学习英语的办法之前，我需要提醒各位成人：忘掉自己的成人
-
学习这些精益求精的操作方法，工作效率绝对腾飞在Excel中，除了使用进行一些企业高层函数外，熟练使用一些实际操作方式方法研究可以大大提高学生工作学习效率。今天总结了一些问
-
成人应该怎么学英语最快?无论做什么事不能一蹴而就，要懂得循序渐进，心急吃不了热豆腐。成年人在学习英语也是一样的，那么有没有什么学习英语的方法是比较快速的呢?以下是大连