基于GoFrame框架的Go语言语法学习-1

结构体

1. 自定义类型

Go语言中可以使用type关键字来定义自定义类型。

自定义类型是定义了一个全新的类型。我们可以基于内置的基本类型定义，也可以通过struct定义。例如：

 //将MyInt定义为int类型,通过Type关键字的定义，MyInt就是一种新的类型，它具有int的特性。
    type MyInt int

自定义类型与类型别名的区别

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

2. 结构体内嵌

Go语言的结构体内嵌是一种组合特性，使用结构体内嵌可构建一种面向对象编程思想中的继承关系。 结构体实例化后，可直接访问内嵌结构体的所有成员变量和方法。

// 废话，都嵌进来，肯定能访问，但是如果A继承B，A可以完全使用B的成员，那么B能使用A的吗？能的话，能使用多少？使用到什么程度？---- 用不了

例：

// 内嵌及初始化
package main
import "fmt"

type Book struct {
	title  string
	author string
	num    int
	id     int
}

type BookBorrow struct {
	Book
	borrowTime string
}

type BookNotBorrow struct {
	Book
	readTime string
}

func main() {
    // 键值初试化
    // 使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作。
	bookBorrow := &BookBorrow{ 
		Book: Book{title: "golang", author: "Tom",
			num: 20, id: 123456,
		},
		borrowTime: "2022.01.02",
	}
    // 列表初始化
	bookNotBorrow := &BookNotBorrow{ 
		Book: Book{"python",
			"Jan",
			10,
			654321,
		},
		readTime: "2022.01.03",
	}
	fmt.Println(bookBorrow)
	fmt.Println(bookNotBorrow)
}

3. 匿名结构体

例：

package main

import (
    "fmt"
)

func main() {
    var user struct{Name string; Age int}
    user.Name = "pprof.cn"
    user.Age = 18
    fmt.Printf("%#v\n", user)
}

3.1 取结构体的地址实例化

使用&对结构体进行取地址操作相当于对该结构体类型进行了一次new实例化操作。

package main

import "fmt"

type inter int
type Person struct {
	name string
	city string
	age inter
}
func main() {
	var n = &Person{}
	fmt.Printf("%T\n", n)
    // 输出
	*main.Person
    
    p3.name = "博客"
	p3.age = 30
    p3.city = "成都"  // 等价于(*p3).city = "成都"
	fmt.Printf("p3=%#v\n", p3) //p3=&main.person{name:"博客", city:"成都", age:30}
    
    // 输出
    p3=&main.Person{name:"博客", city:"成都", age:30}
}

3.2 使用键值对初始化

使用键值对对结构体进行初始化时，键对应结构体的字段，值对应该字段的初始值。

package main
import "fmt"
type inter int
type person struct {
	name string
	city string
	age inter
}
func main() {
	p5 := person{
		name: "pprof.cn",
		city: "北京",
		age:  18,
	}
	fmt.Printf("p5=%#v\n", p5) //p5=main.person{name:"pprof.cn", city:"北京", age:18}
    
    // 也可以
    p6 := &person{
		name: "pprof.cn",
		city: "北京",
		age:  18,
	}
	fmt.Printf("p6=%#v\n", (*p6))
}

当某些字段没有初始值的时候，该字段可以不写。此时，没有指定初始值的字段的值就是该字段类型的零值。

p7 := &person{
    city: "北京",
}
fmt.Printf("p7=%#v\n", p7) //p7=&main.person{name:"", city:"北京", age:0}

面试题

package main

import "fmt"

type student struct {
	name string
	age  int
}

func main() {
	m := make(map[string]*student)
	stus := []student{
		{name: "pprof.cn", age: 18},
		{name: "测试", age: 23},
		{name: "博客", age: 28},
	}
	// 主要问题在这
	//for _, stu := range stus {
	//	m[stu.name] = &stu
	// for range 是创建了每个元素的副本然后映射该副本，并不是返回对元素的引用，而且使用的一直是同一个遍历指针，
	// 这在循环读取中是没有问题的。但如果循环建立哈希表，使用遍历的指针作为每个键的映射，
	// 那么循环结束后会指向最后一个元素，造成所有的值都是同一个。
	for i, stu := range stus {
		m[stu.name] = &stus[i]
	}
	for k, v := range m {
		fmt.Println(k, "=>", v.name)
	}
}

3.3 构造函数

package main
import "fmt"

type person struct {
	name string
	city string
	age  int8
}

func newPerson(name string, city string, age int8) *person {
	return &person{
		name: name,
		city: city,
		age:  age,
	}
}

func main() {
	p9 := newPerson("pprof.cn", "测试", 90)
	fmt.Printf("%#v\n", p9)
}

3.4 方法和接收者（你试一下，以接收者的思想看待方法）

方法：方法就是作用在接收器（receiver）上的一个函数；
接收器：某个类型的变量；

Go语言中的方法（Method）是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者(方法作用于特定类型)（Receiver）。接收者的概念就类似于其他语言中的this或者 self。

方法的定义格式如下：

// (接收者变量 接收者类型) --> 绑定关系
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
	函数体
}

其中，

1.接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名的第一个小写字母，而不是self、this之类的命名。例如，Person类型的接收者变量应该命名为 p，Connector类型的接收者变量应该命名为c等。
2.接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
3.方法名、参数列表、返回参数：具体格式与函数定义相同。

func (p Person) Dream() {
	fmt.Printf("%s的梦想是学好Go语言！\n", p.name)
}

3.5 指针类型的接收者

package main

import "fmt"

//Person 结构体
type Person struct {
	name string
	age  int8
}
//NewPerson 构造函数
func NewPerson(name string, age int8) *Person {
	return &Person{
		name: name,
		age:  age,
	}
}
func (p *Person) SetAge(newAge int8) {
	p.age = newAge
}

func main() {
	p1 := NewPerson("测试", 25)
    fmt.Printf("%T\n", p1)
	p1.SetAge(30)
	fmt.Println(p1.age)
}
// 输出
*main.Person
30

3.6 结构体的继承

package main

import "fmt"

type Animal struct {
	name string
}
func (a *Animal) move(){
	fmt.Printf("%s会动\n" , a.name)
}
// Gog
type Dog struct {
	Feet byte
	*Animal		// 通过嵌套匿名结构体(光把类型带进来了，没写变量)实现继承
}
func (d *Dog) wang(){
	fmt.Printf("%s会汪汪汪~\n", d.name)
}
func main(){
	// 结构体实例化
	d1 := &Dog{
		Feet: 4,
		// Dog结构体继承了Animal结构体的方法
		Animal : &Animal{name: "乐乐",},
	}
	d1.wang()
	d1.move()
}

3.7 结构体与JSON序列化

package main

import (
	"encoding/json"
	"fmt"
)
//Student 学生
type Student struct {
	ID     int
	Gender string
	Name   string
}

//Class 班级
type Class struct {
	Title    string
	Students []*Student
}

func main() {
	// 实例化
	c := &Class{
		Title:    "101",
		Students: make([]*Student, 0, 200),
	}
	for i := 0; i < 10; i++ {
		stu := &Student{
			Name:   fmt.Sprintf("stu%02d", i),
			Gender: "男",
			ID:     i,
		}
		c.Students = append(c.Students, stu)
	}
	//JSON序列化：结构体-->JSON格式的字符串
	data, err := json.Marshal(c)
	if err != nil {
		fmt.Println("json marshal failed")
		return
	}
	fmt.Printf("json:%s\n", data)
	//JSON反序列化：JSON格式的字符串-->结构体
	str := `{"Title":"101","Students":[{"ID":0,"Gender":"男","Name":"stu00"},{"ID":1,"Gender":"男","Name":"stu01"},{"ID":2,"Gender":"男","Name":"stu02"},{"ID":3,"Gender":"男","Name":"stu03"},{"ID":4,"Gender":"男","Name":"stu04"},{"ID":5,"Gender":"男","Name":"stu05"},{"ID":6,"Gender":"男","Name":"stu06"},{"ID":7,"Gender":"男","Name":"stu07"},{"ID":8,"Gender":"男","Name":"stu08"},{"ID":9,"Gender":"男","Name":"stu09"}]}`
	c1 := &Class{}
	err = json.Unmarshal([]byte(str), c1)
	if err != nil {
		fmt.Println("json unmarshal failed!")
		return
	}
	fmt.Printf("%#v\n", c1)
}

方法

定义上文已提及，不再赘述

	func (recevier type) methodName(参数列表)(返回值列表){}

    参数和返回值可以省略

注意：

注意，当方法的接受器不是一个指针时，方法操作对应接受器的值的副本，意思就是即使你使用了指针调用函数，但是函数的接受者是值类型，你还是传的值，而非指针，所以函数内部操作还是对副本的操作，而不是指针操作。可笑的是，当接受者是指针时，即使用值类型调用那么函数内部也是对指针的操作（双标吗？）。

不双标，方法有自主权，如果自己都没有选择自己成为什么样的人的权利，那也太可笑了。

1. receiver T 和 *T 的差别。

package main

import "fmt"

type Data struct {
	x int
}

func (self Data) ValueTest(){		// 函数形式：func ValueTest(self Data);
	fmt.Printf("Value is %p\n", &self)
}
func (self *Data) PointerTest() {   // 函数形式：func PointerTest(self *Data);
	fmt.Printf("Pointer: %p\n", self)
}
func main(){
	d := Data{}
	p := &d
	fmt.Printf("Data: %p, type: %T\n", p, p)

	d.ValueTest()	// ValueTest(d)
	d.PointerTest() // PointerTest(&d)  指针

	p.ValueTest()   // ValueTest(*p)
	p.PointerTest() // PointerTest(p)	指针
}

// 输出
Data: 0xc00001a0a8, type: *main.Data
Value is 0xc00001a0c8
Pointer: 0xc00001a0a8
Value is 0xc00001a0e0
Pointer: 0xc00001a0a8

饶了我半天。。。。。指针传递本来就传的同一个地址啊；改变值就要改变变量，不同变量的地址肯定不一样

匿名字段(很萌、很猛)

结果：

// 这块地址装这么多东西
Manager: 0xc00010e4b0, &{{1 Tom} Administrator}
User: 0xc00010e4b0, &{1 Tom}

方法总结：

func (p *Person) insert (a int) int{}

t() // PointerTest§ 指针
}

// 输出
Data: 0xc00001a0a8, type: *main.Data
Value is 0xc00001a0c8
Pointer: 0xc00001a0a8
Value is 0xc00001a0e0
Pointer: 0xc00001a0a8

饶了我半天。。。。。指针传递本来就传的同一个地址啊；改变值就要改变变量，不同变量的地址肯定不一样

# 匿名字段(很萌、很猛)

[外链图片转存中...(img-misPugRK-1689745885036)]

结果：

```go
// 这块地址装这么多东西
Manager: 0xc00010e4b0, &{{1 Tom} Administrator}
User: 0xc00010e4b0, &{1 Tom}

方法总结：

func (p *Person) insert (a int) int{}