Go语言之method

方法method

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

1、创建method

//创建方法
package main

import "fmt"

type book struct {
    Name string
}

type eleBook struct {
    Name string
}

func main() {
    //创建一个对象
    aBook := book{Name:"spark computer"}
    aBook.show()

    bBook := eleBook{Name:"k8s computer"}
    bBook.show()
}

//创建一个method
//此mothod方法属于book类型
//(a book)  这个字段 是说
// 此方法，属于哪类型，是跟类型绑定的
// (a book)就是一个receiver
//只能指定的类型的变量，才能调用
//方法的绑定，只能是同一个包中，才起作用
func (a book) show()  {
    fmt.Println("this is book:\t",a.Name)
}

// 这属于重载了
//func (a book) show(info string)  {
//  fmt.Println("this is book")
//}

//创建一个method
//此mothod方法属于eleBook类型
func (a eleBook) show()  {
    fmt.Println("this is ele book")
}

2、receiver 按引用传递 测试

package main

import "fmt"

type flower struct {
    Name string
}

type rose struct {
    Name string
}

func main() {

    flower := flower{Name:"a big flower"}
    rose := rose{Name:"a big rose"}
    fmt.Println("init flower:\t", flower)
    flower.show()
    fmt.Println("after flower:\t", flower)

    fmt.Println("===========================")

    fmt.Println("init rose:\t", rose)
    rose.show()
    fmt.Println("after rose:\t", rose)
}

//(flower flower)  这种方式，是按值传递的，不能改变原值的
func (flower flower)show()  {
    flower.Name = "I'm flower"
    fmt.Println("flower:\t", flower)
}

//(rose *rose) 是按引用传递的，可以改变原值的
func (rose *rose)show()  {
    rose.Name = " this is rose"
    fmt.Println("rose:\t", rose)
}

3、测试 别名 与 方法的绑定

//别名 与 方法的绑定
// 作用，就是，有一种增强的感觉，如int类型，本身没有show,add方法
//别名  与   方法的组合，确有了
package main

import "fmt"

type TZ int

func main() {
    var ty TZ = 3
    fmt.Println("ty:\t" , ty)
    //Method value 调用方式，通过类型的变量来调用
    ty.show()
    ty.add()

    fmt.Println("==================Method value   Method Express的不同==============================")
    //对方法的两种不同的导调用方式而已

    //Method express 调用方式，通过类型直接来调用
    //此种方式，需要自己输入 变量
    //因为receiver接收的是地址，因此，我们传入的是地址
    (*TZ).show(&ty)
    (*TZ).add(&ty)

}

//下面的这些方法，都是通过 某一个类型的 变量 来进行调用的
//java 是通过对象来调用的
func (tz *TZ)show()  {
    fmt.Println("---->:\t 这是int类型", *tz) //tz是地址，*tz 是取地址里的内容了
}

func (tz *TZ)add()  {
    fmt.Println("---->:\t 这是int类型的加法")
}

4、方法访问属性 的权限 测试

//方法 的权限问题，是否可以访问 私有字段呢？
//权限是以package 为级别的
//方法的访问权限是很高的，可以访问同一个package下的所有属性，包括公共的，私有的
package main

import "fmt"

type bike struct {
    //小写是私有属性，私有属性，只能在同一个package内，进行访问的
    name string
    //大写是公共属性
    Color string
}

func main() {
    bike := bike{name:"捷安特", Color:"黑色"}
    fmt.Println("old bike:\t", bike)

    //通过类型的变量，来调用方法
    bike.show()
    fmt.Println("new bike:\t", bike)
}

func (bike *bike)show()  {
    bike.Color = "红色"
    bike.name = "永久" //看见了吧，方法是可以访问同一package下的私有属性的
    fmt.Println("bike:\t", bike)
}

5、练习题

//练习题：
//依据的理论知识：为结构增加方法的知识
//尝试声明一个底层类型为int的类型
//并实现调用某个方法就递增100
//如   a:=0, 调用a.Increase()只会，a从0变成100
package main

import "fmt"

//为int 声明一个别名
type intFor int

func main() {
    var a intFor = 0
    fmt.Println(a.Increase())
}

//传的地址
//注意，返回值的类型是intFor
func (arg *intFor)Increase()  intFor {
    //添加上*,就表示取地址里的内容了
    *arg = 100

    return *arg
}

总结：

例如，type intFor int，
不光是int类型，也可以是其他类型。
开始扩展思维，其实，就是为某个类型，增加方法；
Java里的一个类里包括属性，以及方法；
在Go语言中，各种属性是封装在一个类型里，方法是通过receiver来绑定；
只是不同的表现形式而已