资源来自：https://blog.csdn.net/DXB2021/article/details/122652779
结体体定义如下：
type author struct{
field1 type1
field2 type2
...
}
结构体的定义格式如下：
type 类型名 struct{
字段1 字段1类型
字段2 字段2类型
……
}
基本实例化格式如下：
var ins T
T为结构体类型。
ins为结构体的实例。
创建指针类型的结构体：
使用new的格式如下：
ins:=new(T)
T为类型，可以是结构体、整型、字符串等。
ins：T类型被实例化后保存到ins变量中，ins的类型为*T，属于指针。
代码如下：
package main
type Player struct {
Name string
HealthPoint int
MagicPoint int
}
func main() {
tank := new(Player)
tank.Name = "Canon"
tank.HealthPoint = 300
}
取结构体的地址实例化：
取地址格式如下：
ins := &T{}
T表示结构体类型。
ins为结构体的实例，类型为*T，是指针类型。
声明并创建一个简单的结构体，程序清单如下：
package main
import(
"fmt"
)
type Movie struct{ //结构体
Name string
Rating float32
}
func main(){
m:=Movie{
Name:"Citizen Kane",
Rating:10,
}
fmt.Println(m.Name,m.Rating)
}
运行结果如下：
Citizen Kane 10
声明一个类型为结构体的变量，程序清单如下：
package main
import(
"fmt"
)
type Movie struct{ //结构体
Name string
Rating float32
}
func main(){
var m Movie
fmt.Printf("%+v\n",m) //零值
m.Name="Metropolis"
m.Rating=0.9918
fmt.Printf("%+v\n",m)
}
运行结果如下：
{Name: Rating:0}
{Name:Metropolis Rating:0.9918}
使用关键字new创建结构体实例，程序清单如下：
package main
import(
"fmt"
)
type Movie struct{ //结构体
Name string
Rating float32
}
func main(){
m:=new(Movie)
m.Name="Metropolis"
m.Rating=0.99
fmt.Printf("%+v\n",m)
}
运行结果如下：
&{Name:Metropolis Rating:0.99}
代码如下：
package main
import (
"fmt"
)
type myStruct struct {
i1 int
f1 float32
str string
}
func main() {
ms := new(myStruct)
ms.i1 = 10
ms.f1 = 15.5
ms.str = "Google"
fmt.Printf("int: %d\n", ms.i1)
fmt.Printf("float: %f\n", ms.f1)
fmt.Printf("string: %s\n", ms.str)
fmt.Println(ms)
}
运行结果如下：
int: 10
float: 15.500000
string: Google
&{10 15.5 Google}
使用简短变量赋值创建结构体实例，程序清单如下：
package main
import(
"fmt"
)
type Movie struct{ //结构体
Name string
Rating float32
}
func main(){
m:=Movie{
Name:"Metropolis",
Rating:0.99,
}
fmt.Printf("%+v\n",m)
}
运行结果如下：
{Name:Metropolis Rating:0.99}
使用简短变量赋值创建嵌套结构体实例，程序清单如下：
package main
import(
"fmt"
)
type Superhero struct{
Name string
Age int
Address Address
}
type Address struct{
Number int
Street string
City string
}
func main(){
e:=Superhero{
Name:"Batman",
Age:32,
Address:Address{
Number:1007,
Street:"Mountain Drive",
City:"Gotham",
},
}
fmt.Printf("%+v\n",e)
fmt.Println(e.Address.Street)
}
运行结果如下：
{Name:Batman Age:32 Address:{Number:1007 Street:Mountain Drive City:Gotham}}
Mountain Drive
使用构造函数自定义默认值，程序清单如下：
package main
import(
"fmt"
)
type Alarm struct{
Time string
Sound string
}
func NewAlarm(time string)Alarm{
a:=Alarm{
Time:time,
Sound:"Klaxon",
}
return a
}
func main(){
fmt.Printf("%+v\n",NewAlarm("07:00"))
}
运行结果如下：
{Time:07:00 Sound:Klaxon}
对两个数据字段值相等的结构体进行比较，程序清单如下：
package main
import(
"fmt"
)
type Drink struct{
Name string
Ice bool
}
func main(){
a:=Drink{
Name:"Lemonade",
Ice:true,
}
b:=Drink{
Name:"Lemonade",
Ice:true,
}
if a==b{
fmt.Println("a and b are the same")
}
fmt.Printf("%+v\n",a)
fmt.Printf("%+v\n",b)
}
运行结果如下：
a and b are the same
{Name:Lemonade Ice:true}
{Name:Lemonade Ice:true}
检查结构休的类型，程序清单如下：（没学过reflect）
package main
import(
"fmt"
"reflect"
)
type Drink struct{
Name string
Ice bool
}
func main(){
a:=Drink{
Name:"Lemonade",
Ice:true,
}
b:=Drink{
Name:"Lemonade",
Ice:true,
}
fmt.Println(reflect.TypeOf(a))
fmt.Println(reflect.TypeOf(b))
}
运行结果如下：
main.Drink
main.Drink
以值引用的方式复制结构体，程序清单如下：
package main
import(
"fmt"
)
type Drink struct{
Name string
Ice bool
}
func main(){
a:=Drink{
Name:"Lemonade",
Ice:true,
}
b:=a
b.Ice=false
fmt.Printf("%+v\n",b)
fmt.Printf("%+v\n",a)
fmt.Printf("%p\n",&a)
fmt.Printf("%p\n",&b)
}
运行结果如下：
{Name:Lemonade Ice:false}
{Name:Lemonade Ice:true}
0xc00000c030
0xc00000c048
以指针引用的方式复制结构体，程序清单如下：
package main
import(
"fmt"
)
type Drink struct{
Name string
Ice bool
}
func main(){
a:=Drink{
Name:"Lemonade",
Ice:true,
}
b:=&a
b.Ice=false
fmt.Printf("%+v\n",*b)
fmt.Printf("%+v\n",a)
fmt.Printf("%p\n",b)
fmt.Printf("%p\n",&a)
}
运行结果如下：
{Name:Lemonade Ice:false}
{Name:Lemonade Ice:false}
0xc00000c030
0xc00000c030
使用三个不同的方式调用方法，代码如下：
package main
import (
"fmt"
"strings"
)
type Person struct {
firstName string
lastName string
}
func upPerson(p *Person) {
p.firstName = strings.ToUpper(p.firstName)
p.lastName = strings.ToUpper(p.lastName)
}
func main() {
//作为值类型
var pers1 Person
pers1.firstName = "Zhang"
pers1.lastName = "Sansan"
upPerson(&pers1)
fmt.Printf("the name is %s %s\n", pers1.firstName, pers1.lastName)
//作为指针
pers2 := new(Person)
pers2.firstName = "Zhang"
pers2.lastName = "Sansan"
(*pers2).lastName = "Sansan" //这也是合法的
upPerson(pers2)
fmt.Printf("the name is %s %s\n", pers2.firstName, pers2.lastName)
//作为字面量
pers3 := &Person{"Zhang", "Sansan"}
upPerson(pers3)
fmt.Printf("the name is %s %s\n", pers3.firstName, pers3.lastName)
}
运行结果如下：
the name is ZHANG SANSAN
the name is ZHANG SANSAN
the name is ZHANG SANSAN
递归结构体：
可以通过引用自身来定义，这在定义链表或二叉树的元素（通常叫节点）时特别有用，此时节点包含指向临时节点的链接（地址）。
data字段用于存放有效数据，su指针指向后继节点：
type Node struct{
data float64
su *Node
}
链表中的第一个元素叫作head，它指向第二个元素；最后一个元素叫作tail，它没有后继元素，所以它的su值为nil。当然真实的链接会有很多数据节点，并且链表可以动态增长或收缩。
可以定义一个双向链表，它有一个前趋节点pr和一个后继节点su：
type Node struct{
pr *Node
data float64
su *Node
}
二叉树中每个节点最多能链接到两个节点：左节点（le）和右节点（ri），这两个节点本身又可以有左右节点。树的顶层节点叫作根节点（root），底层没有子节点的节点叫作叶子节点（leaves），叶子节点的le和ri指针为nil值。在Go语言中可以如下定义二叉树：
type Tree strcut{
le *Tree
data float64
ri *Tree
}
结构体使用
1、自定义包的结构体
main.go使用了一个结构体，它来自struct_pack下的包structPack：
package struck_pack
type ExpStruct struct {
Mi1 int
Mf1 float32
}
下面是main.go的代码：
package main
import (
"fmt"
"./struct_pack/struckPack"
)
func main() {
struct1:=new(structPack.Expstruct)
struct1.Mi1=10
struct1.Mf1=16.
fmt.Prinf("Mi1 = %d\n",struct.Mi1)
fmt.Prinf("Mf1 = %d\n",struct.Mf1)
}
编译执行输出：（编译失败）
Mi1=10
Mf1=16.000000
2、结构体成员访问
在Go语言中，访问结构体成员需要使用点号操作符，格式为“结构体.成员名”。
代码如下：
package main
import (
"fmt"
)
type Employee struct {
ID int
Name string
Address string
Phone string
}
func main() {
var employee1 Employee
employee1.ID = 10001
employee1.Name = "Tom"
employee1.Address = "xxxx"
employee1.Phone = "1881412xxxx"
fmt.Printf("employee1 ID: %d\n", employee1.ID)
fmt.Printf("employee1 Name: %s\n", employee1.Name)
fmt.Printf("employee1 Address: %s\n", employee1.Address)
fmt.Printf("employee1 Phone: %s\n", employee1.Phone)
}
运行结果如下：
employee1 ID: 10001
employee1 Name: Tom
employee1 Address: xxxx
employee1 Phone: 1881412xxxx
使用结构体指针重写以上实例，代码如下：
package main
import (
"fmt"
)
type Employee struct {
ID int
Name string
Address string
Phone string
}
func printEmployee(employee *Employee) {
fmt.Printf("Employee ID: %d\n", employee.ID)
fmt.Printf("Employee Name: %s\n", employee.Name)
fmt.Printf("Employee Address: %s\n", employee.Address)
fmt.Printf("Employee Phone: %s\n", employee.Phone)
}
func main() {
var employee Employee
employee.ID = 10001
employee.Name = "Tom"
employee.Address = "xxxx"
employee.Phone = "1881412xxxx"
printEmployee(&employee)
}
运行结果如下：
Employee ID: 10001
Employee Name: Tom
Employee Address: xxxx
Employee Phone: 1881412xxxx
3、结构体参数传输
代码如下：
package main
import (
"fmt"
)
type Employee struct {
ID int
Name string
Address string
Phone string
}
//形式传参
func operateEmployee1(employee Employee) {
employee.ID = 10010
}
//指针传参
func operateEmployee2(employee *Employee) {
employee.ID = 10010
}
func main() {
var employee Employee
employee.ID = 10001
employee.Name = "Tom"
employee.Address = "xxxx"
employee.Phone = "1881412xxxx"
fmt.Printf("形式传参之前，employee ID : %d\n", employee.ID)
operateEmployee1(employee)
fmt.Printf("形式传参之后，employee ID : %d\n", employee.ID)
fmt.Printf("指针传参之前，employee ID : %d\n", employee.ID)
operateEmployee2(&employee)
fmt.Printf("指针传参之后，employee ID : %d\n", employee.ID)
}
运行结果如下：
形式传参之前，employee ID : 10001
形式传参之后，employee ID : 10001
指针传参之前，employee ID : 10001
指针传参之后，employee ID : 10010
形式伟参中employee只是传递了一个副本到另一个函数，函数中操作的是副本，对employee没有任何影响；而在指针传参中employee传递的是地址，函数中的操作会影响到employee。
带标签的结构体
标签内容只有reflect包能获取。
代码如下：
package main
import (
"fmt"
"reflect"
)
type TagType struct {
field1 bool "是否有存货"
field2 string "商品名称"
field3 int "商品价格"
}
func refTag(tt TagType, ix int) {
ttType := reflect.TypeOf(tt)
ixField := ttType.Field(ix)
fmt.Printf("%v\n", ixField.Tag)
}
func main() {
tt := TagType{true, "LPhone X", 1}
for i := 0; i < 3; i++ {
refTag(tt, i)
}
}
运行结果如下：
是否有存货
商品名称
商品价格
匿名字段和内嵌结构体
1.匿名字段
代码如下：
package main
import (
"fmt"
)
type firstS struct {
in1 int
in2 int
}
type secondS struct {
b int
c float32
int //匿名字段
firstS //匿名字段
}
func main() {
sec := new(secondS)
sec.b = 6
sec.c = 7.5
sec.int = 60
sec.in1 = 5
sec.in2 = 10
fmt.Printf("sec.b is: %d\n", sec.b)
fmt.Printf("sec.c is: %f\n", sec.c)
fmt.Printf("sec.int is: %d\n", sec.int)
fmt.Printf("sec.in1 is: %d\n", sec.in1)
fmt.Printf("sec.in2 is: %d\n", sec.in2)
//使用结构体字面量
sec2 := secondS{6, 7.5, 60, firstS{5, 10}}
fmt.Println("sec2 is:", sec2)
}
运行结果如下：
sec.b is: 6
sec.c is: 7.500000
sec.int is: 60
sec.in1 is: 5
sec.in2 is: 10
sec2 is: {6 7.5 60 {5 10}}
在一个结构体中对于每一个数据类型只能有一个匿名字段。
2.内嵌结构体
代码如下：
package main
import (
"fmt"
)
type A struct {
ax, ay int
}
type B struct {
A
bx, by float32
}
func main() {
b := B{A{1, 2}, 3.0, 4.0}
fmt.Println(b.ax, b.ay, b.bx, b.by)
fmt.Println(b.A)
}
运行结果如下：
1 2 3 4
{1 2}
3.命名冲突
当两个字段拥有相同的名字时会产生冲突，一般情况下有两种：
（1）外层字段的名字覆盖内层字段的名字，但是两者的内存空间都会保留，这提供了一种重载字段或方法的方式。
（2）相同的名字在同层次结构体中出现了重复，并且这个字段被程序调用了，这将导致程序错误。这种情况只能由程序员自己修改。
类型系统
Go语言是一种静态类型的编程语言。
int64类型的值需要8B（64b），float32类型的值需4B(32b)，bool类型的值需要1B（8b）。
代码如下：
package main
import (
"fmt"
"reflect"
)
type Student struct {
name string "学生名字" // 结构体标签
Age int "学生年龄" // 结构体标签
Room int `json:"Roomid"` // 结构体标签
}
func main() {
st := Student{"Titan", 14, 102}
fmt.Println(reflect.TypeOf(st).Field(0).Tag)
fmt.Println(reflect.TypeOf(st).Field(1).Tag)
fmt.Println(reflect.TypeOf(st).Field(2).Tag)
}
运行结果：
[Running] go run "c:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\tempCodeRunnerFile.go"
学生名字
学生年龄
json:"Roomid"
[Done] exited with code=0 in 12.15 seconds
代码如下：
package main
import (
"fmt"
)
type Writer interface {
Write()
}
type Author struct {
name string
Writer
}
// 定义新结构体，重点是实现接口方法Write()
type Other struct {
i int
}
func (a Author) Write() {
fmt.Println(a.name, " Write.")
}
// 新结构体Other实现接口方法Write()，也就可以初始化时赋值给Writer 接口
func (o Other) Write() {
fmt.Println(" Other Write.")
}
func main() {
// 方法一：Other{99}作为Writer 接口赋值
Ao := Author{"Other", Other{99}}
Ao.Write()
// 方法二：简易做法，对接口使用零值，可以完成初始化
Au := Author{name: "Hawking"}
Au.Write()
}
运行结果如下：
[Running] go run "c:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\main.go"
Other Write.
Hawking Write.
[Done] exited with code=0 in 26.289 seconds
代码如下 ：
package main
import (
"fmt"
)
type Human struct {
name string // 姓名
Gender string // 性别
Age int // 年龄
string // 匿名字段
}
type Student struct {
Human // 匿名字段
Room int // 教室
int // 匿名字段
}
func main() {
//使用new方式
stu := new(Student)
stu.Room = 102
stu.Human.name = "Titan"
stu.Gender = "男"
stu.Human.Age = 14
stu.Human.string = "Student"
fmt.Println("stu is:", stu)
fmt.Printf("Student.Room is: %d\n", stu.Room)
fmt.Printf("Student.int is: %d\n", stu.int) // 初始化时已自动给予零值：0
fmt.Printf("Student.Human.name is: %s\n", stu.name) // (*stu).name
fmt.Printf("Student.Human.Gender is: %s\n", stu.Gender)
fmt.Printf("Student.Human.Age is: %d\n", stu.Age)
fmt.Printf("Student.Human.string is: %s\n", stu.string)
// 使用结构体字面量赋值
stud := Student{Room: 102, Human: Human{"Hawking", "男", 14, "Monitor"}}
fmt.Println("stud is:", stud)
fmt.Printf("Student.Room is: %d\n", stud.Room)
fmt.Printf("Student.int is: %d\n", stud.int) // 初始化时已自动给予零值：0
fmt.Printf("Student.Human.name is: %s\n", stud.Human.name)
fmt.Printf("Student.Human.Gender is: %s\n", stud.Human.Gender)
fmt.Printf("Student.Human.Age is: %d\n", stud.Human.Age)
fmt.Printf("Student.Human.string is: %s\n", stud.Human.string)
}
运行结果如下：
[Running] go run "c:\Users\a-xiaobodou\OneDrive - Microsoft\Projects\Go\tempCodeRunnerFile.go"
stu is: &{{Titan 男 14 Student} 102 0}
Student.Room is: 102
Student.int is: 0
Student.Human.name is: Titan
Student.Human.Gender is: 男
Student.Human.Age is: 14
Student.Human.string is: Student
stud is: {{Hawking 男 14 Monitor} 102 0}
Student.Room is: 102
Student.int is: 0
Student.Human.name is: Hawking
Student.Human.Gender is: 男
Student.Human.Age is: 14
Student.Human.string is: Monitor
[Done] exited with code=0 in 2.352 seconds
代码如下 ：
运行结果如下：
代码如下 ：
运行结果如下：
代码如下 ：
运行结果如下：
方法
一、方法声明
1.方法的声明
定义方法的一般格式如下：
func (recv receiver_type) methodName(parameter_list) (return_value_list) { ... }
在方法名之前，func关键字之后的括号中指定接收者。
一个结构体上的简单方法的例子，代码如下：
package main
import (
"fmt"
)
type TwoInts struct {
a int
b int
}
func (tn *TwoInts) AddThem() int {
return tn.a + tn.b
}
func (tn *TwoInts) AddToParam(param int) int {
return tn.a + tn.b + param
}
func main() {
two1 := new(TwoInts)
two1.a = 12
two1.b = 10
fmt.Printf("和为：%d\n", two1.AddThem())
fmt.Printf("将它们添加到参数：%d\n", two1.AddToParam(20))
two2 := TwoInts{3, 4}
fmt.Printf("和为：%d\n", two2.AddThem())
}
运行结果如下：
和为：22
将它们添加到参数：42
和为：7
非结构体类型方法的例子，代码如下：
package main
import (
"fmt"
)
type IntVector []int
func (v IntVector) Sum() (s int) {
for _, x := range v {
s += x
}
return
}
func main() {
fmt.Println(IntVector{1, 2, 3}.Sum())
}
运行结果如下：
6
代码如下：
package main
import (
"fmt"
"time"
)
type myTime struct {
time.Time //匿名字段
}
func (t myTime) first3Chars() string {
return t.Time.String()[0:3]
}
func main() {
m := myTime{time.Now()}
fmt.Println("完整的时间格式：", m.String())
fmt.Println("前三个字符：", m.first3Chars())
}
运行结果如下：
完整的时间格式： 2022-02-01 20:56:18.069698 +0800 CST m=+0.000139031
前三个字符： 202
2.函数和方法的区别
函数将变量作为参数：Function1(recv);方法在变量上被调用：recv.Method1()。
二、为类型添加方法
代码如下：
package main
import (
"fmt"
)
type Integer int
func (a Integer) Less(b Integer) bool {
return a < b
}
func main() {
var a Integer = 1
if a.Less(2) {
fmt.Println(a, "Less 2")
}
}
运行结果如下：
1 Less 2
代码如下：
package main
import (
"fmt"
)
type Integer int
func Integer_Less(a Integer, b Integer) bool {
return a < b
}
func main() {
var a Integer = 1
if Integer_Less(a, 2) {
fmt.Println(a, "Less 2")
}
}
运行结果如下：
1 Less 2
三、工厂方法创建结构体
四、基于指针对象的方法
代码如下：
package main
import (
"fmt"
)
type HttpResponse struct{ status_code int }
func (r *HttpResponse) validResponse() { r.status_code = 200 }
func (r HttpResponse) updateStatus() string { return fmt.Sprint(r) }
func main() {
var r1 HttpResponse
r1.validResponse()
fmt.Println(r1.updateStatus())
r2 := new(HttpResponse)
r2.validResponse()
fmt.Println(r2.updateStatus())
}
运行结果如下：
{200}
{200}
五、方法值和方法表达式
代码如下：
package main
import (
"fmt"
)
type S struct {
Name string
}
func (s S) M1() {
s.Name = "value"
}
func (s *S) M2() {
s.Name = "pointer"
}
func main() {
var s1 = S{"new"}
var s2 = &s1
s1.M2()
fmt.Printf("%+v, %+v\n", s1, s2)
s1 = S{"new"}
s2 = &s1
s2.M1()
fmt.Printf("%+v, %+v\n", s1, s2)
}
运行结果如下：
{Name:pointer}, &{Name:pointer}
{Name:new}, &{Name:new}
六、方法和未导出字段
七、嵌入式型的方法和继承
1.嵌入类型的方法和继承
代码如下：
package main
import (
"fmt"
"math"
)
type Point struct {
x, y float64
}
func (p *Point) Abs() float64 {
return math.Sqrt(p.x*p.x + p.y*p.y)
}
type NamedPoint struct {
Point
name string
}
func main() {
n := &NamedPoint{Point{3, 4}, "Pythongoooo"}
fmt.Println(n.Abs())
}
运行结果如下：
5
2.多重继承
代码如下：
package main
import (
"fmt"
)
type Camera struct{}
func (c *Camera) TakeAPicture() string {
return "拍照"
}
type Phone struct{}
func (p *Phone) Call() string {
return "响铃"
}
type CameraPhone struct {
Camera
Phone
}
func main() {
cp := new(CameraPhone)
fmt.Println("我们的新款拍照手机有多种功能：")
fmt.Println("打开了相机：", cp.TakeAPicture())
fmt.Println("电话来电：", cp.Call())
}
运行结果如下：
我们的新款拍照手机有多种功能：
打开了相机： 拍照
电话来电： 响铃
初始化结构体的成员变量
一、使用“键值对”初始化结构体
键值对初始化的格式如下：
ins:=结构体类型名{
字段1：字段1的值，
字段2：字段2的值，
……
}
二、使用多个值的列表初始化结构体
多个值使用逗号分隔初始化结构体，例如：
ins:=结构体类型号{
字段1的值，
字段2的值，
……
}
代码如下：
package main
import (
"fmt"
)
func main() {
type Address struct {
Province string
City string
ZipCode int
PhoneNumber string
}
addr := Address{
"四川",
"成都",
610000,
"0",
}
fmt.Println(addr)
}
运行结果如下：
{四川 成都 610000 0}
三、初始化匿名结构体
代码如下：
package main
import (
"fmt"
)
//打印消息类型，传入匿名结构体
func printMsgType(msg *struct {
id int
data string
}) {
//使用动词%T打印msg的类型
fmt.Printf("%T\n", msg)
}
func main() {
//实例化一个匿名结构体
msg := &struct { //定义部分
id int
data string
}{ //值初始化部分
1024,
"hello",
}
printMsgType(msg)
}
运行结果如下：
*struct { id int; data string }
构造函数——结构体和类型的一系列初始化操作的函数封装
1、多种方式创建和初始化结构体——模拟构造函数重载
2、带有父子关系的结构体的构造和初始化——模拟父级构造调用
方法：
一、为结构体添加方法
二、接收器——方法作用的目标
接收器的格式如下：
func (接收器变量 接收器类型) 方法名 (参数列表) (返回参数) {
函数体
}
1、理解指针类型的接收器
代码如下：
package main
import (
"fmt"
)
//定义属性结构
type Property struct {
value int //属性值
}
//设置属性值
func (p *Property) SetValue(v int) {
//修改p的成员变量
p.value = v
}
//取属性值
func (p *Property) Value() int {
return p.value
}
func main() {
//实例化属性
p := new(Property)
//设置值
p.SetValue(100)
//打印值
fmt.Println(p.Value())
}
运行结果如下：
100
2、理解非指针类型的接收器
代码如下：
package main
import (
"fmt"
)
//定义点结构
type Point struct {
X int
Y int
}
//非指针接收器的加方法
func (p Point) Add(other Point) Point {
//成员值与参数相加后返回新的结构
return Point{p.X + other.X, p.Y + other.Y}
}
func main() {
//初始化点
p1 := Point{1, 1}
p2 := Point{2, 2}
//与另外一个点相加
result := p1.Add(p2)
//输出结果
fmt.Println(result)
}
运行结果如下：
{3 3}
三、示例：二维矢量模拟玩家移动
创建一个文件夹playermove，有三个文件
1、实现二维矢量结构
vec.go的代码如下：
package main
import "math"
type Vec2 struct {
X, Y float32
}
//使用矢量加上另外一个矢量，生成新的矢量
func (v Vec2) Add(other Vec2) Vec2 {
return Vec2{
v.X + other.X,
v.Y + other.Y,
}
}
//使用矢量减去另外一个矢量，生成新的矢量
func (v Vec2) Sub(other Vec2) Vec2 {
return Vec2{
v.X - other.X,
v.Y - other.Y,
}
}
//使用矢量乘以另外一个矢量，生成新的矢量
func (v Vec2) Scale(s float32) Vec2 {
return Vec2{v.X * s, v.Y * s}
}
//计算两个矢量的距离
func (v Vec2) DistanceTo(other Vec2) float32 {
dx := v.X - other.X
dy := v.Y - other.Y
return float32(math.Sqrt(float64(dx*dx + dy*dy)))
}
//返回当前矢量的标准化矢量
func (v Vec2) Normalize() Vec2 {
mag := v.X*v.X + v.Y*v.Y
if mag > 0 {
oneOverMag := 1 / float32(math.Sqrt(float64(mag)))
return Vec2{v.X * oneOverMag, v.Y * oneOverMag}
}
return Vec2{0, 0}
}
2、实现玩家对象
player.go的代码如下：
package main
type Player struct {
currPos Vec2
targetPos Vec2
speed float32
}
//设置玩家移动的目标位置
func (p *Player) MoveTo(v Vec2) {
p.targetPos = v
}
//获取当前的位置
func (p *Player) Pos() Vec2 {
return p.currPos
}
//判断是否到达目的地
func (p *Player) IsArrived() bool {
//通过计算当前玩家位置与目标位置的距离不超过移动的步长，判断已经到达目标点
return p.currPos.DistanceTo(p.targetPos) < p.speed
}
//更新玩家的位置
func (p *Player) Update() {
if !p.IsArrived() {
//计算机出当前位置指向目标的朝向
dir := p.targetPos.Sub(p.currPos).Normalize()
//添加速度矢量生成新的位置
newPos := p.currPos.Add(dir.Scale(p.speed))
//移动完成后，更新当前位置
p.currPos = newPos
}
}
//创建新玩家
func NewPlayer(speed float32) *Player {
return &Player{
speed: speed,
}
}
3、处理移动逻辑
main.go的代码如下：
package main
import "fmt"
func main() {
//实例化玩家对象，并设速度为0.5
p := NewPlayer(0.5)
//让玩家移动到3,1点
p.MoveTo(vec2{3, 1})
//如果没有到达就一直循环
for !p.IsArrived() {
//更新玩家位置
p.Update()
//打印每次移动后的玩家位置
fmt.Println(p.Pos())
}
}
四、为类型添加方法
1、为基本类型添加方法
代码如下：
package main
import (
"fmt"
)
//将int定义MyInt类型
type MyInt int
//为MyInt添加IsZero()方法
func (m MyInt) IsZero() bool {
return m == 0
}
//为MyInt添加Add()方法
func (m MyInt) Add(other int) int {
return other + int(m)
}
func main() {
var b MyInt
fmt.Println(b.IsZero())
b = 1
fmt.Println(b.Add(2))
}
运行结果如下：
true
3
2、http包中的类型方法
代码如下：
package main
import (
"fmt"
"io/ioutil"
"net/http"
"os"
"strings"
)
func main() {
client := &http.Client{}
//创建一个HTTP请求
req, err := http.NewRequest("POST", "http://www.163.com", strings.NewReader("key=value"))
//发现错误就打印并退出
if err != nil {
fmt.Println(err)
os.Exit(1)
return
}
//为标头添加信息
req.Header.Add("User-Agent", "myClient")
//开始请求
resp, err := client.Do(req)
//处理请求的错误
if err != nil {
fmt.Println(err)
os.Exit(1)
return
}
//读取服务器返回的内容
data, err := ioutil.ReadAll(resp.Body)
fmt.Println(string(data))
defer resp.Body.Close()
}
运行结果如下：内容太多了，不复制。
3、time包中的类型方法
代码如下：
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println(time.Second.String())
}
运行结果如下：
1s
五、示例：使用事件系统实现事件的响应和处理
1、方法和函数的统一调用
函数代理，detegate.go，代码如下：
package main
import (
"fmt"
)
//声明一个结构体
type class struct{}
//给结构体添加Do()方法
func (c *class) Do(v int) {
fmt.Println("call method do:", v)
}
//普通函数的Do()方法
func funcDo(v int) {
fmt.Println("call function do:", v)
}
func main() {
//声明一个函数回调
var delegate func(int)
//创建结构体实例
c := new(class)
//将回调设为c的Do方法
delegate = c.Do
//调用
delegate(100)
//将回调设为普通函数
delegate = funcDo
//调用
delegate(100)
}
运行结果如下：
call method do: 100
call function do: 100
2、事件系统基本原理
3、事件注册
注册事件，./eventsys/reg.go，代码如下：
//实例化一个通过字符串映射函数切片的map
var eventByName=make(map[string][]func(interface{}))
//注册事件，提供事件名和回调函数
func RegisterEvent(name string,callback func(interface{})){
//通过名字查找事件列表
list:=eventByName[name]
//在列表切片中添加函数
list=append(list,callback)
//保存修改的事件列表切片
eventByName[name]=list
}
4、事件调用
调用事件，./eventsys/reg.go，代码如下：
//调用事件
func CallEvent(name string, param interface{}) {
//通过名字找到事件列表
list := eventByName[name]
//遍历这个事件的所有回调
for _, callback := range list {
//传入参数调用回调
callback(param)
}
}
5、使用事件系统
使用事件系统，./eventsys/main.go，代码如下：
package main
import "fmt"
//声明角色的结构体
type Actor struct{}
//为角色添加一个事件处理函数
func (a *Actor) OnEvent(param interface{}) {
fmt.Println("actor event:", param)
}
//全局事件
func GlobalEvent(param interface{}) {
fmt.Println("global event:", param)
}
func main() {
//实例化一个角色
a := new(Actor)
//注册名为OnSkill的回调
RegisterEvent("OnSkill", a.OnEvent)
//再次在OnSkill上注册全局事件
RegisterEvent("OnSkill", GlobalEvent)
//调用事件，所有注册的同名函数都会被调用
CallEvent("OnSkill", 100)
}
书上的运行结果 如下：
actor event:100
global event:100
类型内嵌和结构体内嵌
一、声明结构体内嵌
代码如下：
package main
import (
"fmt"
)
//基础颜色
type BasicColor struct {
//红、绿、蓝三种颜色分量
R, G, B float32
}
//完整颜色定义
type Color struct {
//将基本颜色作为成员
Basic BasicColor
//透明度
Alpha float32
}
func main() {
var c Color
//设置基本颜色分量
c.Basic.R = 1
c.Basic.G = 1
c.Basic.B = 0
//设置透明度
c.Alpha = 1
//显示整个结构体内容
fmt.Printf("%+v", c)
}
运行结果如下：
{Basic:{R:1 G:1 B:0} Alpha:1}
代码如下：
package main
import (
"fmt"
)
//基础颜色
type BasicColor struct {
//红、绿、蓝三种颜色分量
R, G, B float32
}
//完整颜色定义
type Color struct {
//将基本颜色作为成员
BasicColor
//透明度
Alpha float32
}
func main() {
var c Color
//设置基本颜色分量
c.R = 1
c.G = 1
c.B = 0
//设置透明度
c.Alpha = 1
//显示整个结构体内容
fmt.Printf("%+v", c)
}
运行结果如下：
{BasicColor:{R:1 G:1 B:0} Alpha:1}
二、结构内嵌特性
三、使用组合思想描述对象特性
人和鸟的特性，代码如下：
package main
import (
"fmt"
)
//可飞行的
type Flying struct{}
func (f *Flying) Fly() {
fmt.Println("can fly")
}
//可行走的
type Walkable struct{}
func (f *Walkable) Walk() {
fmt.Println("can walk")
}
//人类
type Human struct {
Walkable //人类能行走
}
//鸟类
type Bird struct {
Walkable //鸟类能行走
Flying //鸟类能飞行
}
func main() {
//实例化鸟类
b := new(Bird)
fmt.Println("Bird:")
b.Fly()
b.Walk()
//实例化人类
h := new(Human)
fmt.Println("Human:")
h.Walk()
}
运行结果如下：
Bird:
can fly
can walk
Human:
can walk
四、初始化结构体内嵌
车辆结构的组装和初始化，代码如下：
package main
import (
"fmt"
)
//车轮
type Wheel struct {
Size int
}
//引擎
type Engine struct {
Power int //功率
Type string //类型
}
//车
type Car struct {
Wheel
Engine
}
func main() {
c := Car{
//初始化轮子
Wheel: Wheel{
Size: 18,
},
//初始化引擎
Engine: Engine{
Type: "1.4T",
Power: 143,
},
}
fmt.Printf("%+v\n", c)
}
运行结果如下：
{Wheel:{Size:18} Engine:{Power:143 Type:1.4T}}
五、初始化内嵌匿名结构体
内嵌结构体，代码如下：
package main
import (
"fmt"
)
//车轮
type Wheel struct {
Size int
}
//车
type Car struct {
Wheel
//引擎
Engine struct {
Power int //功率
Type string //类型
}
}
func main() {
c := Car{
//初始化轮子
Wheel: Wheel{
Size: 18,
},
//初始化引擎
Engine: struct {
Power int
Type string
}{
Type: "1.4T",
Power: 143,
},
}
fmt.Printf("%+v\n", c)
}
运行结果如下：
{Wheel:{Size:18} Engine:{Power:143 Type:1.4T}}
六、成员名字冲突
代码如下：
package main
import (
"fmt"
)
type A struct {
a int
}
type B struct {
a int
}
type C struct {
A
B
}
func main() {
c := &C{}
c.A.a = 1
fmt.Println(c)
}
运行结果如下：
&{{1} {0}}
示例：使用匿名结构体分离JSON数据
代码如下：
package main
import (
"encoding/json"
"fmt"
)
//定义手机屏幕
type Screen struct {
Size float32 //屏幕尺寸
ResX, ResY int //屏幕水平和垂直分辨率
}
//定义电池
type Battery struct {
Capacity int //容量
}
//生成JSON数据
func getJsonData() []byte {
//完整数据结构
raw := &struct {
Screen
Battery
HasTouchID bool
}{
//屏幕参数
Screen: Screen{
Size: 5.5,
ResX: 1920,
ResY: 1080,
},
//电池参数
Battery: Battery{
2910,
},
//是否有指纹识别
HasTouchID: true,
}
//将数据序列化为JSON
jsonData, _ := json.Marshal(raw)
return jsonData
}
func main() {
//生成一段JSON数据
jsonData := getJsonData()
fmt.Println(string(jsonData))
//只需要屏幕和指纹识别信息的结构和实例
screenAndTouch := struct {
Screen
HadTouchID bool
}{}
//反序列化到screenAndTouch中
json.Unmarshal(jsonData, &screenAndTouch)
//输出screenAndTouch的详细结构
fmt.Printf("%+v\n", screenAndTouch)
//只需要电池和指纹识别信息的结构和实例
batteryAndTouch := struct {
Battery
HasTouchID bool
}{}
//反序列化到batteryAndTouch
json.Unmarshal(jsonData, &batteryAndTouch)
//输出screenAndTouch的详细结构
fmt.Printf("%+V\n", batteryAndTouch)
}
运行结果如下：
{"Size":5.5,"ResX":1920,"ResY":1080,"Capacity":2910,"HasTouchID":true}
{Screen:{Size:5.5 ResX:1920 ResY:1080} HadTouchID:false}
{{%!V(int=+2910)} %!V(bool=true)}
————————————————
版权声明：本文为CSDN博主「DXB2021」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/DXB2021/article/details/122652779