golang-gopher.png
1. 概述
Go 语言中 的方法 （ Method ） 是一种作用 于特定类型变量 的函数 。这种特定类型变量
叫做接收器（ Receiver ） 。
如果将特定类型理解为结构体或“类”时，接收器的概念就类似于其他语言中的 this 或 者 self。
在 Go 语言中，接收器的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。
- 简单的说，我们可以给任何类型（包含内置类型）添加方法
- 方法必须和特定的数据类型绑定才能使用，也就是说方法一定会有一个自己的接收器，接收器就是指定的数据类型，或者也可以称为一个
实例- 方法和函数的区别是，函数没有作用对象,即不需要和特定的数据类型变量绑定.
2. 方法的声明和调用
接收器变量 : ** 可以是任意的正确的变量名,可以命名为
this,self这样的命名,但是通常不建议这样做**,推荐的做法是接收器类型首字母的小写**接收类型 : ** 接收器类型可以是指针类型也可以是非指针类型,可以是结构体,也可以是其他类型
方法名,参数列表,返回值列表和函数一致
(接收器变量 接收器类型) 总称为 接收器
Receiver根据接收器类型 可以分为 指针接收器和非指针接收器 两种接收器会在具体执行中会有不同的效果,这种不同的效果最基本的体现是值传递的影响和引用传递的影响
func (接收器变量 接收器类型) MethodName(参数列表) (返回值列表){
}
任何类型都可以有方法
我们以Go语言内置类型
int为例
package main
import "fmt"
// 定义一个新类型numA 但是其本质是int类型
type numA int
// 给numA类型绑定了一个方法 getDouble
func (a numA) getDouble(n int) (res1 int,res2 numA){
// 但是在内部编译的时候依然认为 numA类型和int类型不匹配,需要转换
// numA类型转换成int类型
res1 = int(a)*n
// int类型转换成numA类型
res2 = a*numA(n)
return
}
// 给numA类型绑定了一个方法 compare
func (a numA) compare(n numA) numA{
if a > n {
return a
}else{
return n
}
}
func main() {
var AA numA = 9
// numA的类型变量调用绑定的方法
res,res1:= AA.getDouble(2)
fmt.Println(res,res1)
res2 := AA.compare(99)
fmt.Println(res2)
}
go run main.go
18 18
99
方法更多的时候是和结构体一起,构成面向对象编程
package main
import "fmt"
type Person struct {
name string
birth string
hobby []string
}
func NewPerson(name string,birth string ,hobby []string) *Person{
return &Person{
name:name,
birth:birth,
hobby:hobby,
}
}
// Person类型绑定的方法
func (p Person) SelfIntroduction(){
hobbys := ""
for _,h := range p.hobby{
hobbys = hobbys+h+" "
}
fmt.Printf("大家好我叫 %s 我出生于 %s 我的爱好是 %s\n",p.name,p.birth,hobbys)
}
// Person类型绑定的方法不同的是接收器是指针类型的Person类型,引用传递
// 此处的是指针接收器,对原值有影响
func (p *Person) addHobby(h string){
p.hobby = append(p.hobby,h)
}
func main() {
// 初始化一个person类型的实例 p1
p1 := NewPerson("Tom","1990.1.1",[]string{"足球"})
// 调用方法
p1.SelfIntroduction()
p1.addHobby("篮球")
p1.SelfIntroduction()
// 初始化一个结构体变量 p2 (换一种说法)
// p1 和 p2 在内存中有相同的布局,但是本质上是两个内存空间,毫不相关
p2 := NewPerson("Anne","1992.1.1",[]string{"看书","购物"})
p2.SelfIntroduction()
}
go run main.go
大家好我叫 Tom 我出生于 1990.1.1 我的爱好是 足球
大家好我叫 Tom 我出生于 1990.1.1 我的爱好是 足球 篮球
大家好我叫 Anne 我出生于 1992.1.1 我的爱好是 看书 购物
3. 指针接收器与非指针接收器
由于指针的特性,修改指针接收器的任意成员,在方法调用结束之后,会对原有的数据产生效果
而非指针接收器是值拷贝一份,方法内修改接收器的成员,在方法结束之后不影响原有值
- 数据量小的对象赋值比较快,使用非指针接收器也合适,数据量大的对象赋值起来性能较低,使用指针接收器比较合适,
package main
import (
"fmt"
)
type Point struct {
x int
y int
}
// 指针接收器
func (p *Point) forwardTo(x1, y1 int) {
p.x += x1
p.y += y1
}
// 非指针接收器
func (p Point) retreatTo(x2, y2 int) {
p.x -= x2
p.y -= y2
}
func main() {
// 定义一个Point类型的结构体变量 我们可以看成一个实例化的一个`对象`
var p1 Point = Point{
0,
0,
}
fmt.Printf("P1的初始x = %d, y = %d\n", p1.x, p1.y)
p1.forwardTo(9, 6)
fmt.Printf("P1前进之后的x = %d, y = %d\n", p1.x, p1.y)
// 执行后对原没影响
p1.retreatTo(2,2)
fmt.Printf("P1后退之后的x = %d, y = %d\n", p1.x, p1.y)
}
P1的初始x = 0, y = 0
P1前进之后的x = 9, y = 6
P1后退之后的x = 9, y = 6
4. 比较面向对象和面向过程
"Go语言中没有隐藏的this指针"
- 方法作用的目标是显示传递的
- 方法作用的目标不一定是指针
接收器就是方法作用的目标
package main
type integer int
func (i integer) compareWithNum(x int) bool {
if i > integer(x) {
return true
} else {
return false
}
}
func compare(x ,y integer) bool{
if x>y {
return true
}else{
return false
}
}
func main() {
var num integer = 9
// 面向对象的用法
// 显性调用方法
num.compareWithNum(10)
// 面向过程的用法
compare(num,88)
}
网友评论