Go----方法和函数的区别

一、区别

• Go语⾔，同时有函数和⽅法，⽅法的本质是函数，但是⽅法和函数⼜具有不同点。

二、不同点

含义不同

• 1.1）函数function是⼀段具有独⽴功能的代码，可以被反复多次调⽤，从⽽实现代码复⽤。⽽⽅法method是⼀个类的⾏为功能，只有该类的对象才能调⽤。

⽅法有接受者，⽽函数⽆接受者

• 2.1）Go语⾔的⽅法method是⼀种作⽤于特定类型变量的函数，这种特定类型变量叫做Receiver（接受者、接收者、接收器）；
• 2.2）接受者的概念类似于传统⾯向对象语⾔中的this或self关键字；
• 2.3）Go语⾔的接受者强调了⽅法具有作⽤对象，⽽函数没有作⽤对象；
• 2.4）⼀个⽅法就是⼀个包含了接受者的函数；
• 2.5）Go语⾔中， 接受者的类型可以是任何类型，不仅仅是结构体， 也可以是struct类型外的其他任何类型。

函数不可以重名，⽽⽅法可以重名

• 3.1）只要接受者不同，则⽅法名可以⼀样。

调用方式不一样

• 4.1) 方法是struct对象通过.点号+名称来调用，而函数是直接使用名称来调用。

2.1、方法

• 示例: 给结构体添加一个方法

package main
import "fmt"
// 1.定义一个结构体
type Person struct {
	name string
	age int
}
// 2.定义一个方法, 并将这个方法和Person结构体绑定在一起
func (p Person)say() {
	fmt.Println("my name is", p.name, "my age is", p.age)
}
func main() {
	// 3.创建一个结构体变量
	per := Person{"lnj", 33}
	// 4.利用结构体变量调用和结构体绑定的方法
	// 调用时会自动将调用者(per)传递给方法的接收者(p)
	// 所以可以在方法内部通过p方法结构体变量的属性
	per.say()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2.1、方法的数据类型也是函数类型, 所以也可以定义变量保存(作为参数返回值等)

package main

import "fmt"

type people struct {
	name string
	age  int
}

// 定义一个方法
func (p people) say() {
	fmt.Println("this is person's say method")
}

// 定义一个函数
func say() {
	fmt.Println("this is general fun")
}
func main() {
	p := people{name: "老王"}
	fmt.Printf("%T\n", p.say) // func()
	fmt.Printf("%T\n", say)   // func()

	//定义一个没有保存形参没有返回值的函数变量类型
	var fn func()

	//利用函数类型变量保存一个方法
	fn = p.say
	// 利用函数类型调用一个方法
	fn() // this is person's say method

	//利用函数类型变量保存一个函数
	fn = say
	//利用函数类型调用一个函数
	fn()  // this is general fun   
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

2.2、方法只能通过绑定类型的变量调用, 函数可以直接调用

package main

import "fmt"

type People struct {
	name string
	age  int
}

//定义一个方法
func (p People) sayOne() {
	fmt.Println("my name is", p.name, "my age is", p.age)
}

//定义一个函数
func test() {
	fmt.Println("This is test'fun")
}
func main() {
	p := People{"老王", 19}
	p.sayOne() // 方法只能通过绑定的类型调用
	// sayOne() 编译报错，不能直接调用
	test() // 编译通过，可以直接调用

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2.3、方法的接收者可以看做就是函数的一个形参

• 既然可以看做形参，那么自然也具备形参的特点(值传递和地址传递)

// 接收者是一个指针
func (o *personFridayOne) setAge(age int) {
	o.age = age
}
func main() {
	per := personFridayOne{"老王头", 20}
	fmt.Println(per) // {老王头 20}

	//值传递方法内部修改不会影响方法外部
	per.setName("老张")
	fmt.Println(per) //{老王头 20}

	p := &per
	// 地址传递, 方法内部修改会影响方法外部
	(*p).setAge(30)
	fmt.Println(per) //{老王头 30}

	per.setAge(40)
	fmt.Println(per) // {老王头 40}


}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23