Golang map集合丶struct结构体丶继承

一.map集合

// map键值对集合
func testMap() {
    // Map的定义: var 变量名 map[keytType]valueType
    // 细节:
    // 1.key唯一
    // 2.map是引用
    // 3.直接遍历map是无序的
    // 4.map会自动扩容,make中设置的长度并没有对map任何限制
    var m1 = make(map[string]int32, 2)
    var m2 = map[string]string{
        "key1": "test1",
        "key2": "test2",
        "key3": "test3",
    }
    m2["key4"] = "test4"
    delete(m2, "key2") // 删除操作.如果要删除所有,需要循环删除,或者重新定义后让回收机制回收
    fmt.Println("m1=", m1)
    fmt.Println("m2=", m2)

    // 查找
    val, b := m2["key4"]
    fmt.Println("=", val, "  ", b) // = test4    true
    fmt.Println("=", m2["key4"])   // = test4

    fmt.Println("================================")
    // 遍历 第一次
    for key, val := range m2 {
        fmt.Println("key=", key, " val=", val)
    }
    m2["key5"] = "test5"
    fmt.Println("===========可以看到map遍历的顺序并不是每次都一样,特别是在新加了元素之后=====================")
    // 遍历 第二次
    for key, val := range m2 {
        fmt.Println("key=", key, " val=", val)
    }
    fmt.Println("================================")
    fmt.Println("===========如果要按固定排序输出的话只能通过keys数组切片去实现顺序输出=====================")
    var mapIndexs = make([]string, len(m2))
    temIndex := 0
    for k, _ := range m2 {
        mapIndexs[temIndex] = k
        temIndex++
    }
    sort.Strings(mapIndexs)
    for _, k := range mapIndexs {
        fmt.Println(m2[k])
    }
    fmt.Println("================================")
    // 集合切片
    var m3 = make([]map[string]string, 2)
    m3[0] = map[string]string{
        "name": "张三",
        "age":  "20",
    }
    m3[1] = map[string]string{
        "name": "李四",
        "age":  "19",
    }
    w5 := map[string]string{
        "name": "王五",
        "age":  "21",
    }
    m3 = append(m3, w5)
    fmt.Printf("%v &m3[0]=%x &m3[1]=%x \n", m3, &(m3[0]), &(m3[1]))

}

二.struct结构体

type Person1 struct {
    Name string
    Age  int16 // 小写开头带表只能本包可用
}

func (self *Person1) PrintInfo() (result bool) {
    self.Name = "张三丰"
    fmt.Println("姓名:", self.Name, "\t年龄:", self.Age)
    result = true
    return
}

// 定义struct方法并不会影响内存分配
func (self Person1) PrintInfo1() {
    self.Name = "张三丰" // 这里并不会修改调用对象
    fmt.Println("姓名:", self.Name, "\t年龄:", self.Age)
}

// 给结构体实现String()   那进行强制str转换的时候就是调用这个
func (self *Person1) String() string {
    return fmt.Sprintln("姓名:", self.Name, "\t年龄:", self.Age)
}

func testStruct() {
    fmt.Println("=======================struct定义丶访问============================")
    type Person struct {
        Name string
        age  int16 // 本包可用
    }
    var p1 Person = Person{Name: "Tom", age: 19}
    var p2 *Person = new(Person)
    var p3 *Person = &Person{Name: "Lisa", age: 22}
    p4 := p1
    p4.Name = "Jerry11"
    p1.age = 19
    p2.age = 99 // 因p2是指针,编译器会将"p2.age = 99" 同等 "(*p2).age = 99"
    fmt.Println("struct 是值类型,并非引用:", p1, p2, p3, p4)
    fmt.Println("占用内存大小:", unsafe.Sizeof(p1.Name))
    fmt.Println("占用内存大小:", unsafe.Sizeof(p4.Name))
    fmt.Println()
    fmt.Println("============================使用细节===================================")
    // 1.属性名小写,只能在本包中访问
    // 2.指针:  "*p2.age = 99" 中的"."优先级高于"*" 所以必须"(*p2.age) = 99"  或者不用"*"
    // 3.结构体中的属性,内存分配是连续的.
    // 4.不同struct类型变量如果要强制转换的话,必须声明定义的属性字段类型顺序相同
    // 5.struct中提供tag来协助序列与反序列转化(struct转json或反过来[反射])
    type Monster struct {
        Name  string `json:"name"`
        Age   int16  `json:"age"`
        Skill string `json:"skill"`
    }
    m1 := Monster{"关羽", 101, "大宝剑"}
    jsonstr, _ := json.Marshal(m1) // 如果将属性首字母改称小写,在这里json包中就访问不到了.所以就需要用到tag了
    fmt.Println(string(jsonstr))
    fmt.Println()
    fmt.Println("============================struct 方法 ===================================")
    // 定义语法:func (self Person1) PrintInfo() (result bool) {
    // 注意细节:
    // 1.给struct定义方法并不会影响struct内存分配
    // 2.首参为指针类型的时候才是self,不然self只是值传递
    // 3.语法中的Person1类型,并不一定要是struct,可以是任何自定义类型
    // 4.给结构体实现String()方法   那进行Println输出的时候就是调用这个
    p5 := Person1{"Carry", 30}
    fmt.Println(unsafe.Sizeof(p5))
    p5.PrintInfo() // 同等:(&p5).PrintInfo()    注意:不管你这里从"(&p5)."还是"p5."来调用,编译器都会去设配结构体"PrintInfo()"方法的定义去设配
    fmt.Println("Println:", &p5)

    fmt.Println()
    fmt.Println("============================struct 工厂模式 ===================================")
    // 工厂模式:定义的结构体为私有的,外部想要获得,只能通过工厂统一创建初始化(具体代码看student包)
    stu1 := student.StudentFactory("三年级(2)班", "陈是凯", 13, 85)
    fmt.Println(stu1)
    stu2 := student.HighStudentFactory("三年级(1)班", "吴开军", 26, 75,
        "打篮球", 9, 2002, 1, 15,
        178)
    fmt.Println(stu2)

}

三.struct继承

package student

import (
    "fmt"
    "strconv"
)

// 工厂模式:struct结构体为私有的,通过工厂方法返回结构体变量
func HighStudentFactory(classID string, name string, age int8, score int16,
    hobby string, hobbyScore int16,
    byear uint16, bmonth uint16, bday uint16,
    heightCM uint16) (result *HighStudent) {

    result = &HighStudent{
        Person:   Person{ClassID: classID, Name: name, Age: age, score: score},
        Hobby:    Hobby{Name: hobby, score: hobbyScore},
        Birthday: Birthday{Year: byear, Month: bmonth, Day: bday},
        HeightCM: 172,
    }

    return
}

/* student结构体在factory文件中. 这样重新定义类型,原来student的方法并不会跟过来 */
type Person student

/* 但是这样继承,原来student的方法会跟过来 */
type Person1 struct {
    student
}

type Hobby struct {
    Name  string
    score int16
}

type Birthday struct {
    Year  uint16
    Month uint16
    Day   uint16
}

/* 正常项目不要用这种多重继承方式,会严重干扰你的思绪 */
type HighStudent struct {
    Person   // 继承
    Hobby    // 继承
    Birthday // 继承
    HeightCM uint16
}

func (self *Hobby) String() string {
    return self.Name + "\t热度:" + strconv.Itoa(int(self.score))
}

func (self *Birthday) String() string {
    return fmt.Sprintf("%d年%d月%d日", self.Year, self.Month, self.Day)
}

func (self *HighStudent) String() string {
    s1 := student(self.Person).String() // 因为Person和student完全一样所以可以直接强制转换
    s2 := self.Birthday.String()
    s3 := self.Hobby.String()
    return fmt.Sprintf("%v\n生日:%v\n身高:%v\n爱好:%v\n", s1, s2, self.HeightCM, s3)
}

func TestAddress() {
    stu1 := Person1{student{"八年级(2)班", "五栋梁", 25, 99}}

    fmt.Println(stu1.GetScoreRate())
}