方法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来绑定；
只是不同的表现形式而已
©著作权归作者所有：来自51CTO博客作者故新的原创作品，如需转载，请注明出处，否则将追究法律责任
m
共同学习，写下你的评论
评论加载中...
作者其他优质文章
