第04天(面对对象编程)_02

05_结构体指针类型匿名字段.go

package main

import "fmt"

type Person struct {
    name string //名字
    sex  byte   //性别, 字符类型
    age  int    //年龄
}

type Student struct {
    *Person //指针类型
    id      int
    addr    string
}

func main() {
    s1 := Student{&Person{"mike", 'm', 18}, 666, "bj"}
    fmt.Println(s1.name, s1.sex, s1.age, s1.id, s1.addr)

    //先定义变量
    var s2 Student
    s2.Person = new(Person) //分配空间
    s2.name = "yoyo"
    s2.sex = 'm'
    s2.age = 18
    s2.id = 222
    s2.addr = "sz"
    fmt.Println(s2.name, s2.sex, s2.age, s2.id, s2.addr)
}

06_面向过程和对象函数的区别.go

package main

import "fmt"

//实现2数相加
//面向过程
func Add01(a, b int) int {
    return a + b
}

//面向对象，方法：给某个类型绑定一个函数
type long int

//tmp叫接收者，接收者就是传递的一个参数
func (tmp long) Add02(other long) long {
    return tmp + other
}

func main() {
    var result int
    result = Add01(1, 1) //普通函数调用方式
    fmt.Println("result = ", result)

    //定义一个变量
    var a long = 2
    //调用方法格式： 变量名.函数(所需参数)
    r := a.Add02(3)
    fmt.Println("r = ", r)

    //面向对象只是换了一种表现形式
}

07_为结构体类型添加方法.go

package main

import "fmt"

type Person struct {
    name string //名字
    sex  byte   //性别, 字符类型
    age  int    //年龄
}

//带有接收者的函数叫方法
func (tmp Person) PrintInfo() {
    fmt.Println("tmp = ", tmp)
}

//通过一个函数，给成员赋值
func (p *Person) SetInfo(n string, s byte, a int) {
    p.name = n
    p.sex = s
    p.age = a
}

type long int

//只要接收者类型不一样，这个方法就算同名，也是不同方法，不会出现重复定义函数的错误
func (tmp long) test() {

}

type char byte

func (tmp char) test() {

}

func (tmp *long) test02() {

}

type pointer *int

//pointer为接收者类型，它本身不能是指针类型
//func (tmp pointer) test() {

//}

func main() {
    //定义同时初始化
    p := Person{"mike", 'm', 18}
    p.PrintInfo()

    //定义一个结构体变量
    var p2 Person
    (&p2).SetInfo("yoyo", 'f', 22)
    p2.PrintInfo()
}

08_值语义和引用语义.go

package main

import "fmt"

type Person struct {
    name string //名字
    sex  byte   //性别, 字符类型
    age  int    //年龄
}

//修改成员变量的值

//接收者为普通变量，非指针，值语义，一份拷贝
func (p Person) SetInfoValue(n string, s byte, a int) {
    p.name = n
    p.sex = s
    p.age = a
    fmt.Println("p = ", p)
    fmt.Printf("SetInfoValue &p = %p\n", &p)
}

//接收者为指针变量，引用传递
func (p *Person) SetInfoPointer(n string, s byte, a int) {
    p.name = n
    p.sex = s
    p.age = a

    fmt.Printf("SetInfoPointer p = %p\n", p)
}

func main() {
    s1 := Person{"go", 'm', 22}
    fmt.Printf("&s1 = %p\n", &s1) //打印地址

    //值语义
    //  s1.SetInfoValue("mike", 'm', 18)
    //  fmt.Println("s1 = ", s1) //打印内容

    //引用语义
    (&s1).SetInfoPointer("mike", 'm', 18)
    fmt.Println("s1 = ", s1) //打印内容
}

09_指针变量的方法集.go

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{"mike", 'm', 18}
    //p.SetInfoPointer() //func (p *Person) SetInfoPointer()
    (*p).SetInfoPointer() //把(*p)转换层p后再调用，等价于上面

    //内部做的转换， 先把指针p， 转成*p后再调用
    //(*p).SetInfoValue()
    //p.SetInfoValue()

}

10_普通变量的方法集.go

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{"mike", 'm', 18}
    p.SetInfoPointer() //func (p *Person) SetInfoPointer()
    //内部，先把p, 转为为&p再调用， (&p).SetInfoPointer()

    p.SetInfoValue()
}