golang基础--method方法

Go没有类似python语言中类class的概念，但依旧有method

• 类型方法定义格式如下
  func (a mytype) method_name(x type)(y type){ return y }
• 调用方式：
  instance.method(args) -> (type).func(instance, args)

通过显示的说明Receiver(强制函数传递的第一个参数)来实现与某个类型(struct,int...)的组合

package main
import "fmt"

type A struct{
    Name Sting
}

func main() {
    a := A{}                                        //实例化结构体
    a.Method_Print()                                //结构体调用方法
}

func (a A) Method_Print() {                         //强制将A(struct类型)作为第一个参数传递给Method_Print，从而说明此函数属于结构A的一个方法
    fmt.Println("This is a method for struct A")
}

/*输出
This is a method for struct A
*/

只能为同一个包package中的类型定义方法(method),不能为非本package中的类型定义方法，但是方法（这里指公有方法）是可以在其它包中调用。

可以只用值或指针来调用方法，编译器会自动完成转换

package main
import "fmt"

type A struct {
    Name string
}

type B struct {
    Name string
}

func main() {
    a := A{}                //实例化结构体
    a.Method_Print()        //结构体调用方法
    fmt.Println(a.Name)     //指针传递时，不用使用`*a.Name`,解释器自动识别

    b := B{}
    fmt.Println(b.Name)
    b.Method_Print()
}

func (a *A) Method_Print() {                        //方法传递结构体指针
    a.Name = "maozi"
    fmt.Println("This is a method for struct A")
}

func (b B) Method_Print() {                         //方法:传递结构
    b.Name = "Sazi"                                 //这种方式只能进行值的拷贝，无法进行更改结构体属性(字段)
    fmt.Println("This is a method for struct B")
}

/*输出
a.Method_Print---   This is a method for struct A
a.Name---           maozi
b.Name--            //空值，修改失败
b.Method_Print      This is a method for struct B
*/

类型别名(如下代码INT为int类型的别名)不会拥有底层类型所附带的方法；可以为任一底层类型（int...）绑定一个方法，如下Method_Print

package main
import "fmt"

type INT int                                        //自定义一个类型INT,底层为int类型，INT就是底层类型int的一个别名

func main() {
    var a INT
    a.Method_Print()

}

func (a *INT) Method_Print() {                      //为int类型绑定一个方法
    fmt.Println("This is a method for int type ")
}

/*输出
a.Method_Print---This is a method for int type
*/

• Method Value 是包装后的状态对象，总是与特定的对象实例关联在一起

• 调用方式类似python类的调用方式，先实例化一个类，在通过.属性调用

• Method Expression是直接类型.method(var) 的方式

package main
import "fmt"

type INT int //定义一个INT

func main() {
    var a INT
    a.Method_Print()                            //method value调用方式
    (*INT).Method_Print(a)                      //method expression调用方式
}

func (a *INT) Method_Print() {                  //为int类型绑定一个方法
    fmt.Println("This is a method for int type ")
}
/*输出
a.Method_Print---This is a method for int type
*/

类方法名称冲突类似与字段的名称冲突，按继承顺序；如果外部结构和嵌入的结构体存在同名方法，则优先调用外部结构体的方法

类方法访问权限：大写首字母表示外部可以访问，小写表示结构体类型的私有字段，私有字段和方法只能在同一个包中调用，只有公有方法（首字母大写）可以在包外调用

package main
import "fmt"

type A struct {
    name string //小写首字母，私有字段
} 

func main() {
    a := A{}
    a.Method_Print() //method value调用方式
}

func (a *A) Method_Print() {                                    
    a.name = "123"                                              //方法可以访问私有字段
    fmt.Println("This is a method for struct type ")
}

/*输出
a.Method_Print---This is a method for int type
*/

声明一个底层为int的类型，实现调用一个方法就递增250， 如x:=0,调用a.Increase(num)后，a从0变为250

    package main
import "fmt"

type Ad int                       //声明底层类型为int类型
    func main() {
    var x Ad
    x.Add(250)                   //method value调用方式,方法传递参数num=100
    fmt.Println(a)
}
func (ad *Ad) Add(num int) {    //为int类型绑定一个方法
    *ad += Ad(num)              //强制类型转换为底层Ad---int型
}
/*输出
a--->250
*/