go之结构体

什么是结构体

　　结构体是用户定义的类型，表示若干个字段的集合，有时应该把数据整合一起，而不是让这些数据没有联系，这种情况下可以使用结构体

语法

// 结构体
//type关键字  结构体名字  struct{
// 字段1 字段类型
// 字段2 字段类型
//}

结构体定义

type Person struct {  // 如果小写，在其他包使用不到Person结构体
	Name string  // 字段大写，表示导出，如果小写，表示隐藏，在其他包中取不到
	age uint8
	Sex string
}

使用结构体

　　结构体是值类型，有默认零值，如果当函数参数传递，在函数中修改，不会影响原来的

package main

import "fmt"

type Person struct { // 如果小写，在其他包使用不到Person结构体
	Name string // 字段大写，表示导出，如果小写，表示隐藏，在其他包中取不到
	age  uint8
	Sex  string
}

func main() {
	var p Person       // 没有初始化,有零值，零值是每个字段的零值
	fmt.Println(p.age) //0  有默认零值，字段的零值
	fmt.Println(p)     //{ 0 }
}

定义并初始化

　　按位置初始化

　　按照顺序，有几个字段，必须传几个字段

package main

import "fmt"

type Person struct { // 如果小写，在其他包使用不到Person结构体
	Name string // 字段大写，表示导出，如果小写，表示隐藏，在其他包中取不到
	age  uint8
	Sex  string
}

func main() {
	var p Person=Person{"zys",18,"男"}
	fmt.Println(p)  //{zys 18 男}
}

　　按关键字初始化

　　不用按顺序，字段不用都传

package main

import "fmt"

type Person struct { // 如果小写，在其他包使用不到Person结构体
	Name string // 字段大写，表示导出，如果小写，表示隐藏，在其他包中取不到
	age  uint8
	Sex  string
}

func main() {
	var p Person=Person{Sex:"男",age:19}
	fmt.Println(p)  //{ 19 男}
}

字段的取值赋值

　　通过.

package main

import "fmt"

type Person struct { // 如果小写，在其他包使用不到Person结构体
	Name string // 字段大写，表示导出，如果小写，表示隐藏，在其他包中取不到
	age  uint8
	Sex  string
}

func main() {
	var p Person=Person{Sex:"男",age:19}
	fmt.Println(p)  //{ 19 男}
	fmt.Println(p.Name)
	p.Name="xx"
	fmt.Println(p.Name)  //xx
}

结构体零值

　　不初始化有默认零值，零值是各个字段的零值

package main

import "fmt"

type Person struct { // 如果小写，在其他包使用不到Person结构体
	Name string // 字段大写，表示导出，如果小写，表示隐藏，在其他包中取不到
	age  uint8
	Sex  string
}

func main() {
	var p Person
	fmt.Println(p)  //{ 0 }
}

匿名结构体

　　结构体没有名字和type关键字，一般定义在函数内部，只使用一次

　　好处是：多个变量可以包装到一个变量中

func main() {
	a:= struct {
	age int
	name string
	}{19,"彭于晏"}
	fmt.Println(a.name)
	fmt.Println(a.age)
	fmt.Println(a)
}

结构体指针

　　还可以创建只想结构体的指针

package main

import (  
    "fmt"
)

type Employee struct {  
    firstName, lastName string
    age, salary         int
}

func main() {  
    emp8 := &Employee{"Sam", "Anderson", 55, 6000}
    fmt.Println("First Name:", (*emp8).firstName)
    fmt.Println("Age:", (*emp8).age)
}

　　在上面程序中，emp8 是一个指向结构体 Employee 的指针。(*emp8).firstName 表示访问结构体 emp8 的 firstName 字段。该程序会输出

First Name: Sam
Age: 55

　　Go 语言允许我们在访问 firstName 字段时，可以使用 emp8.firstName 来代替显式的解引用 (*emp8).firstName。

package main

import (  
    "fmt"
)

type Employee struct {  
    firstName, lastName string
    age, salary         int
}

func main() {  
    emp8 := &Employee{"Sam", "Anderson", 55, 6000}
    fmt.Println("First Name:", emp8.firstName)
    fmt.Println("Age:", emp8.age)
}

　　在上面的程序中，我们使用 emp8.firstName 来访问 firstName 字段，该程序会输出：

First Name: Sam
Age: 55

结构体当函数参数传递

package main

import "fmt"

type Person struct { // 如果小写，在其他包使用不到Person结构体
	Name string // 字段大写，表示导出，如果小写，表示隐藏，在其他包中取不到
	age  uint8
	Sex  string
}

func main() {
	var p =Person{"zys",18,"男"}
	test5(p)
	fmt.Println("----",p)  // p 不受影响  ---- {zys 18 男}
}
func test5(p Person)  {
	fmt.Println(p)  //{zys 18 男}
	p.Name="lyf"
	fmt.Println(p)  //{lyf 18 男}

}

结构体指针当函数参数传递

package main

import "fmt"

type Person struct { // 如果小写，在其他包使用不到Person结构体
	Name string // 字段大写，表示导出，如果小写，表示隐藏，在其他包中取不到
	age  uint8
	Sex  string
}

func main() {
	var p = &Person{"zys", 18, "男"}
	test6(p)               //指针传入，地址copy传入，改了就影响原来
	fmt.Println("----", p) // p 受影响  ---- &{lyf 18 男}
}
func test6(p *Person) {
	fmt.Println(p) //&{zys 18 男}
	p.Name = "lyf"
	//(*p).Name="lyf"
	fmt.Println(p) //&{lyf 18 男}

}

匿名字段

　　字段没有名字，跟结构体是否匿名没有必然联系

　　作用：可以做字段提升，实现面向对象的继承

package main

import "fmt"

type Animal struct {
	string // 字段没有名字，但是不能出现两个同种类型的字段 ,字段名就是类型名
	int
}

func main() {
	//var a =Animal{"小鸭子",1}
	var a = Animal{string: "小鸭子", int: 1}
	fmt.Println(a) //{小鸭子 1}
}

结构体嵌套

　　结构体中套结构体

package main

import "fmt"

func main() {
	type Animal struct {
		Name string
		age  int
	}
	type Dog struct {
		//Name string
		//age int
		// 简写成--->结构体嵌套
		//animal Animal
		Animal //匿名字段，Animal字段匿名了，字段名就是类型名，而且不用写name和age了
		//Dog比Animal多的字段
		Speak bool
	}
	//var dog =Dog{Animal{"二哈",3},true}
	var dog = Dog{Animal: Animal{"二哈", 3}, Speak: true}
	//面向对象继承，1 少写代码  2 子类对象.属性 如果子类没有，直接使用父类的
	fmt.Println(dog.Name) //二哈  dog的name本来是Animal的，使用了匿名字段，字段提升了
	//如果Animal不是匿名字段，不能提升
	fmt.Println(dog.Animal.Name) //二哈  指名道姓用   dog.Animal 相当于 super()
	//Dog中有Name,Animal 用了匿名字段，Name冲突了，会优先使用Dog自己的
}

导出结构体和字段

package main

import (
	"day01/entity"
	"fmt"
)

type Person struct { // 如果小写，在其他包使用不到Person结构体
	Name string // 字段大写，表示导出，如果小写，表示隐藏，在其他包中取不到
	age  uint8
	Sex  string
}

func main() {
	//var p =entity.Person{"lyf",37}  // age 小写，外包包不能用
	var p =entity.Person{Name:"lyf"}
	fmt.Println(p)  //{lyf 0}
}

　　entity包

package entity


type Person struct {  // 大写开头，外包才可以用
	Name string
	age int

}

结构体是值类型

package main

import (
	"fmt"
)

type Person struct { // 如果小写，在其他包使用不到Person结构体
	Name string // 字段大写，表示导出，如果小写，表示隐藏，在其他包中取不到
	age  uint8
	Sex  string
}

func main() {
	//如果它的每一个字段都是可比较的，则该结构体也是可比较的。
	//如果两个结构体变量的对应字段相等，则这两个变量也是相等的
	var p1=Person{"zys",19,"男"}
	var p2=Person{Name: "zys",age: 19,Sex: "男"}
	p2.age=20
	if p1==p2{
		fmt.Println("p1 和p2 相等")
	}else{
		fmt.Println(1)  //1
	}

	//如果结构体包含不可比较的字段(有引用类型)，则结构体变量也不可比较
	//type Cat struct {
	//Name string
	//age int
	//wife []string  // 可以有很多异性猫
	//}
	//var c1 =Cat{"小野豹",3,[]string{"女朋友1号","女朋友2号"}}
	//var c2 =Cat{"小野豹",3,[]string{"女朋友1号","女朋友2号"}}
	//if c1==c2{
	//
	//}
}