标签：struct 18 fmt Golang main type age string name
package main
import "fmt"
// Golang中的结构体详解
type newInt int // 自定义类型
type myInt = int // 类型别名
type zsInt int
type person struct {
name string
city string
age int8
}
type PerSon struct {
name string
age int
}
// 匿名字段结构体
type PersonMan struct {
string
int
}
// 定义Address地址结构体
type Address struct {
Province string
City string
}
// 定义User用户结构体
type User struct {
Name string
Gender string
Address Address // 在这里就是结构体中嵌套了另一个结构体
}
// UserT 用户结构体中嵌套匿名结构体
type UserT struct {
Name string
Gender string
Address // 匿名结构体
}
// Animal 动物
type Animal struct {
name string
}
// Dog 狗
type Dog struct {
Age int8
*Animal // 通过嵌套匿名结构体实现继承
}
func (a *Animal) run() {
fmt.Printf("%s 会运动！ \n", a.name)
}
func (d *Dog) wang() {
fmt.Printf("%s 会汪汪汪~ \n", d.name)
}
// 值类型接收者
func (p PerSon) printInfo() {
fmt.Printf("姓名：%v 年龄：%v \n", p.name, p.age) // 姓名：小王子 年龄：25
}
// 指针类型接收者
func (p *PerSon) setInfo(name string, age int) {
p.name = name
p.age = age
}
func (m zsInt) SayHello() {
fmt.Println("Hello, 我是一个int...")
}
func main() {
/*
1.关于Golang结构体
Golang中没有"类"的概念，Golang中的结构体和其他语言中的类有点相似。和其他面向对象语言中的类相比，
Golang中的结构体具有更高的扩展性和灵活性。
Golang结构体因何而出：
Golang中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事务的全部或部分属性时，这时候再用单一的基本数据类型就无法满足
要求了，Golang中提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体，英文名struct。也就是我们可以通过struct
来定义我们自己的类型了。
2.Golang type 关键字自定义类型和类型别名
Golang中通过type关键字定义一个结构体。
2.1 type自定义类型
在Go语言中有一些基本的数据类型，如string、整型、浮点型、布尔等数据类型，Go语言中可以使用type关键字来定义自定义类型。
type myint int 这个表示将myint定义为int类型，通过type关键字的定义，myint就是一种新的类型，它具有int的特性。
2.2 定义类型别名
Golang1.9版本以后添加的新功能。类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型。就像
一个小孩小时候有大名、小明、英文名，但这些名字都指的是他本人。
type TypeAlias = Type ,我们之前见过的rune和byte就是类型别名，他们的底层定义如下：
type byte = uint8
type rune = int32
2.3 自定义类型和类型别名的区别
类型别名与自定义类型表面上看只有一个等号的差异，我们通过下面的这段代码来理解他们之间的区别。
package main
import "fmt"
// 自定义类型
type newInt int
// 类型别名
type myInt = int
func main(){
var a newInt
var b myInt
fmt.Printf("自定义类型的结果是 type of a:%T \n", a) // 自定义类型的结果是 type of a:main.newInt
fmt.Printf("类型别名的结果是 type of b:%T \n", b) // 类型别名的结果是 type of b:int
}
结果显示a的类型是main.newInt,表示main包下定义的newInt类型。b的类型是int类型。
3.结构体定义初始化的几种方法
3.1 结构体的定义
使用type和struct关键字来定义结构体，具体代码格式如下：
type 类型名 struct {
字段名 字段类型
字段名 字段类型
字段名 字段类型
..... ......
}
其中：
1.类型名：表示自定义结构体的名称，在同一个包内不能重复。
2.字段名：表示结构体字段名。结构体中的字段名必须唯一。
3.字段类型：表示结构体字段的具体类型。
举例，我们定义一个person人类的结构体，代码如下：
type person struct {
name string
city string
age int8
}
同样类型的字段也可以写在一行：
type person struct {
name, city string
age int8
}
注意：结构体首字母可以大写，也可以小写，大写表示这个结构体是公有的，在其他的包里面可以使用。小写表示这个结构体是私有的，只有这个包里面才能使用。
3.2 结构体实例化（第一种方法）
只有当结构体实例化时，才会真正的分配内存。也就是必须实例化后才能使用结构体的字段。结构体本身也是一种类型，我们可以
像声明内置类型一样使用var关键字声明结构体类型。 var 结构体实例 结构体类型，例如借用上面的结构体进行声明：var p1 person
package main
import "fmt"
type person struct {
name string
city string
age int8
}
func main() {
var p1 person
p1.name = "张三"
p1.city = "北京"
p1.age = 18
fmt.Printf("p1=%v \n", p1) // p1={张三 北京 18}
fmt.Printf("p1=%#v \n", p1) // p1=main.person{name:"张三",city:"北京",age:18}
}
3.3 结构体实例化（第二种方法）
我们可以使用new关键字对结构体进行实例化，得到的是结构体的地址。格式如下：
package main
import "fmt"
type person struct {
name string
city string
age int
}
func main() {
var p2 = new(person)
p2.name = "张三"
p2.city = "北京"
p2.age = 20
fmt.Printf("%T \n", p2) // *main.person
fmt.Printf("p2=%#v \n", p2) //p2=&main.person{name:"张三",city:"北京",age:20}
}
从打印的结果中我们可以看出p2是一个结构体指针。注意：在Golang中支持对结构体指针直接使用，来访问结构体的成员。
p2.name="张三" 其实在底层是(*p2).name="张三"
3.4 结构体实例化（第三种方法）
使用&对结构体进行取地址操作。
package main
import "fmt"
type person struct {
name string
city string
age int
}
func main() {
p3 := &person{}
fmt.Printf("%T \n", p3) // *main.person
fmt.Printf("p3=%#v \n", p3) // p3=&main.person{name:"",city:"",age:0}
p3.name = "张三"
p3.city = "北京"
p3.age = 20
// (*p3).age = 50 // 这样也是可以的
fmt.Printf("p3=%#v \n", p3) // p3=&main.person{name:"张三",city:"北京",age:20}
}
3.5 结构体实例化（第四种方法）键值对初始化
package main
import "fmt"
type person struct {
name string
city string
age int
}
func main() {
p4 := person{
name:"张三",
city:"北京",
age:18, // 要注意，最后一个属性的逗号要加上不能丢。
}
fmt.Printf("p4=%#v \n", p4) // p4=&main.person{name:"张三",city:"北京",age:18}
}
3.6 结构体实例化（第五种方法）结构体指针进行键值对初始化
package main
import "fmt"
type person struct {
name string
city string
age int
}
func main() {
p5 := &person{
name: "张三",
city: "北京",
age: 28,
}
fmt.Printf("p5=%#v \n", p5) // p5=&main.person{name:"张三",city:"北京",age:28}
}
当某些字段没有初始值的时候，这个字段可以不写。此时，没有指定初始值的字段采用类型的零值。
package main
import "fmt"
type person struct {
name string
city string
age int
}
func main() {
p6 := &person{
city: "北京",
}
fmt.Printf("p6=%#v \n", p6) // p6=&main.person{name:"",city:"北京",age:0}
}
3.7 结构体实例化（第六种方法）使用值的列表初始化
package main
import "fmt"
type person struct {
name string
city string
age int
}
func main() {
p7 := &person{
"zhangsan",
"北京",
28,
}
fmt.Printf("p7=%#v \n", p7) // p7=&main.person{name:"zhangsan",city:"北京",age:28}
}
!!! 使用这种格式初始化时，需要注意：
1. 必须初始化结构体的所有字段。
2. 初始值的填充顺序必须和字段在结构体中的声明顺序一致。
3. 该方式不能和键值初始化方式混用。
4.结构体方法和接收者
在Go语言中，没有类的概念但是可以给类型（结构体，自定义类型）定义方法。所谓方法就是定义了接收者的函数。
接收者的概念就类似于Python语言中的self。
方法的定义格式如下：
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
函数体
}
其中：
1.接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名的第一个小写字母，而不是self、this之类的命名。
例如，Person类型的接收者变量应该命名为小写字母p,Connector类型的接收者变量应该命名为c等。总之接收者变量就是用小写字母。
2.接收者类型：接收者类型和参数类似，可以时指针类型和非指针类型。
3.方法名、参数列表、返回参数：具体格式与函数定义相同。
实例1: 给结构体Person定义一个方法打印Person的信息
package main
import "fmt"
type PerSon struct {
name string
age int8
}
// 值类型接收者
func (p PerSon) printInfo() {
fmt.Printf("姓名：%v 年龄：%v \n", p.name, p.age)
}
func main() {
p1 := PerSon{
name: "小王子",
age: 25,
}
p1.printInfo()
}
4.1 值类型的接收者-------> 就是传入的参数类型前面没有*符号
当方法作用域值类型接收者时，Go语言会在代码运行时将接收者的值复制一份。在值类型接收者的方法中可以获取接收者的成员值，
但修改操作只是针对副本，无法修改接收者变量本身。
4.2 指针类型的接收者--------> 就是传入的参数在类型前面会加上*符号
指针类型的接收者由一个结构体的指针组成，由于指针的特性，调用方法时修改接收者指针的任意成员变量，在方法结束后，修改都是有效的。
这种方式就十分接近于其他语言中面向对象中的this或者self。
下面写一下值类型和指针类型接收的示例：
package main
import "fmt"
type Person struct {
name string
age int
}
// 下面定义一个printInfo方法和一个setInfo方法并绑定给结构体Person.
// 值类型接收者
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() {
p1 := Person{
name: "小王子",
age: 25,
}
p1.printInfo()
p1.setInfo("张三", 20)
p1.printInfo()
}
// 上面的运行结果是：
值类型接收者和指针类型接收者运行结果：
姓名：小王子 年龄：25
姓名：张三 年龄：20
5.给任意类型添加方法
在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。举个例子：
我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。
package main
import "fmt"
type zsInt int
func (m zsInt) SayHello() {
fmt.Println("Hello, 我是一个int...")
}
func main() {
var m1 zsInt
m1.SayHello() // Hello, 我是一个int...
m1 = 100
fmt.Printf("%#v %T \n", m1, m1) // 100 main.zsInt
}
注意事项：非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。
6.结构体的匿名字段
结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。
type PersonMan struct {
string
int
}
func main() {
p1 := PersonMan{
"小王子",
18,
}
fmt.Printf("%#v \n", p1) // main.PersonMan{string:"北京", int:18} ------>>>> 匿名字段默认采用类型名作为字段名
fmt.Println(p1.string, p1.int) // 北京 18
}
匿名字段默认采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。
简而言之就是每种类型只能出现一次，不能重复。
7.嵌套结构体
一个结构体中可以嵌套包含另一个结构体或结构体指针。
package main
import "fmt"
// 定义Address地址结构体
type Address struct {
Province string
City string
}
// 定义User用户结构体
type User struct {
Name string
Gender string
Address Address // 在这里就是结构体中嵌套了另一个结构体
}
func main() {
user1 := User{
Name:"张三",
Gender:"男",
Address:Address{
Province:"广东",
City:"深圳",
},
}
fmt.Printf("user1=%#v \n", user1)
// 结果是：user1=main.User{Name:"张三",Gender:"男",Address:main.Address{Province:"广东",City:"深圳"}}
}
8.嵌套匿名结构体
package main
import "fmt"
// Address 地址结构体
type Address struct{
Province string
City string
}
// User 用户结构体
type User struct{
Name string
Gender string
Address // 匿名结构体
}
func main() {
var user2 UserT
user2.Name = "张三"
user2.Gender = "男"
user2.Address.Province = "广东" // 通过匿名结构体.字段名访问
user2.City = "深圳" // 直接访问匿名结构体的字段名
fmt.Printf("user2=%#v \n", user2)
// 结果是：user2=main.UserT{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}}
}
【注意】：当访问结构体成员时会先在结构体中查找该字段，找不到再去匿名结构体中查找。这就是为什么可以用User2.City = "深圳" 不报错的原因。
9.关于嵌套结构体的字段名冲突
嵌套结构体内部可能存在相同的字段名。这个时候为了避免歧义需要指定具体的内嵌结构体字段。
package main
import "fmt"
// Address 地址结构体
type Address struct {
Province string
City string
CreateTime string
}
// Email 邮箱结构体
type Email struct {
Account string
CreateTime string
}
// User用户结构体
type User struct {
Name string
Gender string
Address
Email
}
func main() {
var user3 User
user3.Name = "张三"
user3.Gender = "男"
//user3.CreateTime = "2020" // 这样是错误的，嵌套结构体内部有相同的字段，需要指名道姓用点的方式
user3.Address.CreateTime = "2020" // 指定Address结构体中的CreateTime
user3.Email.CreateTime = "2021" // 指定Email结构体中的CreateTime
}
10.结构体的继承
Go 语言中使用结构体也可以实现其他编程语言中的继承。
package main
import "fmt"
// Animal 动物
type Animal struct {
name string
}
func(a *Animal) run() {
fmt.Printf("%s 会运动！ \n", a.name)
}
// Dog 狗
type Dog struct {
Age int8
*Animal // 通过嵌套匿名结构体实现继承
}
func(d *Dog) wang() {
fmt.Printf("%s 会汪汪汪~ \n", d.name)
}
func main() {
d1 := &Dog{
Age:4,
Animal:&Animal{ // 注意嵌套的是结构体指针
name:"阿奇",
},
}
d1.wang() // 阿奇会汪汪汪~
d1.run() // 阿奇会运动！
}
*/
// 自定义类型 和 类型别名的打印结果
var a newInt
var b myInt
fmt.Printf("自定义类型的结果是 type of a:%T \n", a) // 自定义类型的结果是 type of a:main.newInt
fmt.Printf("类型别名的结果是 type of b:%T \n", b) // 类型别名的结果是 type of b:int
// 结构体实例化方法1
var p1 person
p1.name = "张三"
p1.city = "北京"
p1.age = 18
fmt.Printf("p1=%v \n", p1) // p1={张三 北京 18}
fmt.Printf("p1=%#v \n", p1) // p1=main.person{name:"张三",city:"北京",age:18}
// 结构体实例化方法2
var p2 = new(person)
p2.name = "张三"
p2.city = "北京"
p2.age = 20
fmt.Printf("%T \n", p2) // *main.person
fmt.Printf("p2=%#v \n", p2) //p2=&main.person{name:"张三",city:"北京",age:20}
// 结构体实例化方法3
p3 := &person{}
fmt.Printf("%T \n", p3) // *main.person
fmt.Printf("p3=%#v \n", p3) // p3=&main.person{name:"",city:"",age:0}
p3.name = "张三"
p3.city = "北京"
p3.age = 20
// (*p3).age = 50 // 这样也是可以的
fmt.Printf("p3=%#v \n", p3) // p3=&main.person{name:"张三",city:"北京",age:20}
// 打印结构体的信息
pp := PerSon{
name: "小王子",
age: 25,
}
pp.printInfo() // 姓名：小王子 年龄：25
// 值类型接收者和指针类型接收者
fmt.Println("值类型接收者和指针类型接收者运行结果：")
p2p := PerSon{
name: "小王子",
age: 25,
}
p2p.printInfo()
p2p.setInfo("张三", 20)
p2p.printInfo()
/* // 上面的运行结果是：
值类型接收者和指针类型接收者运行结果：
姓名：小王子 年龄：25
姓名：张三 年龄：20
*/
// 给任意类型添加个方法
println()
var m1 zsInt
m1.SayHello() // Hello, 我是一个int...
m1 = 100
fmt.Printf("%#v %T \n", m1, m1) // 100 main.zsInt
// 匿名字段结构体
println()
pm := PersonMan{
"小王子",
18,
}
fmt.Printf("%#v \n", pm) // main.PersonMan{string:"小王子", int:18}
fmt.Println(pm.string, pm.int) // 小王子 18
// 嵌套结构体
println()
user1 := User{
Name: "张三",
Gender: "男",
Address: Address{
Province: "广东",
City: "深圳",
},
}
fmt.Printf("user1=%#v \n", user1)
// 结果是：user1=main.User{Name:"张三",Gender:"男",Address:main.Address{Province:"广东",City:"深圳"}}
// 嵌套匿名结构体
println()
var user2 UserT
user2.Name = "张三"
user2.Gender = "男"
user2.Address.Province = "广东" // 通过匿名结构体.字段名访问
user2.City = "深圳" // 直接访问匿名结构体的字段名
fmt.Printf("user2=%#v \n", user2)
// 结果是：user2=main.UserT{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}}
// 关于结构体的继承
println()
d1 := &Dog{
Age: 4,
Animal: &Animal{ // 注意嵌套的是结构体指针
name: "阿奇",
},
}
d1.wang() // 阿奇会汪汪汪~
d1.run() // 阿奇会运动！
// 发现这个用法和Python中类的继承用法是一样的，继承父类的方法和属性都可以通过点的方式去调用。
/* 以上代码的全部执行结果如下：
自定义类型的结果是 type of a:main.newInt
类型别名的结果是 type of b:int
p1={张三 北京 18}
p1=main.person{name:"张三", city:"北京", age:18}
*main.person
p2=&main.person{name:"张三", city:"北京", age:20}
*main.person
小王子 18
user1=main.User{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}}
user2=main.UserT{Name:"张三", Gender:"男", Address:main.Address{Province:"广东", City:"深圳"}}
阿奇 会汪汪汪~
阿奇 会运动！
*/
}
标签：struct,
18,
fmt,
Golang,
main,
type,
age,
string,
name
From： https://www.cnblogs.com/ludundun/p/16998752.html