方法method

package main

/*
方法method

Go 中虽没有class，但依旧有method
通过显示说明receiver来实现与某个类型的组合
只能为同一个包中的类型定义方法
Receiver 可以是类型的值或者指针
不存在方法重载
可以使用值或指针来调用方法，编译器会自动完成转换
从某种意义上来说，方法是函数的语法糖，因为receiver其实就是
方法所接收的第1个参数（Method Value vs. Method Expression）
如果外部结构和嵌入结构存在同名方法，则优先调用外部结构的方法
类型别名不会拥有底层类型所附带的方法
方法可以调用结构中的非公开字段

*/

//go语言没有方法的重载概念，
import (
    "fmt"
)

type A struct {
    name string
}

type B struct {
    name string //小写是私有字段，方法Print1也可以访问，小写对于整个package是公有的，包外面不能访问，
}

func main() {
    a := A{}
    a.Print(1)          //"A"
    a.Print1()          //"A1"
    fmt.Println(a.name) //a1，也可以访问结构体的私有字段，

    b := B{}
    b.Print(1)          //"B"
    b.Print1()          //"B1"
    fmt.Println(b.name) //""

    var c TZ
    c.print() //"TZ",这样就可以为基本类型int绑定方法了，这就是为什么type不仅仅是别名，
    //因此TZ类型转换成int类型要强制转换，因为无法为int类型绑定方法（即使在int包中绑定了方法，
    //其余包也是在不到这个方法的），但是通过type定义别名后就可以为基本类型绑定方法了，
    fmt.Println(c)  //10000
    (*TZ).print(&c) //"TZ",也调用了print方法，两者都可以，
}

func (a A) Print(c int) { //a A就是reciver接收者，Print方法就是结构体A的方法，
    fmt.Println("A")
}
func (a *A) Print1() { //把a结构体的指针闯进来，可以修改a里面的值，
    //传递的是地址（结构体传递参数是值传递不是引用传递，但是这里强制传递的是地址）
    a.name = "a1"
    fmt.Println("A1")
}

func (b B) Print(c int) { //b B就是reciver接收者，Print方法就是结构体B的方法，
    fmt.Println("B")
}

func (b B) Print1() { //没有传递指针，不能修改b结构体里面的值，
    b.name = "b1"
    fmt.Println("B1")
}

//可以为内置的基本类型绑定方法
type TZ int //别名

func (a *TZ) print() {
    *a = 10000
    fmt.Println("TZ")
}

package main

/*
 */

import (
    "fmt"
)

type TZ int

func (tz *TZ) add(num int) {
    *tz += TZ(num) //int类型要强制转换成TZ类型
}

func main() {
    var a TZ
    a.add(100)
    fmt.Println(a) //100
}