Golang 学习之路八:面向对象-方法(Method)
2017-05-08 16:34
239 查看
Golang 学习:面向对象-方法
一、方法的定义
Go语言的结构体类型(Struct)比函数类型更加灵活。它可以封装属性和操作。前者即是结构体类型中的字段,而后者则是结构体类型所拥有的方法。在关键字func和名称Grow之间的那个圆括号及其包含的内容就是接收者声明。其中的内容由两部分组成。第一部分是代表它依附的那个类型的值的标识符。第二部分是它依附的那个类型的名称。后者表明了依附关系,而前者则使得在该方法中的代码可以使用到该类型的值(也称为当前值)。代表当前值的那个标识符可被称为接收者标识符,或简称为接收者。
这里的接收者指代它所依附的那个类型。我们仍以结构体类型Person为例。下面是依附于它的一个名为Grow的方法的声明:
func (person *Person) Grow() { person.Age++ }
如上所示,在关键字func和名称Grow之间的那个圆括号及其包含的内容就是接收者声明。其中的内容由两部分组成。第一部分是代表它依附的那个类型的值的标识符。第二部分是它依附的那个类型的名称。后者表明了依附关系,而前者则使得在该方法中的代码可以使用到该类型的值(也称为当前值)。代表当前值的那个标识符可被称为接收者标识符,或简称为接收者。请看下面的示例:
p := Person{"Robert", "Male", 33} p.Grow()
我们可以直接在Person类型的变量p之上应用调用表达式来调用它的方法Grow。注意,此时方法Grow的接收者标识符person指代的正是变量p的值。这也是“当前值”这个词的由来。在Grow方法中,我们通过使用选择表达式选择了当前值的字段Age,并使其自增。因此,在语句p.Grow()被执行之后,p所代表的那个人就又年长了一岁(p的Age字段的值已变为34)。
需要注意的是,在Grow方法的接收者声明中的那个类型是*Person,而不是Person。实际上,前者是后者的指针类型。这也使得person指代的是p的指针,而不是它本身。
方法总是绑定对象实例,并隐式将实例作为第一实参(receiver)。
只能为当前包内命名类型定义方法。
参数receive可任意命名。如方法中未曾使用,可省略参数名。
参数receive类型可以是T或*T。类型T不能是接口指针。
不支持方法重载,receive只是参数签名的组成部分。
可用实例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 : 0x1167c0ec Value : 0x1167c108 Pointer : 0x1167c0ec Value : 0x1167c10c Pointer : 0x1167c0ec
结果分析:
从上面的结果可以看出当receiver是T类型时,它是Data的一个copy,而当receiver是*T类型时,就指真正的Data。如果一个method的receiver是*T,你可以在一个T类型的实例变量V上面调用这个method,而不需要&V去调用这个method。如果一个method的receiver是*T,你可以在一个T类型的实例变量V上面调用这个method,而不需要&V去调用这个method类似的如果一个method的receiver是T,你可以在一个*T类型的变量P上面调用这个method,而不需要 *P去调用这个method。所以,你不用担心你是调用的指针的method还是不是指针的method,Go知道你要做的一切。我真是惊呆了,这就是说Go的设计是需要你能理解why,但是不需要你去做what。
从Go version1.4开始,不再支持多级指针查找方法成员。
type X struct{} func (*X) test() { println("X.test") } func main() { p := &X{} p.test() // Error: calling method with receiver &p (type **X) requires explicit dereference // (&p).test() }
二、匿名字段
可以像字段成员那样访问匿名字段方法,编译器负责查找。type User struct { id int name string } type Manager struct { User } func (self *User) ToString() string { return fmt.Sprintf("User: %p,%v", self, self) } func main() { m := Manager{User{1, "Tom"}} fmt.Println("Manager: %p\n", &m) fmt.Println(m.ToString()) }
输出结果:
Manager: %p &{{1 Tom}} User: 0x115b2170,&{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: 0x1162fb20, &{{1 Tom} Administrator} User: 0x1162fb20, &{1 Tom}
三、方法集
每个类型都有与之关联的方法集,这会影响到接口实现规则。类型T方法集包含全部的receive T方法。
类型*T方法集包含全部receive T + *T方法。
如类型S包含你名字段T,则S方法集包含T方法。
如类型S包含匿名字段*T,则S方法集包含T + *T方法。
不管嵌入T或*T,*S方法集总是包含T + *T方法。
用实例value和pointer调用方法(含匿名字段)不受方法集约束,编译器总是查找全部方法,并自动转换receive实参。
四、表达式
根据调用者的不同,方法分为两种表现形式:instance.method(args...) ---> <type>.func(interface, 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 }
输出结果:
0x11482170, &{1 Tom} 0x11482170, &{1 Tom} 0x11482170, &{1 Tom}
注意method value会复制receiver。
type User struct { id int name string } func (self User) Test() { fmt.Println(self) } func main() { u := User{1, "Tom"} mValue := u.Test // 立即复制 receiver,因为不是指针类型,不受后续修改影响。 u.id, u.name = 2, "Jack" u.Test() mValue() }
输出结果:
{2 Jack} {1 Tom}
在汇编层面,method value和闭包的实现方式相同,实际返回FuncVal类型对象。
FuncVal { method_address, receiver_copy }
可根据方法集转换 method expression,注意receive类型的差异。
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 : 0x116420e0, {1 Tom} TestValue : 0x11642140, {1 Tom} TestPointer : 0x116420e0, &{1 Tom} TestValue : 0x11642170, {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 }
五、补充练习示例
为源码文件中声明的结构体类型Person添加相应的字段和方法,使得该文件不会导致任何编译错误并能够在标准输出上打印出Robert moved from Beijing to San Francisco.。
package main import "fmt" type Person struct { Name string Gender string Age uint8 } func main() { p := Person{"Robert", "Male", 33, "Beijing"} oldAddress := p.Move("San Francisco") fmt.Printf("%s moved from %s to %s.\n", p.Name, oldAddress, p.Address) }
参考代码:
package main import "fmt" type Person struct { Name string Gender string Age uint8 Address string } func (self *Person) Move(addr string) string { a := self.Address self.Address = addr return a } func main() { p := Person{"Robert", "Male", 33, "Beijing"} oldAddress := p.Move("San Francisco") fmt.Printf("%s moved from %s to %s.\n", p.Name, oldAddress, p.Address) }
六、总结
本部分主要介绍了Go面向对象 method,学习了这部分就可以设计一些出基本的面向对象的Go程序。Go里面的面向对象是如此的简单,没有任何的私有、公有关键字,通过大小写来实现(大写开头的为共有,小写开头的为私有),方法也同样适用这个原则。仔细探究这些用法,愈发感觉Go的设计精妙,它能让开发者开发过程中不忽略关键点,但不许要你为其做多余的,繁杂的动作。七、参考资料
Go 学习笔记(雨痕)Go Web 编程
Go语言第一课
相关文章推荐
- java学习之路 之 高级类特性1-面向对象特征之二:继承及方法重写(override)
- java学习笔记《java面向对象编程》——面向对象开发方法概述
- 学习面向对象开发的方法
- JavaSE入门学习23:Java面向对象之构造方法
- [原创]java WEB学习笔记79:Hibernate学习之路--- 四种对象的状态,session核心方法:save()方法,persist()方法,get() 和 load() 方法,update()方法,saveOrUpdate() 方法,merge() 方法,delete() 方法,evict(),hibernate 调用存储过程,hibernate 与 触发器协同工作
- 面向对象设计学习之路——CRC卡及其应用
- PHP面向对象及类、方法的学习心得
- php学习笔记------[php面向对象中常用关键字与魔术方法]
- 学习笔记9:C#基础(面向对象和字符串的方法)
- js面向对象学习笔记之二(debug调试方法)
- 菜鸟的学习之路(3) —java 面向对象程序设计的封装、继承和多态
- C++学习笔记5:从方法到属性(面向对象基础)
- C#面向对象设计模式纵横谈(四) --- Factory Method 工厂方法(创建型模式)
- JAVA面向对象基础 对象 类 方法学习笔记
- php学习笔记------[php面向对象中常用关键字与魔术方法]
- JavaSE入门学习23:Java面向对象之构造方法
- java学习之路 之 面向对象编程-类的成员之属性、方法及对象的创建和使用
- Java菜鸟学习笔记--面向对象篇(十六):Object类方法
- Python之路,Day6 - 面向对象学习
- JavaScript学习--Item8 函数,方法,构造函数调用 标签: javascript构造函数面向对象函数call