Go语言学习笔记　－　方法

方法定义

方法总是绑定对象实例，并隐式将实例作为第一实参(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
}