结构体：
1、用来自定义复杂数据结构
2、struct里面可以包含多个字段（属性）
3、struct类型可以定义方法，注意和函数的区分
4、strucr类型是值类型
5、struct类型可以嵌套
6、go语言中没有class类型，只有struct类型
struct声明：
type 标识符 struct{
field1 type
field2 type
}
例子：
type Student struct{
Name string
Age int
Score int
}
struct中字段访问，和其他语言一样，使用点
例子：
var stu Student //拿结构题定义一个变量
stu.Name=”tony”
stu.Age=18
stu.Score=20
fmt.Printf(“name=%s,age=%d,score=%d”,stu.Name,stu.Age,stu.Sore)
struct定义的三种形式 初始化的三种方式
a、var stu Student
b、var stu *Student=new(Student)
c、var stu *Student=&Student{}
其中b和c返回的都是指向结构体的指针，访问形式如下：
a、stu.Name、stu.Age 和stu.Score 或者（*stu）.Name、 （*stu）.Age等
如果是指针形式可以用上面的普通的方式访问，其实就自动转化为指针访问的形式
struct内存布局
例子：
package mainimport( 'fmt')type Student struct{ Name string Age int score float32}func main(){ var stu Student stu.Name='hua' stu.Age=18 stu.score=80 fmt.Print(stu) fmt.Printf('Name:%p\n',&stu.Name) fmt.Printf('Age:%p\n',&stu.Age) fmt.Printf('score:%p\n',&stu.score)}{hua 18 80}Name:0xc04204a3a0Age:0xc04204a3b0score:0xc04204a3b8这里int32是4字节，64是8字节链表的定义：
type Student struct{
name string
next* Student
}
每个节点包含下一个节点的地址，这样把所有的节点串起来，通常把链表中的每一个节点叫做链表头
遍历到最后一个元素的时候有个特点，就是next这个指针指向的是nil，可以从这个特点来判断是否是链表结束
单链表的特点：只有一个字段指向后面的结构体
单链表只能从前往后遍历
双链表的特点：有两个字段，分别指向前面和后面的结构体
双链表可以双向遍历
链表操作：
1、生成链表及遍历链表操作
插入链表的方法：
1、尾部插入法，就在链表的尾部插入结构体代码如下：package mainimport( 'fmt')type Student struct{ Name string Age int Score float32 next *Student}func trans(p *Student){ for p!=nil { //这里p就是head结构体，所以要从第一个遍历 fmt.Println(*p) p = p.next }}func main() { var head Student head.Name = 'hua' head.Age = 18 head.Score = 80 var stu1 Student stu1.Name = 'stu1' stu1.Age = 20 stu1.Score = 100 var stu2 Student stu2.Name='stu2' stu2.Age=22 stu2.Score=90 head.next=&stu1 stu1.next=&stu2 trans(&head) }2、尾部循环插入package mainimport ( 'fmt' 'math/rand')type Student struct{ Name string Age int Score float32 next *Student}func trans(p *Student){ for p!=nil { //这里p就是head结构体，所以要从第一个遍历 fmt.Println(*p) p = p.next }}//尾部循环插入数据func trans2(tail *Student){ for i:=0;i<10;i++{ stu:=&Student{ Name:fmt.Sprintf('stu%d',i), Age:rand.Intn(100), Score:rand.Float32()*100, } //注意下面的是指针 tail.next=stu //链表是指向下一个 tail=stu //更新最后一个链表 }}func main(){ var head Student head.Name='hua' head.Age=18 head.Score=100 //下面这两个都是根据head这个链表结构体产生 trans2(&head) trans(&head)}3、头部插入1、注意给指针分配内存空间2、用指针的方式才可以分配内存，如果用变量就不行（牵扯到地址就用指针）package mainimport( 'fmt' 'math/rand')type Student struct{ Name string Age int Score float32 next *Student}func trans(p *Student){ for p!=nil{ fmt.Println(*p) p=p.next }}func main(){ //因为这是指针，所以要给指针分配空间，下面是给指针分配内存空间的两种方法 //var head *Student=&Student{} var head *Student=new(Student) head.Name='hua' head.Age=18 head.Score=100 //从头插入 for i:=0;i<10;i++{ stu:=Student{ Name:fmt.Sprintf('stu%d',i), Age:rand.Intn(100), Score:rand.Float32()*100, } //头部插入必须要传递指针才可以,首先头部插入一个，链表指向第一个，但是插入的链表地址被覆盖 stu.next=head head=&stu //指针赋值 } trans(head)}头部插入和尾部插入的区别是头部插入：需要用指针的方式来插入尾部插入：直接插入就可以了（变量形式插入）优化代码package mainimport( 'fmt' 'math/rand')type Student struct{ Name string Age int Score float32 next *Student}//打印函数func trans(p *Student){ for p!=nil{ fmt.Println(*p) p=p.next }}//这里的head是指针变量副本，这里要接受指针的指针，head1 * Student是指针变量的副本func insertHead(head1 **Student){ //从头插入 for i:=0;i<10;i++ { stu := Student{ Name: fmt.Sprintf('stu%d', i), Age: rand.Intn(100), Score: rand.Float32() * 100, } //因为参数是指针的指针，所以这里要传递指针的指针， stu.next = *head1 *head1 = &stu }}func main(){ var head *Student=new(Student) head.Name='hua' head.Age=18 head.Score=100 //因为这个函数要改变指针变量的值，所以要传递指针的地址进去 insertHead(&head) trans(head)}理解：如下：这里的insertHead中的head1是head的副本，开始head1和head是指向同一个内存地址，当head1=&stu的时候head1的地址，也就是head的副本的地址就变化了，但是head还是没有变化的。所以要改变指针的地址，也就是head的地址，这里函数必须要传递指针的指针才可以，在指针的基础之上多加一个*，func insertHead(head1 **Student){}然后传递的时候要传递指针的地址，如 insertHead(* head)小结： 要改变指针变量的值，就要传递指针的指针进去指针还有二级指针，三级指针等删除链表
删除指定节点：
思路：
1、遍历，
2、遍历当前节点的上个节点的next等于当前节点的下一个节点，这个节点就删除了
3、如果第一次没有找到，那么就往后移动位置，即当前节点的上级节点等于当前节点，当前节点的下一个节点赋值给当前节点，
4、下面这个代码是有问题的，主要是这是一个副本。头部插入会有问题
代码：
怎么在上面stu6后面插入一个节点？
思路：
1、首先生成一个节点，让这个节点的下一个节点等于stu6的下一个节点
2、再让stu6的下一个节点指向插入的这个节点
package mainimport ( 'fmt' 'math/rand')type Student struct{ Name string Age int Score float32 next *Student //指向下一个节点}func trans(p *Student) { for p!=nil{ fmt.Println(*p) p=p.next }}//头部插入func insertHead(head **Student){ //从头插入 for i:=0;i<10;i++ { stu := Student{ Name: fmt.Sprintf('stu%d', i), Age: rand.Intn(100), Score: rand.Float32() * 100, } //因为参数是指针的指针，所以这里要传递指针的指针， stu.next = *head *head = &stu }}func delNode(p * Student){ //临时变量保存上一个节点 var prev *Student=p /* 遍历链表 1、首先判断当前链表节点是否等于要删除的链表，如果是那么把当前链表节点上一个节点等于 当前链表节点的下一个节点 2、如果没有找到，那么当前链表节点就等于上个节点，当前链表节点就指向下个节点，也就是往后移动位置 */ for p!=nil{ if p.Name=='stu6'{ prev.next=p.next break } //如果没有找到，那么p就等于上个节点，p就指向下个节点 prev=p p=p.next }}//在stu5后面插入一个链表func addNode(p *Student,newNode * Student){ for p!=nil{ if p.Name=='stu5'{ newNode.next=p.next p.next=newNode break } p=p.next }}func main(){ var head *Student=new(Student) head.Name='hua' head.Age=18 head.Score=100 insertHead(&head) delNode(head) trans(head) var newNode *Student=new(Student) newNode.Name='stu1000' newNode.Age=18 newNode.Score=100 addNode(head,newNode) trans(head)}双向链表
定义 type Student struct{
Name sring
next * Student
prevn * Student
}
如果有两个指针分别指向前一个节点和后一个节点，我们叫做双链表
二叉树
定义：
type Student struct{
Name string
left * Student
right *Student
}
如果每个节点有两个指针分别用来指向左子树和右子树，我们把这样的结构叫做二叉树
对于二叉树，要用到广度优先或者深度优先的递归算法
下面是二叉树的类型图，下面的stu2的右边的孩子也可以是为nil，然后stu3如果没有孩子就叫做叶子节点，stu02是stu01的子树
代码：
下面采用递归的形式进行遍历二叉树，下面是深度优先的原理
如果要采取广度优先，那么每次遍历的时候就要把结果放到队列里面
前序遍历：是从根节点开始遍历的
结构体与方法
结构体是用户单独定义的类型，不能和其他类型进行强制转换
type Student struct{
Number int
}
type Stu Student //alias 别名 type 变量 类型 这个是定义类型的别名
var a Student
a=Student{30}
var b Stu
a=b //这样赋值错误
a=Student(b) //这样才可以
上面这两个Stu和Student是别名关系，但是这两个字段一样，并不是同一个类型，因为是type定义的
如：
package mainimport ( 'fmt')type integer intfunc main(){ //赋值给谁呢么类型，就要强制转换成什么类型 var i integer=1000 fmt.Println(i) var j int=100 //这里i是自定义的类型， j是int类型，所以赋值的时候要强制转换，如下 j=int(i) //i如果赋值给j应该强制转换为int类型 i=integer(j) //j如果想复制给i必须转换为integer类型 fmt.Println(i) fmt.Println(j)}工厂模式
golang中的struct没有构造函数，一般可以使用工厂模式来解决这个问题
Package model
type student Struct{
Name string
Age int
}
func NewStudent(name string,age int)*Student{
return &Student{ //创建实例
Name:name
Age:age
}
}
Package main
S:new(student)
S:model.NewStudent(“tony”,20)
再次强调
make用来创建map,slice ,channel
new 用来创建值类型
struct中的tag
我们可以为strct中的每一个字段，协商一个tag，这个tag可以通过反射机制获取到，最常用的场景就是json序列化和反序列化
type student struct{
Name string “this is name field” //每个字段写一个说明，作为这个字段的描述
Age int “this is age field”
}
json打包
json.Marshal()
注意：
json打包的时候，
1、必须要把结构体中的字段大写，才可以
下面是程序声明打包初始化的两种方式
匿名字段
结构体 中字段可以没有名字，叫做匿名字段
type Car struct{
Name string
Age int
}
type Train struct{
Car //匿名字段
Start time.Time //有名字段
int //匿名字段
}
匿名字段要怎么访问呢？
package mainimport ( 'fmt' 'time')type Cart struct{ name string age int}type Train struct{ Cart int strt time.Time}func main(){ var t Train //正规写法 t.Cart.name='001' t.Cart.age=11 //上面的正规写法可以缩写成下面的写法 t.name='001' t.age=11 t.int=200 fmt.Println(t)}匿名字段冲突处理
对于上面的1这里有优先原则：
缩写形式，如果有两个结构体中有相同的字段，会优先找本身的字段
对于上面的2，必须要手动的指定某个字段才可以，不然会报错
方法：
golang中的方法是作用在特定类型的变量上，因此自定义类型，都可以有方法，而不仅仅是struct
定义: func (recevier type ) methodName(参数列表)(返回值列表){}
方法的调用
type A struct{
a int
}
func (this A)test(){
fmt.Println(this.a)
}
var t A
t.test()
上面的this就是下面的t，通过上面方法中的参数this.A就能获取当前结构体中的实例
方法和函数的区别：
1）函数调用 :function(variable,参数列表)
2）‘方法 variable.function(参数列表)
指针receiver vs值receiver
本质上和函数的值传递和地址传递是一样的
方法的访问控制，通过大小写控制
继承
如果一个struct潜逃了另一个匿名结构体，那么这个结构可以直接访问匿名结构体的方法，从而实现了继承
如：
package mainimport ( 'fmt' 'time')type Cart struct{ name string age int}type Train struct{ Cart int strt time.Time age int}func main(){ var t Train //正规写法 t.Cart.name='001' t.Cart.age=11 //上面的正规写法可以缩写成下面的写法 t.name='001' t.age=11 t.int=200 fmt.Println(t)}这里的Train继承了Cart，Cart为父类，然后Train里面有Cart的所有的方法下面是方法的继承
组合和匿名函数
如果一个struct嵌套了另一个匿名结构体，那么这个结构体可以直接访问匿名结构体的方法，从而实现了继承
如果一个struct嵌套了另一个有名结构体，那么这个模式就叫做组合（一个结构体嵌套另一个结构体）
也可以说匿名字段是特殊的组合
package mainimport ( 'fmt')type Car struct{ weight int name string}func (p *Car) Run(){ fmt.Println('running')}type Train struct{ c Car}func main(){ var b Train b.c.weight=1000 b.c.name='train' b.c.Run() //running}如上就是组合多重继承
如果一个struct嵌套了多个匿名结构体，那么这个结构可以直接访问多个匿名结构体的方法，从而实现了多重继承
如果冲突的话，就需要带上结构体的名字来访问
实现String() 这是一个接口
如果一个变量实现了String()这个方法，那么fmt.Println默认会调用变量String()进行输出
go里面只要实现了接口这个方法，那么就实现了这个接口，相当于鸭子类型
联系客服
