Go语言入门-方法

Go语言入门-方法

概念

A method is a function with a receiver. A method declaration binds an identifier, the method name, to a method, and associates the method with the receiver’s base type.

方法是一种特殊的函数，绑定一个receiver。 与接收者的基本类型关联。
基本语法

--官方描述
MethodDecl = "func" Receiver MethodName Signature [ FunctionBody ] .
Receiver   = Parameters .
--通俗描述
func([Receiver] ReceiverType) methodName(ParamsList...)(ReturnList...) {
   
	FunctionBody 
	...
}

其中与函数定义的区别是在名字前面增加了(Receiver] Type)用来标识该方法的接受者的类型。并且 Reciver当在方法中不使用的时候可以不写

• 示例1

type yourInt int
//定义一个方法，接收者的类型为yourInt，使用reciver来表示被绑定的yourInt类型的变量。
func (receiver yourInt) print() {
   
    println(receiver)
}
//定义一个方法，接收者的类型为yourInt，也就是只有yourInt类型才可以使用改方法，但是该方法中未使用receiver因此可以省略
func (yourInt) print2() {
   
    println("hello ")
}
func main() {
   
    your := yourInt(10)
    your.print()
    your.print2()
}
/**
output:
10
hello
*/

其中：
1. Receiver-接受者的变量，关联被绑定的实例的标识符，不推荐使用this、self等，一般使用类型的首字母小写。当方法内部不引用被绑定的实例，则可以省略接收者变量的标识符。
2. ReceiverType-接收者类型，关联一个base类型T，而具体的类型可以是T或者T（此处T可以理解go中的引用）。T也不能是接口或指针类型。
3. 方法名-同函数
4. 参数列表-同函数
5. 返回值列表-同函数

使用

基本的使用（T）

示例2-一个点的类型point的基本使用

//定义一个点的类型point
type point struct {
   
    x, y int
}

//打印绑定变量本身
func (p point) printSelf() {
   
    fmt.Printf("[%p]->[%d, %d]\n", &p, p.x, p.y)
}

//打印传入的变量类型
func (point) print(p point) {
   
    fmt.Printf("[%p]->[%d, %d]\n", &p, p.x, p.y)
}
//打印坐标X
func (p point) printX() {
   
    fmt.Printf("[%p]->[%d, -]\n", &p, p.x)
}

//打印坐标Y
func (p point) printY() {
   
    fmt.Printf("[%p]->[-, %d]\n", &p, p.x)
}
//获取坐标X的值
func (p point) GetX() int {
   
    return p.x
}

//获取坐标Y的值
func (p point) GetY() int {
   
    return p.y
}

//坐标相加
func (p point) add(p2 point) {
   
    p.x += p2.x
    p.y += p2.y
}
//坐标相减
func (p point) sub(p2 point) {
   
    p.x -= p2.x
    p.y -= p2.y
}

func main() {
   
    sour := point{
   
        x: 1,
        y: 2,
    }
    other := point{
   
        x: 4,
        y: 3,
    }
    //打印自身
    sour.printSelf()
    //打印入参
    sour.print(other)
    //other变量自己打印
    other.printSelf()
    //打印X坐标
    sour.printX()
    //获取Y坐标值
    fmt.Println(sour.GetY())
    //两坐标相加
    sour.add(other)
    //打印相加的结果
    sour.printSelf()
    //两坐标相减
    sour.sub(other)
    //打印相减结果
    sour.printSelf()
}
/**
output:
[0xc00000a0f0]->[1, 2]
[0xc00000a130]->[4, 3]
[0xc00000a150]->[4, 3]
[0xc00000a170]->[1, -]
2
[0xc00000a190]->[1, 2]
[0xc00000a1b0]->[1, 2]
 */

以上示例中奇怪的是即使对 sour进行加减操作，但是sour的值始终不发生变化。以及每次打印的过程中地址都不一致。--------------------是什么原因呢？

1. 方法的接收者的base Type为T，接收者类型是T则表示结构体变量做绑定的接收者是值传递，值传递不会修改接收者的内容，修改的是接收者的copy的变量。
2. 方法的接收者的base Type为T，接收者类型是(*T) 表示使用的是绑定变量的地址，传递地址的时候也只值传递，但是地址所关联的内存确是接收者变量的内存，因此可以修改接收者的值。

以上用法为 值接收者用法。

指针接收者（*T）

• 示例3 - 指针接收者

//定义一个点的类型point
type point struct {
   
    x, y int
}

//打印绑定变量本身
func (p *point) printSelf() {
   
    fmt.Printf("[%p]->[%d, %d]\n", p, p.x, p.y)
}

//打印传入的变量类型
func (*point) print(p *point) {
   
    fmt.Printf("[%p]->[%d, %d]\n", p, p.x, p.y)
}
//打印坐标X
func (p *point) printX() {
   
    fmt.Printf("[%p]->[%d, -]\n", p, p.x)
}

//打印坐标Y
func (p *point) printY() {
   
    fmt.Printf("[%p]->[-, %d]\n", p, p.