第十五章:Go语言方法

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)
}