今日概要:
1. 结构体和方法
2. 接口
一、go中的struct
1. 用来自定义复杂数据结构
2. struct里面可以包含多个字段（属性）
3. struct类型可以定义方法，注意和函数的区分
4. struct类型是值类型
5. struct类型可以嵌套
6. Go语言没有class类型，只有struct类型
1.struct声明
type 标识符 struct {
field1 type
field2 type
}
例子：
type Student struct {
Name string
Age int
Score int
}
2. 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.Score
3. struct定义的三种形式
//第一种
var stu Student
//第二种
var stu *Student = new (Student)
//第三种
var stu *Student = &Student{}
其中b和c返回的都是指向结构体的指针，访问形式如下：
stu.Name、stu.Age和stu.Score或者 (*stu).Name、(*stu).Age
4. struct的内存布局：struct中的所有字段在内存是连续的
struct当传入的为值的时候,传入值对应的内存地址是连续的,当传入指针的时候,指针对应的内存地址是连续的,指针原数据对应的地址是不连续的.
例子：
package main
import (
"fmt"
)
//结构体所有字段的内存布局都是连续的
type Student struct {
name string
age int //int占用8字节
score float32
}
func main() {
var stu Student
stu.age = 18
stu.name = "alex"
stu.score = 100
fmt.Printf("name:%s,age:%d,score:%d
",stu.name,stu.age,stu.score)
//在内存中的布局
fmt.Printf("Name:%p
",&stu.name)
fmt.Printf("Age:%p
",&stu.age)
fmt.Printf("Score:%p
",&stu.score)
// 初始化,可以初始化部分字段
var stu1 *Student = &Student{
name:"xiaogang",
age:29,
score:1000,
}
fmt.Println(stu1)
var stu2 = Student{
name:"test",
age:111,
}
fmt.Println(stu2)
var stu3 *Student = new(Student)//创建了个内存地址
fmt.Println(stu3)
}
5.链表定义
type Student struct {
Name string
Next* Student
}
每个节点包含下一个节点的地址，这样把所有的节点串起来了，通常把链表中的第一个节点叫做链表头
package main
import "fmt"
type Student struct {
Name string
Age int
Score int
next *Student
}
//函数化,循环链表
func trans (p *Student){
for p != nil {
fmt.Println(*p)
p = p.next
}
fmt.Println()
}
func main() {
var head Student
head.Name = "alex"
head.Age = 18
head.Score = 100
var stu2 Student
stu2.Name = "xiaogang"
head.next = &stu2
trans(&head)
var stu3 Student
stu3.Name = "xiaoming"
stu2.next = &stu3
trans(&head)
//p := &head // var p *Student = &head
}
链表头部插入:
package main
import (
"fmt"
"math/rand"
)
type Student struct {
Name string
Age int
Score float32
up *Student
}
//函数化
func trans (p *Student){
for p != nil {
fmt.Println(*p)
p = p.up
}
fmt.Println()
}
func HeadChain(head **Student){
for i :=0 ; i < 11; i ++ {
var stu = Student{
Name:fmt.Sprintf("student%d",i),
Age:rand.Intn(100),
Score:rand.Float32() * 100,
}
stu.up = *head
*head = &stu //head相当于副本
}
}
func DelNode(node *Student){
//删除节点
var prev_node *Student = node //临时变量保留上一个节点
for node != nil{
if (node.Name == "student6"){
prev_node.up = node.up //被删除节点上一个节点的的up 指向被删除节点的up
break
}
prev_node = node //prev是node的上一个节点
node = node.up
}
}
func AddNode(node *Student,new_node *Student){
//插入节点
for node != nil{
if (node.Name == "student6"){
new_node.up = node.up
node.up = new_node
break
}
node = node.up
}
}
func main() {
//生成链表表头
var head *Student = new(Student) //head是指针 //改变一个变量的地址,传变量的变量的内存地址,要是改变一个指针的地址,将指针的内存地址传入进去
head.Name = "alex"
head.Age = 18
head.Score = 100
//链表头部插入法
HeadChain(&head) //传入指针的内存地址
trans(head)
//DelNode(head)
//trans(head)
var newNode *Student = new(Student)
newNode.Name = "xiaogang"
newNode.Age = 20
newNode.Score = 300
AddNode(head,newNode)
trans(head)
//p := &head // var p *Student = &head
}
/*
{student10 95 36.08714 0xc420072390}
{student9 37 21.855305 0xc420072360}
{student8 11 29.310184 0xc420072330}
{student7 28 46.888985 0xc420072300}
{student6 62 38.06572 0xc4200722d0}
{student5 94 81.36399 0xc4200722a0}
{student4 56 30.091187 0xc420072270}
{student3 25 15.651925 0xc420072240}
{student2 81 68.682304 0xc420072210}
{student1 47 43.77142 0xc4200721e0}
{student0 81 94.05091 0xc4200721b0}
{alex 18 100 <nil>}
{student10 95 36.08714 0xc420072390}
{student9 37 21.855305 0xc420072360}
{student8 11 29.310184 0xc420072330}
{student7 28 46.888985 0xc420072300}
{student6 62 38.06572 0xc420072630}
{xiaogang 20 300 0xc4200722d0}
{student5 94 81.36399 0xc4200722a0}
{student4 56 30.091187 0xc420072270}
{student3 25 15.651925 0xc420072240}
{student2 81 68.682304 0xc420072210}
{student1 47 43.77142 0xc4200721e0}
{student0 81 94.05091 0xc4200721b0}
{alex 18 100 <nil>}
*/
图解链表插入过程
链表从尾部插入:
package main
import (
"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
}
fmt.Println()
}
func tailInsertChain(p *Student){
for i := 0 ; i < 11 ; i++ {
var stu = Student{
Name:fmt.Sprintf("student%d",i),
Age:rand.Intn(100),
Score:rand.Float32() * 100,
}
p.next = &stu
p = &stu
}
}
func main() {
//生成链表表头
var head Student
head.Name = "alex"
head.Age = 18
head.Score = 100
//链表尾部插入法
tailInsertChain(&head)
trans(&head)
//p := &head // var p *Student = &head
}
/*
{alex 18 100 0xc4200721b0}
{student0 81 94.05091 0xc4200721e0}
{student1 47 43.77142 0xc420072210}
{student2 81 68.682304 0xc420072240}
{student3 25 15.651925 0xc420072270}
{student4 56 30.091187 0xc4200722a0}
{student5 94 81.36399 0xc4200722d0}
{student6 62 38.06572 0xc420072300}
{student7 28 46.888985 0xc420072330}
{student8 11 29.310184 0xc420072360}
{student9 37 21.855305 0xc420072390}
{student10 95 36.08714 <nil>}
*/
6.双链表定义
如果有两个指针分别指向前一个节点和后一个节点，我们叫做双链表
例子: 二叉树(通过递归实现)
如果每个节点有两个指针分别用来指向左子树和右子树，我们把这样的结构叫做二叉树
package main
import "fmt"
type Student struct {
Name string
Age int
Score float32
left *Student
right *Student
}
func trans(p *Student){
if (p == nil){ //如果为空就终止
return
}
//前序遍历
//fmt.Println(p)
//trans(p.left)
//trans(p.right)
//中序遍历
//trans(p.left)
//fmt.Println(p)
//trans(p.right)
//后续遍历
trans(p.left)
trans(p.right)
fmt.Println(p)
}
func main() {
var root *Student = &Student{
Name:"alex",
Age:18,
Score:100,
}
var left *Student = &Student{
Name:"alex_left",
Age:19,
Score:200,
}
var left1 *Student = &Student{
Name:"alex_left1",
Age:19,
Score:200,
}
var right *Student = &Student{
Name:"alex_right",
Age:19,
Score:200,
}
var right1 *Student = &Student{
Name:"alex_right1",
Age:19,
Score:200,
}
root.left = left
root.right = right
left.left = left1
right.right = right1
trans(root)
}
/*
&{alex_left1 19 200 <nil> <nil>}
&{alex_left 19 200 0xc4200721e0 <nil>}
&{alex_right1 19 200 <nil> <nil>}
&{alex_right 19 200 <nil> 0xc420072240}
&{alex 18 100 0xc4200721b0 0xc420072210}
*/
7.结构体是用户单独定义的类型，不能和其他类型进行强制转换
type Student struct {
Number int
}
type Stu Student //alias
var a Student
a = Student(30)
var b Stu
a = b
//错误示范
8.golang中的struct没有构造函数，一般可以使用工厂模式来解决这个问题
类似于python的__init__构造方法
package main
import "fmt"
//go中没构造函数,可以通过工厂函数实现
type Student struct {
Name string
Age int
}
func NewStudent(name string,age int) *Student{
res := new(Student)
res.Name = name
res.Age = age
return res
//return &Student{Name:name,Age:age}
}
func main() {
S := NewStudent("alex",18)
fmt.Println(S.Name,S.Age)
}
****前方高能:
- make 用来创建map、slice、channel(引用类型)
- new用来创建值类型
例子：
我们可以为struct中的每个字段，写上一个tag。这个tag可以通过反射的机制获取到，最常用的场景就是json序列化和反序列化
package main
import (
"fmt"
"encoding/json"
)
//结构体Student必须大写,不然json包无法使用结构体里的字段
type Student struct {
Name string `json:"name"`
Age int `json:"age"`
Score int `json:"score"`
}
func main() {
var stu1 Student
stu1.Name = "alex"
stu1.Age = 18
stu1.Score = 200
data, err := json.Marshal(stu1) //默认json序列化为byte数组
if err != nil{
fmt.Println("json error",err)
return
}
fmt.Println(string(data))
}
/*
{"name":"alex","age":18,"score":200}
*/
9.结构体中字段可以没有名字，即匿名字段
package main
import "fmt"
type Human struct {
name string
age int
weight int
}
//匿名字段类似python里的继承
type Student struct {
Human // 匿名字段，那么默认Student就包含了Human的所有字段
speciality string
}
func main() {
//初始化一个学生
mark := Student{Human{"alex",18,180},"python"}
fmt.Println(mark)
//打印
fmt.Println("His name is ", mark.name)
fmt.Println("His age is ", mark.age)
fmt.Println("His weight is ", mark.weight)
fmt.Println("His speciality is ", mark.speciality)
//修改这个学生的爱好
mark.speciality = "golang"
fmt.Println(mark)
mark.age += 2
fmt.Println(mark)
mark.Human = Human{"dragon",33,190} //student可以.Human 直接修改
fmt.Println(mark)
}
/*
我们看到Student访问属性age和name的时候，就像访问自己所有用的字段一样，对，匿名字段就是这样，能够实现字段的继承。是不是很酷啊？
还有比这个更酷的呢，那就是student还能访问Human这个字段作为字段名。请看下面的代码，是不是更酷了。
*/
匿名字段和自定义字段
package main
import "fmt"
//通过匿名访问和修改字段相当的有用，但是不仅仅是struct字段哦，所有的内置类型和自定义类型都是可以作为匿名字段的
type Skills []string
type Human struct {
name string
age int
weight int
}
type Student struct {
Human // 匿名字段，struct
Skills // 匿名字段，自定义的类型string slice
int // 内置类型作为匿名字段
speciality string
}
func main() {
// 初始化学生Jane
jane := Student{Human:Human{"Jane", 35, 100}, speciality:"Biology"}
// 现在我们来访问相应的字段
fmt.Println("Her name is ", jane.name)
fmt.Println("Her age is ", jane.age)
fmt.Println("Her weight is ", jane.weight)
fmt.Println("Her speciality is ", jane.speciality)
// 我们来修改他的skill技能字段
jane.Skills = []string{"anatomy"} //传一个切片进去
fmt.Println("Her skills are ", jane.Skills)
fmt.Println("She acquired two new ones ")
jane.Skills = append(jane.Skills, "physics", "golang")
fmt.Println("Her skills now are ", jane.Skills)
// 修改匿名内置类型字段
jane.int = 3
fmt.Println("Her preferred number is", jane.int)
}
/*
Her name is Jane
Her age is 35
Her weight is 100
Her speciality is Biology
Her skills are [anatomy]
She acquired two new ones
Her skills now are [anatomy physics golang]
Her preferred number is 3
*/
匿名字段冲突问题:
package main
import "fmt"
type Cart1 struct {
name string
age int
}
type Cart2 struct {
name string
}
type Train struct {
Cart1
Cart2
}
func main() {
//cart1,cart2都包含name字段,需要精确选择
var tra1 Train
tra1.Cart1.name = "alex"
fmt.Println(tra1)
}
10.Go中的方法是作用在特定类型的变量上，因此自定义类型，都可以有方法，而不仅仅是struct
定义：func (recevier type) methodName(参数列表)(返回值列表){}
package main
import "fmt"
type interger int
func (p interger) print(){
fmt.Println("number is ",p)
}
func (p *interger) set(b interger){
*p = b
}
type Student struct {
name string
age int
}
func (self *Student) init(name string,age int){
self.name = name
self.age = age
fmt.Println(self)
}
func (self Student) get() Student{
return self
}
func main() {
var stu1 Student
//go中自动变成指针,当赋值或者初始化的时候
stu1.init("alex",18)
res := stu1.get()
fmt.Println(res)
var myint interger
myint = 100
myint.print()
myint.set(1000)
myint.print()
}
/*
&{alex 18}
{alex 18}
number is 100
number is 1000
*/
方法和函数的区别:
- 函数调用： function(variable, 参数列表）
- 方法：variable.function(参数列表）
指针receiver vs 值receiver的区别
本质上和函数的值传递和地址传递是一样的
方法的访问控制，通过大小写控制
11.struct继承和组合
如果一个struct嵌套了另一个匿名结构体，那么这个结构可以直接访问匿名结构体的方法，从而实现了继承。
如果一个struct嵌套了另一个有名结构体，那么这个模式就叫组合。
例子：
如果一个变量实现了String()这个方法，那么fmt.Printf默认会调用这个变量的String()进行输出。
package main
import "fmt"
type Cart struct {
weight int
length int
}
func (p *Cart) run(speed int) {
fmt.Println("running speed is ",speed)
}
//struct实现String,类调用方法都时候将变量转为指针,通过接口实现不会
func (p *Cart) String() string{
str := fmt.Sprintf("[%d]-[%d]",p.length,p.weight)
return str
}
type Bike struct {
Cart
speed int
}
//组合
type Train struct {
c Cart
}
func main() {
var a Bike
a.speed = 100
a.weight = 200
a.length = 20000
fmt.Println(a)
a.run(100)
var b Train
//带着组合的别名
b.c.run(1000)
//触发了String的方法
fmt.Printf("%s",&a)
}
/*
{{200 20000} 100}
running speed is 100
running speed is 1000
[20000]-[200]
*/
多重继承
如果一个struct嵌套了多个匿名结构体，那么这个结构可以直接访问多个匿名结构体的方法，从而实现了多重继承。
多个匿名结构体含有相同字段,需要 变量.结构体.字段 精确指向
12.interface接口
Interface类型可以定义一组方法，但是这些不需要实现。并且interface不能包含任何变量。
interface类型默认是一个指针
接口实现：
Golang中的接口，不需要显示的实现。只要一个变量，含有接口类型中的所有方法，那么这个变量就实现这个接口。因此，golang中没有implement类似的关键字
如果一个变量含有了多个interface类型的方法，那么这个变量就实现了多个接口。
如果一个变量只含有了1个interface的方部分方法，那么这个变量没有实现这个接口。
package main
import "fmt"
//接口是方法都集合,不能设置变量 用途类似于python的抽象类
type Test interface {
print()
}
type Cart struct {
name string
speed int
}
//cart实现了print方法,可以通过接口直接调用
func (self *Cart) print() {
fmt.Println(self.speed)
fmt.Println(self.name)
}
func main() {
var t Test //接口是一个地址
var a Cart = Cart{
name:"baoshijie",
speed:100,
}
t = &a //接口代表了具体都类型
t.print()
}
/*
100
baoshijie
*/
接口嵌套
一个接口可以嵌套在另外的接口
type ReadWrite interface {
Read(b Buffer) bool
Write(b Buffer) bool
}
type Lock interface {
Lock()
Unlock()
}
type File interface {
ReadWrite
Lock
Close()
}
类型断言，由于接口是一般类型，不知道具体类型，如果要转成具体类型
var t int
var x interface{}
x = t
y = x.(int) //转成int
var t int
var x interface{}
x = t
y, ok = x.(int) //转成int，带检查
练习：传入参数判断类型
func classifier(items ...interface{}) {
for i, x := range items {
switch x.(type) {
case bool: fmt.Printf(“param #%d is a bool
”, i)
case float64: fmt.Printf(“param #%d is a float64
”, i)
case int, int64: fmt.Printf(“param #%d is an int
”, i)
case nil: fmt.Printf(“param #%d is nil
”, i)
case string: fmt.Printf(“param #%d is a string
”, i)
default: fmt.Printf(“param #%d’s type is unknown
”, i)
}
}
空接口，interface{}
空接口没有任何方法，所以所有类型都实现了空接口。
var a int
var b interface{}
b = a