#GO学习笔记08
面向对象
1.匿名组合
package main
import "fmt"
type Person struct {
name string
sex byte
age int
}
type Student struct {
Person //匿名字段、继承了Person的成员
id int
addr string
}
func main() {
var s1 Student = Student{Person{"tony", 'm', 18}, 282, "北京路"}
fmt.Println("s1 = ", s1)
//自动推导类型
s2 := Student{Person{"tony", 'm', 18}, 282, "北京路"}
//fmt.Println("s2 = ",s2)
fmt.Printf("s2 = %+v\n", s2)
fmt.Println(s2.name, s2.id, s2.addr, s2.sex)
//指定成员初始化
s3 := Student{id: 1}
fmt.Printf("s3 = %+v\n", s3)
s4 := Student{Person: Person{name: "tony"}, id: 99}
fmt.Printf("s4 = %+v\n", s4)
}
s1 = {{tony 109 18} 282 北京路}
s2 = {Person:{name:tony sex:109 age:18} id:282 addr:北京路}
tony 282 北京路 109
s3 = {Person:{name: sex:0 age:0} id:1 addr:}
s4 = {Person:{name:tony sex:0 age:0} id:99 addr:}
2.同名成员
package main
import "fmt"
type Person struct {
name string
sex byte
age int
}
type Student struct {
Person //匿名字段、继承了Person的成员
id int
addr string
name string
}
func main() {
var s Student
s.name = "tony"
s.id = 99
s.sex = 'm'
fmt.Printf("s = %+v\n", s)
s.Person.name = "PersonName"
fmt.Printf("s = %+v\n", s)
}
s = {Person:{name: sex:109 age:0} id:99 addr: name:tony}
s = {Person:{name:PersonName sex:109 age:0} id:99 addr: name:tony}
3.非结构体的匿名字段
package main
import "fmt"
type mystr string
type Person struct {
name string
sex byte
age int
}
type Student struct {
Person //结构体匿名字段
int //基础类型的匿名字段
mystr
}
func main() {
s:=Student{Person{"tony",'m',88},99,"帝景卡士"}
fmt.Printf("s = %+v\n", s)
}
s = {Person:{name:tony sex:109 age:88} int:99 mystr:帝景卡士}
4.指针类型
package main
import "fmt"
type Person struct {
name string
sex byte
age int
}
type Student struct {
*Person //指针类型
id int
addr string
}
func main() {
//1.直接取地址赋值
s1 := Student{&Person{"tony", 'm', 88}, 99, "帝景卡士"}
fmt.Printf("s1 = %+v\n", s1)
fmt.Println(s1.name, s1.sex, s1.age, s1.id, s1.addr)
//2.先定义后赋值
var s2 Student
s2.Person = new(Person)
s2.name = "tom"
s2.sex = 'm'
s2.age = 19
s2.id = 999
s2.addr = "SZ"
fmt.Println(s2.name, s2.sex, s2.age, s2.id, s2.addr)
}
s1 = {Person:0xc42008e020 id:99 addr:帝景卡士}
tony 109 88 99 帝景卡士
tom 109 19 999 SZ
5.面向对象和面向过程
package main
import "fmt"
//面向过程
func Add01(a, b int) int {
return a + b
}
type long int //定义的类型本身不能是指针
type char byte
//方法名字可以一样，接受者类型不一样也可以
func (temp char) test01(){
}
func (temp char) test01(){
}
//面向对象
func (temp long) Add02(other long) long {
return temp + other
}
func main() {
result := Add01(3, 4)
fmt.Println("a + b = ", result)
var a long = 2
r := a.Add02(3)
fmt.Println("r = ", r)
}
a + b = 7
r = 5
6.结构体类型添加方法
package main
import "fmt"
type Person struct {
name string
sex byte
age int
}
//打印结构体参数的方法
func (tep Person) PrintInfo() {
fmt.Println("tep: ", tep)
}
//通过函数修改Person内容
func (p *Person) SetInfo(name string, sex byte, age int) {
p.name = name
p.sex = sex
p.age = age
}
func main() {
p := Person{"tony", 'm', 19}
p.PrintInfo()
var p2 Person
(&p2).SetInfo("tom", 'f', 20)
p2.PrintInfo()
}
tep: {tony 109 19}
tep: {tom 102 20}
7.值语义和引用语义的区别
package main
import "fmt"
type Person struct {
name string
sex byte
age int
}
func (p Person) SetInfoValue(name string, sex byte, age int) {
p.name = name
p.sex = sex
p.age = age
fmt.Println("SetInfoValue = ", p)
fmt.Printf("SetInfoValue &p = %p\n", &p)
}
func (p *Person) SetInfoPointer(name string, sex byte, age int) {
p.name = name
p.sex = sex
p.age = age
fmt.Printf("SetInfoPointer &p = %p\n", p)
}
func main() {
s1 := Person{"go", 'm', 22}
fmt.Println("s1原始值 = ",s1)
fmt.Printf("&s1 = %p\n", &s1)
//修语义
//s1.SetInfoValue("tony", 'f', 29)
//fmt.Println("s1 = ", s1)
//引用语义
(&s1).SetInfoPointer("tom",'f',99)
fmt.Println("s1 = ", s1)
}
//值语义
s1原始值 = {go 109 22}
&s1 = 0xc42000a060
SetInfoValue = {tony 102 29}
SetInfoValue &p = 0xc42000a0a0
s1 = {go 109 22}
//引用语义
s1原始值 = {go 109 22}
&s1 = 0xc42000a060
SetInfoPointer &p = 0xc42000a060
s1 = {tom 102 99}
8.指针类型和普通类型的方法集
- 指针类型
package main
import "fmt"
type Person struct {
name string
sex byte
age int
}
func (p Person) SetInfoValue() {
fmt.Println("SetInfoValue")
}
func (p *Person) SetInfoPointer() {
fmt.Println("SetInfoPointer")
}
func main() {
p := &Person{"go", 'm', 22}
p.SetInfoPointer()
(*p).SetInfoPointer() //把*p转换成p再调用
(*p).SetInfoValue() //内部做了转换，先把指针转换成*p再调用
p.SetInfoValue()
}
SetInfoPointer
SetInfoPointer
SetInfoValue
SetInfoValue
- 普通类型
package main
import "fmt"
type Person struct {
name string
sex byte
age int
}
func (p Person) SetInfoValue() {
fmt.Println("SetInfoValue")
}
func (p *Person) SetInfoPointer() {
fmt.Println("SetInfoPointer")
}
func main() {
p := Person{"go", 'm', 22}
p.SetInfoPointer() //内部是将p转换成*p再调用
p.SetInfoValue()
}
SetInfoPointer
SetInfoValue
9.继承
package main
import "fmt"
type Person struct {
name string
sex byte
age int
}
func (p *Person) PrintInfo() {
fmt.Printf("name = %s, sex = %c, age = %d\n", p.name, p.sex, p.age)
}
//Student字段集成了Person 包括成员及方法
type Student struct {
Person //匿名字段
id int
addr string
}
func main() {
s := Student{Person{"tony", 'f', 12}, 111, "sz"}
s.PrintInfo()
}
name = tony, sex = f, age = 12
10.方法的重写
package main
import "fmt"
type Person struct {
name string
sex byte
age int
}
func (p *Person) PrintInfo() {
fmt.Printf("name = %s, sex = %c, age = %d\n", p.name, p.sex, p.age)
}
//Student字段集成了Person 包括成员及方法
type Student struct {
Person //匿名字段
id int
addr string
}
//方法的重写
func (temp *Student) PrintInfo() {
fmt.Println("Student:temp = ", temp)
}
func main() {
s := Student{Person{"tony", 'f', 12}, 111, "sz"}
//遵循就近原则
s.PrintInfo()
//显示调用继承的方法
s.Person.PrintInfo()
}
Student:temp = &{{tony 102 12} 111 sz}
name = tony, sex = f, age = 12
11.方法值
package main
import "fmt"
type Person struct {
name string
sex byte
age int
}
func (p Person) SetInfoValue() {
fmt.Printf("SetInfoValue: %p, %v\n", &p, p)
}
func (p *Person) SetInfoPointer() {
fmt.Printf("SetInfoPointer: %p, %v\n", p, p)
}
func main() {
p := Person{"tony", 'f', 12}
fmt.Printf("main: %p, %v\n", &p, p)
p.SetInfoPointer() //普通调用方式
pFunc := p.SetInfoPointer //这个就是方法值，调用函数时，无需再传递接受者，隐藏了接受者
pFunc() //等价于p.SetInfoPointer()
vFunc := p.SetInfoValue
vFunc() //等价于p.SetInfoValue()
}
main: 0xc42000a060, {tony 102 12}
SetInfoPointer: 0xc42000a060, &{tony 102 12}
SetInfoPointer: 0xc42000a060, &{tony 102 12}
SetInfoValue: 0xc42000a0e0, {tony 102 12}
12.方法表达式
package main
import "fmt"
type Person struct {
name string
sex byte
age int
}
func (p Person) SetInfoValue() {
fmt.Printf("SetInfoValue: %p, %v\n", &p, p)
}
func (p *Person) SetInfoPointer() {
fmt.Printf("SetInfoPointer: %p, %v\n", p, p)
}
func main() {
p := Person{"tony", 'f', 12}
fmt.Printf("main: %p, %v\n", &p, p)
//方法表达式
f:=(*Person).SetInfoPointer
f(&p) //显示的把接受者传递过去，p.SetInfoPointer()
f2:=(Person).SetInfoValue
f2(p) //显示的把接受者传递过去，p.SetInfoValue()
}
main: 0xc42000a060, {tony 102 12}
SetInfoPointer: 0xc42000a060, &{tony 102 12}
SetInfoPointer: 0xc42000a060, &{tony 102 12}
SetInfoValue: 0xc42000a0e0, {tony 102 12}
