go实战基础（一）-go实战struct（九）-《GO开发知识笔记》

2025-11-04 01:17:35 编程来源：ZONE.CI 全球网 0 阅读模式

package main
import "fmt"
//自定义类型
type myInt int
// type myFn func(int, int) int
//类型别名
type myFloat = float64
func main() {
    var a myInt = 10
    fmt.Printf("%v %T\n", a, a) //10 main.myInt
    var b myFloat = 12.3
    fmt.Printf("%v %T", b, b) //12.3 float64
}

/*
Go语言中的基础数据类型可以表示一些事物的基本属性，
但是当我们想表达一个事物的全部或部分属性时，
这时候再用单一的基本数据类型明显就无法满足需求了，
Go语言提供了一种自定义数据类型，可以封装多个基本数据类型，
这种数据类型叫结构体，英文名称struct
*/
package main
import "fmt"
type Person struct {
    name string
    age  int
    sex  string
}
func main() {
    var p1 Person //实例化Person结构体
    p1.name = "张三"
    p1.sex = "男"
    p1.age = 20
    fmt.Printf("值:%v 类型:%T\n", p1, p1) //值:{张三 20 男} 类型:main.Person
    fmt.Printf("值:%#v 类型:%T", p1, p1)  //值:main.Person{name:"张三", age:20, sex:"男"} 类型:main.Person
}

/*
Go语言中的基础数据类型可以表示一些事物的基本属性，
但是当我们想表达一个事物的全部或部分属性时，
这时候再用单一的基本数据类型明显就无法满足需求了，
Go语言提供了一种自定义数据类型，可以封装多个基本数据类型，
这种数据类型叫结构体，英文名称struct
注意：结构体首字母可以大写也可以小写，大写表示这个结构体是公有的，在其他的包里面 可以使用。小写表示这个结构体是私有的，只有这个包里面才能使用
*/
package main
import "fmt"
type Person struct {
    Name string
    Age  int
    Sex  string
}
func main() {
    //注意：在 Golang 中支持对结构体指针直接使用.来访问结构体的成员。p2.name = "张三" 其 实在底层是(*p2).name = "张三"
    var p2 = new(Person)
    p2.Name = "李四"
    p2.Age = 20
    p2.Sex = "男"
    (*p2).Name = "王五"
    fmt.Printf("值:%#v 类型:%T\n", p2, p2) //值:&main.Person{Name:"李四", Age:20, Sex:"男"} 类型:*main.Person
    var p3 = &Person{}
    p3.Name = "赵四"
    p3.Age = 23
    p3.Sex = "男"
    fmt.Printf("值:%#v 类型:%T\n", p3, p3) //值:&main.Person{Name:"赵四", Age:23, Sex:"男"} 类型:*main.Person
    var p4 = Person{
        Name: "哈哈",
        Age:  20,
        Sex:  "男",
    }
    fmt.Printf("值:%#v 类型:%T\n", p4, p4) //值:main.Person{Name:"哈哈", Age:20, Sex:"男"} 类型:main.Person
    var p5 = &Person{
        Name: "王麻子",
        Age:  20,
        Sex:  "男",
    }
    fmt.Printf("值:%#v 类型:%T\n", p5, p5) //值:&main.Person{Name:"王麻子", Age:20, Sex:"男"} 类型:*main.Person
    var p6 = &Person{
        Name: "王麻子",
    }
    fmt.Printf("值:%#v 类型:%T\n", p6, p6) //值:&main.Person{Name:"王麻子", Age:0, Sex:""} 类型:*main.Person
    var p7 = &Person{
        "张三",
        20,
        "男",
    }
    fmt.Printf("值:%#v 类型:%T\n", p7, p7) //值:&main.Person{Name:"张三", Age:20, Sex:"男"} 类型:*main.Person
}

/*
    值类型 ： 改变变量副本值的时候，不会改变变量本身的值 (数组、基本数据类型、结构体)
    引用类型：改变变量副本值的时候，会改变变量本身的值  （切片、map）
*/
package main
import "fmt"
type Person struct {
    Name string
    Age  int
    Sex  string
}
func main() {
    var p1 = Person{
        Name: "哈哈",
        Age:  20,
        Sex:  "男",
    }
    p2 := p1
    p2.Name = "李四"
    fmt.Printf("%#v\n", p1) //main.Person{Name:"哈哈", Age:20, Sex:"男"}
    fmt.Printf("%#v", p2)   //main.Person{Name:"李四", Age:20, Sex:"男"}
}

/*
结构体可以描述现实生活中的任何事物，生活中的任何事物都可以当做结构体对象
我们可以把客观事物封装成结构体 :
    汽车
         汽车有属性：颜色   大小   重量  发动机   轮胎 ...
         汽车行为 也叫方法：  run  跑
    小狗
        属性：颜色     大小     品种  性别 ..
        行为：叫    、闻一闻  舔一舔  咬一咬
    电风扇
        属性： 颜色 大小  高低...
        行为：转动
    人也是一个结构体对象：
        属性： 名字  年龄 性别 ...
        行为：工作  运动 ..
*/
package main
import "fmt"
type Person struct {
    Name   string
    Age    int
    Sex    string
    height int
}
func (p Person) PrintInfo() {
    fmt.Printf("姓名：%v 年龄:%v\n", p.Name, p.Age)
}
func main() {
    var p1 = Person{
        Name: "张三",
        Age:  20,
        Sex:  "男",
    }
    p1.PrintInfo() //姓名：张三 年龄:20
    var p2 = Person{
        Name: "李四",
        Age:  30,
        Sex:  "男",
    }
    p2.PrintInfo() //姓名：李四 年龄:30
    p1.PrintInfo() //姓名：张三 年龄:20
}

/*
结构体可以描述现实生活中的任何事物，生活中的任何事物都可以当做结构体对象
我们可以把客观事物封装成结构体 :
    汽车
         汽车有属性：颜色   大小   重量  发动机   轮胎 ...
         汽车行为 也叫方法：  run  跑
    小狗
        属性：颜色     大小     品种  性别 ..
        行为：叫    、闻一闻  舔一舔  咬一咬
    电风扇
        属性： 颜色 大小  高低...
        行为：转动
    人也是一个结构体对象：
        属性： 名字  年龄 性别 ...
        行为：工作  运动 ..
*/
package main
import "fmt"
type Person struct {
    Name   string
    Age    int
    Sex    string
    height int
}
func (p Person) PrintInfo() {
    fmt.Printf("姓名：%v 年龄:%v\n", p.Name, p.Age)
}
func (p *Person) SetInfo(name string, age int) {
    p.Name = name
    p.Age = age
}
func main() {
    var p1 = Person{
        Name: "张三",
        Age:  20,
        Sex:  "男",
    }
    p1.PrintInfo() //姓名：张三 年龄:20
    p1.SetInfo("李四", 34)
    p1.PrintInfo() //姓名：李四 年龄:34
}

/*
结构体可以描述现实生活中的任何事物，生活中的任何事物都可以当做结构体对象
我们可以把客观事物封装成结构体 :
    汽车
         汽车有属性：颜色   大小   重量  发动机   轮胎 ...
         汽车行为 也叫方法：  run  跑
    小狗
        属性：颜色     大小     品种  性别 ..
        行为：叫    、闻一闻  舔一舔  咬一咬
    电风扇
        属性： 颜色 大小  高低...
        行为：转动
    人也是一个结构体对象：
        属性： 名字  年龄 性别 ...
        行为：工作  运动 ..
*/
//golang中结构体实例是独立的，不会相互影响
package main
import "fmt"
type Person struct {
    Name   string
    Age    int
    Sex    string
    height int
}
func (p Person) PrintInfo() {
    fmt.Printf("姓名：%v 年龄:%v\n", p.Name, p.Age)
}
func (p *Person) SetInfo(name string, age int) {
    p.Name = name
    p.Age = age
}
func main() {
    var p1 = Person{
        Name: "张三",
        Age:  20,
        Sex:  "男",
    }
    p1.PrintInfo() //姓名：张三 年龄:20
    var p2 = Person{
        Name: "王五",
        Age:  22,
        Sex:  "男",
    }
    p1.SetInfo("李四", 34)
    p1.PrintInfo() //姓名：李四 年龄:34
    p2.PrintInfo() //姓名：王五 年龄:22
}

package main
import "fmt"
//注意事项： 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。
type MyInt int
func (m MyInt) PrintInfo() {
    fmt.Println("我是自定义类型里面的自定义方法")
}
func main() {
    var a MyInt = 20
    a.PrintInfo()
}

package main
import "fmt"
/*
结构体的匿名字段:
    结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段
    匿名字段默认采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个
*/
type Person struct {
    string
    int
}
func main() {
    p := Person{
        "张三",
        20,
    }
    fmt.Println(p)
}

package main
import "fmt"
/*
结构体的字段类型可以是：基本数据类型、也可以是切片、Map 以及结构体
如果结构体的字段类型是: 指针，slice，和map的零值都是 nil ，即还没有分配空间
如果需要使用这样的字段，需要先make，才能使用.
*/
type Person struct {
    Name  string
    Age   int
    Hobby []string
    map1  map[string]string
}
func main() {
    var p Person
    p.Name = "张三"
    p.Age = 20
    p.Hobby = make([]string, 3, 6)
    p.Hobby[0] = "写代码"
    p.Hobby[1] = "打篮球"
    p.Hobby[2] = "睡觉"
    p.map1 = make(map[string]string)
    p.map1["address"] = "北京"
    p.map1["phone"] = "1324325325"
    fmt.Printf("%#v\n", p)
    fmt.Printf("%v", p.Hobby)
}

package main
import "fmt"
/*
结构体嵌套
*/
type User struct {
    Username string
    Password string
    Address  Address //表示User结构体嵌套Address结构体
}
type Address struct {
    Name  string
    Phone string
    City  string
}
func main() {
    var u User
    u.Username = "itying"
    u.Password = "1234567"
    u.Address.Name = "张三"
    u.Address.Phone = "15201671234"
    u.Address.City = "北京"
    fmt.Printf("%#v", u) //main.User{Username:"itying", Password:"1234567", Address:main.Address{Name:"张三", Phone:"15201671234", City:"北京"}}
}

package main
import "fmt"
/*
嵌套匿名结构体
*/
type User struct {
    Username string
    Password string
    Address
}
type Address struct {
    Name  string
    Phone string
    City  string
}
func main() {
    var u User
    u.Username = "itying"
    u.Password = "1234567"
    u.Address.Name = "张三"
    u.Address.Phone = "15201671234"
    u.Address.City = "北京"
    u.City = "上海" //当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找。
    fmt.Printf("%#v\n", u) //main.User{Username:"itying", Password:"1234567", Address:main.Address{Name:"张三", Phone:"15201671234", City:"上海"}}
    fmt.Println(u.Address.Phone)
    fmt.Println(u.Phone)
}

package main
import "fmt"
/*
嵌套匿名结构体
*/
type User struct {
    Username string
    Password string
    AddTime  string
    Address
}
type Address struct {
    Name    string
    Phone   string
    City    string
    AddTime string
}
func main() {
    var u User
    u.Username = "itying"
    u.Password = "1234567"
    u.Address.Name = "张三"
    u.Address.Phone = "15201671234"
    u.Address.City = "北京"
    u.City = "上海" //当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找。
    u.AddTime = "2020-05-1"
    u.Address.AddTime = "2020-06-1"
    fmt.Printf("%#v\n", u)
}

package main
import "fmt"
/*
关于嵌套结构体的字段名冲突
*/
type User struct {
    Username string
    Password string
    Address
    Email
}
type Address struct {
    Name    string
    Phone   string
    City    string
    AddTime string
}
type Email struct {
    Account string
    AddTime string
}
func main() {
    var u User
    u.Username = "itying"
    u.Password = "1234567"
    u.Address.Name = "张三"
    u.Address.Phone = "15201671234"
    u.Address.City = "北京"
    u.City = "上海" //当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找。
    u.Address.AddTime = "2020-05-1"
    u.Email.AddTime = "2020-06-1"
    fmt.Printf("%#v\n", u)
}

package main
import "fmt"
//父亲结构体
type Animal struct {
    Name string
}
func (a Animal) run() {
    fmt.Printf("%v 在运动\n", a.Name)
}
//子结构体
type Dog struct {
    Age    int
    Animal //结构体嵌套 继承
}
func (d Dog) wang() {
    fmt.Printf("%v 在旺旺\n", d.Name)
}
func main() {
    var d = Dog{
        Age: 20,
        Animal: Animal{
            Name: "阿奇",
        },
    }
    d.run()
    d.wang()
}

package main
import "fmt"
//一个结构体中可以嵌套包含另一个结构体或结构体指针
//父亲结构体
type Animal struct {
    Name string
}
func (a Animal) run() {
    fmt.Printf("%v 在运动\n", a.Name)
}
//子结构体
type Dog struct {
    Age     int
    *Animal //结构体嵌套 继承
}
func (d Dog) wang() {
    fmt.Printf("%v 在旺旺\n", d.Name)
}
func main() {
    var d = Dog{
        Age: 20,
        Animal: &Animal{
            Name: "阿奇",
        },
    }
    d.run()
    d.wang()
}