结构体初识

package main

import "fmt"

//33
func main() {
    /*
    结构体
    */

    //方法一
    var p1 Person
    fmt.Println(p1) //{ 0  }
    p1.name = "王二狗"
    p1.age = 30
    p1.sex = "男"
    p1.address = "长春"
    //姓名：王二狗，年龄：30，性别：男，地址：长春
    fmt.Printf("姓名：%s，年龄：%d，性别：%s，地址：%s\n",p1.name,p1.age,p1.sex,p1.address)

    //方法二
    p2 := Person{}
    p2.name = "st"
    p2.age = 22
    p2.sex = "女"
    p2.address = "北京"
    // 姓名：st，年龄：22，性别：女，地址：北京
    fmt.Printf("姓名：%s，年龄：%d，性别：%s，地址：%s\n",p2.name,p2.age,p2.sex,p2.address)

    //方式三
    p3 := Person{name:"如花",age:20,sex:"女",address:"杭州"}
    fmt.Println(p3) //{如花 20 女 杭州}

    //隔行写
    p4 := Person{
        name:    "老王",
        age:     60,
        sex:     "男",
        address: "武汉",
    }
    fmt.Println(p4) //{老王 60 男 武汉}

    //方法四
    p5 := Person{"李小花",20,"女","成都"}
    fmt.Println(p5) //{李小花 20 女 成都}

}

//1. 定义结构体
type Person struct {
    name string
    age int
    sex string
    address string
}

结构体指针

package main

import "fmt"

//34
func main() {
    /*
    结构体指针

    数据类型：
        值类型：int、float、bool、string、array、struct

        引用类型：slice、map、function、pointer
    */
    p1 := Person1{"李小花",20,"女","成都"}
    fmt.Println(p1)
    fmt.Printf("%p,%T\n",&p1,p1) //0xc000038040,main.Person

    p2 := p1
    fmt.Println(p2)
    fmt.Printf("%p,%T\n",&p2,p2) //0xc000038100,main.Person

    p2.name = "王二狗"
    fmt.Println(p2) //{王二狗 20 女 成都}
    fmt.Println(p1) //{李小花 20 女 成都}


    //定义结构体指针
    var pp1 *Person1
    pp1 = &p1
    fmt.Println(pp1)
    fmt.Printf("%p,%T\n",pp1,pp1) //0xc000038040,*main.Person1
    fmt.Println(*pp1) //{李小花 20 女 成都}

    (*pp1).name = "李四"
    pp1.name = "王五"


    //make new
    //使用内置函数new()，它是go语言中专门用于创建某种类型的指针的函数
    //不是nil，空指针，指向了分配的类型的内存，里面存储的零值
    pp2 := new(Person1)
    fmt.Printf("%T\n",pp2)
    pp2.name = "赵六"
    fmt.Println(*pp2)



}

type Person1 struct {
    name string
    age int
    sex string
    address string
}

结构体的匿名字段

package main

import "fmt"

//35
func main() {
    /*
    结构体的匿名字段

        匿名结构体；没有名字的结构体
            变量名 := struct {
                定义字段Field
            }{
                //赋值
            }

    */

    s1 := Student{name:"张三",age:18}
    fmt.Println(s1) //{张三 18}

    //匿名函数
    func (){
        fmt.Println("hello") //hello
    }()

    //匿名结构体
    s2 := struct {
        name string
        age int
    }{
        name:"李四",
        age:19,
    }

    fmt.Println(s2) //{李四 19}

    //使用匿名字段
    w2 := Worker{"小花",32}
    fmt.Println(w2) //{小花 32}

}

//匿名字段  匿名字段不能重复，否则会冲突
type Worker struct {
    string //匿名字段 默认使用数据类型作为名字
    int
}


type Student struct {
    name string
    age int
}

结构体嵌套

package main

import "fmt"

//36
func main() {
    /*
    结构体的嵌套：一个结构体的字段是另一个结构体
    */

    b1 := Book{"西游记",45.8}

    s1 := Student1{
        name: "王二狗",
        age:  18,
        book: b1,
    }

    fmt.Println(b1)
    fmt.Println(s1)

    fmt.Printf("学生姓名：%s，学生年龄：%d，" +
        "看的书是：《%s》，书的价格：%.2f\n",s1.name,s1.age,s1.book.bookName,
        s1.book.price) //学生姓名：王二狗，学生年龄：18，看的书是：《西游记》，书的价格：45.80

    //值传递
    b1.bookName = "红楼梦"
    fmt.Println(b1) //{红楼梦 45.8}
    fmt.Println(s1) //{王二狗 18 {西游记 45.8}}

}

type Book struct {
    bookName string
    price float64
}

type Student1 struct {
    name string
    age int
    book Book
}

Go语言中的OOP

package main

import "fmt"

//37
func main() {
    /*
        Go语言中的oop
            1. 模拟继承性
                type A struct {
                    field
                }
                type B struct {
                    A //匿名字段
                }

    2. 模拟聚合关系
        type C struct{
            field
        }
        type D struct {
            c C //聚合关系
        }

    */
    //1. 创建父类对象
    p1 := Person2{
        name: "张三",
        age:  30,
    }
    fmt.Println(p1)

    //2. 创建子类对象
    s1 := Student2{
        Person2: Person2{
            name: "李四",
            age:  18,
        },
        school:  "东北大学",
    }
    fmt.Println(s1)

    var s3 Student2
    s3.Person2.name = "王五"
    s3.Person2.age = 19
    s3.school = "清华"
    fmt.Println(s3)

    //提升字段 简写
    //Student结构体将Person结构体作为了一个匿名字段了，那么Person中的字段，对于Student
    //来说，就是提升字段，student对象能直接访问
    s3.name = "赵六"
    s3.age = 50
    s3.school = "门头沟"
    fmt.Println(s3)

}

//定义父类
type Person2 struct {
    name string
    age int
}

//定义子类
type Student2 struct {
    Person2 //模拟继承结构
    school string //子类新增属性
}