方法定义
方法总是绑定对象实例，并隐式将实例作为第一实参(receiver)
- 只能为当前包内命令类型定义方法。
- 参数recevier可任意命名。如方法中未曾使用，可省略参数名。
- 参数recevier类型可以是T或*T。基类型T不能是接口或指针。
- 不支持方法重载，recevier只是参数签名的组成部分。
- 可用实例value或pointer调用全部方法，编译器自动转换。
没有构造和析构方法，通常用简单工厂模式返回对象实例。
type Queue struct {
elements []interface{}
}
func NewQueue() *Queue {// 创建对象实例。
return &Queue{make([]interface{}, 10)}
}
func (*Queue) Push(e interface{}) error {// 省略 receiver 参数名。
panic("not implemented")
}
// func (Queue) Push(e int) error {// Error: method redeclared: Queue.Push
// panic("not implemented")
// }
func (self *Queue) length() int {// receiver 参数名可以是 self、this 或其他。
return len(self.elements)
}
方法不过是一种特殊的函数,只需将其还原,就知道 receiver T 和 *T 的差别。
type Data struct{
x int
}
func (self Data) ValueTest() {// func ValueTest(self Data);
fmt.Printf("Value: %p\n", &self)
}
func (self *Data) PointerTest() {// func PointerTest(self *Data);
fmt.Printf("Pointer: %p\n", self)
}
func main() {
d := Data{}
p := &d
fmt.Printf("Data: %p\n", p)
d.ValueTest() // ValueTest(d)
d.PointerTest() // PointerTest(&d)
p.ValueTest() // ValueTest(*p)
p.PointerTest() // PointerTest(p)
}
//输出：
Data : 0x2101ef018
Value : 0x2101ef028
Pointer: 0x2101ef018
Value: 0x2101ef030
Pointer: 0x2101ef018
匿名字段
可以像字段成员那样访问匿名字段方法,编译器负责查找。
type User struct {
id int
name string
}
type Manager struct {
User
}
func (u *User) ToString() string { // receiver = &(Manager.User)
return fmt.Sprintf("User：%p,%v", u, u)
}
func main() {
m := Manager{User{1,"Tonny"}}
fmt.Printf("Manager： %p", &m)
fmt.Printf(m.ToString())
}
//输出：
Manager：0x2102281b0
User ：0x2102281b0，&{1 Tom}
通过匿名字段,可获得和继承类似的复用能力。依据编译器查找次序,只需在外层定义同名方法,就可以实现 "override"。
type User struct {
id int
name string
}
type Manager struct {
User
title string
}
func (self *User) ToString() string {
return fmt.Sprintf("User: %p, %v", self, self)
}
func (self *Manager) ToString() string {
return fmt.Sprintf("Manager: %p, %v", self, self)
}
func main() {
m := Manager{User{1, "Tom"}, "Administrator"}
fmt.Println(m.ToString())
fmt.Println(m.User.ToString())
}
//输出:
Manager: 0x2102271b0, &{{1 Tom} Administrator}
User: 0x2102271b0, &{1 Tom}
方法集
每个类型都有与之关联的方法集,这会影响到接口实现规则。
• 类型 T 方法集包含全部 receiver T 方法。
• 类型 *T 方法集包含全部 receiver T + *T 方法。
• 如类型 S 包含匿名字段 T,则 S 方法集包含 T 方法。
• 如类型 S 包含匿名字段 *T,则 S 方法集包含 T + *T 方法。
• 不管嵌入入 T 或 T,S 方法集总是包含 T + *T 方法。
用实例 value 和 pointer 调用方法 (含匿名字段) 不受方法集约束,编译器总是查找全部方法,并自动转换 receiver 实参。
表达式
根据调用者不同，方法分为两种表现形式：
instance.method(args...) ---> <type>.func(instance,args...)
前者称为 method value，后者称为method expression。
两者都可以像普通函数那样赋值和传参，区别在于method value绑定实例，而method expression则需显示传参。
type User struct {
id int
name string
}
func (self *User) Test() {
fmt.Printf("%p, %v\n", self, self)
}
func main() {
u := User{1, "Tom"}
u.Test()
mValue := u.Test
mValue()// 隐式传递 receiver
mExpression := (*User).Test
mExpression(&u)// 显式传递 receiver
}
//输出:
0x210230000, &{1 Tom}
0x210230000, &{1 Tom}
0x210230000, &{1 Tom}
需要注意,method value 会复制 receiver。在汇编层面,method value 和闭包的实现方式相同,实际返回 FuncVal 类型对象。
FuncVal { method_address, receiver_copy }
可依据方法集转换 method expression,注意 receiver 类型的差异。
type User struct {
id int
name string
}
func (self *User) TestPointer() {
fmt.Printf("TestPointer: %p, %v\n", self, self)
}
func (self User) TestValue() {
fmt.Printf("TestValue: %p, %v\n", &self, self)
}
func main() {
u := User{1, "Tom"}
fmt.Printf("User: %p, %v\n", &u, u)
mv := User.TestValue
mv(u)
mp := (*User).TestPointer
mp(&u)
mp2 := (*User).TestValue // *User 方方法集包含 TestValue。
mp2(&u) // 签名变为 func TestValue(self *User)。
}// 实际依然是 receiver value copy。
//输出:
User : 0x210231000, {1 Tom}
TestValue : 0x210231060, {1 Tom}
TestPointer: 0x210231000, &{1 Tom}
TestValue: 0x2102310c0, {1 Tom}
//将方方法 "还原" 成函数,就容易理解下面面的代码了。
type Data struct{}
func (Data) TestValue()
{}
func (*Data) TestPointer() {}
func main() {
var p *Data = nil
p.TestPointer()
(*Data)(nil).TestPointer() // method value
(*Data).TestPointer(nil) // method expression
// p.TestValue() // invalid memory address or nil pointer dereference
// (Data)(nil).TestValue() // cannot convert nil to type Data
// Data.TestValue(nil) // cannot use nil as type Data in function argument
}
