go 结构体 - 值类型、引用类型 - 结构体转json类型 - 指针类型的种类 - 结构体方法 - 继承 - 多态(interface接口) - 练习

目录

一、结构体

[1、python 与 go面向对象的实现:](#1、python 与 go面向对象的实现:)

2、初用GO中的结构体:(实例化一个值类型的数据(结构体))

输出结果不同的三种方式

3、实例化一个引用类型的数据(结构体)

[4、引用类型(指针类型) vs 值类型(两者的区别)](#4、引用类型(指针类型) vs 值类型(两者的区别))

[引用类型(指针类型) - 值类型内存拓扑图:](#引用类型(指针类型) - 值类型内存拓扑图:)

5、结构体匿名字段、匿名结构体

6、结构体的嵌套

7、结构体转json类型

二、指针类型的种类(结构体指针、数据变量指针、指针数组、数组指针)

三、结构体方法(普通方法、指针方法)

四、结构体继承:

五、结构体多态:(interface接口的运用)

1、空接口的定义:

2、接口如何实现自定义error呢?

1、练习:判断Role(角色)是否存活

2、练习:实现发邮件功能

3、练习:定义标准化返回(json格式)


一、结构体

结构体(Struct) 是一种在Go语言中用于定义复合数据类型的机制。它允许你将不同类型的数据组合在一起,形成一个自定义的数据类型,以便更方便地管理和操作相关数据。

在Go语言中,通过type关键字和字段列表来定义结构体。每个字段都可以有自己的数据类型,类似于其他编程语言中的类的成员变量。结构体中的字段可以包含任意类型的数据,包括基本数据类型(如整数、浮点数、字符串等)和其他自定义类型(如其他结构体、数组、切片等)。

结构体中可以定义多个字段,类似于python中class类的属性

以下是一个简单的例子来说明如何定义和使用结构体:

package main

import "fmt"

// 定义一个Person结构体
type Person struct {
    Name string
    Age  int
}

func main() {
    // 创建一个Person类型的变量
    var person1 Person

    // 设置person1的字段值
    person1.Name = "Alice"
    person1.Age = 30

    // 打印person1的字段值
    fmt.Println(person1) // 输出:{Alice 30}

    // 创建并初始化Person结构体的另一个变量
    person2 := Person{
        Name: "Bob",
        Age:  25,
    }

    // 打印person2的字段值
    fmt.Println(person2) // 输出:{Bob 25}
}

在上述示例中,我们通过type关键字定义了一个名为Person的结构体。该结构体有两个字段,分别为NameAge,分别用来存储人的姓名和年龄。

main函数中,我们创建了两个Person类型的变量person1person2,并分别设置了它们的字段值。可以通过运算符来访问结构体变量的字段。

1、python 与 go面向对象的实现:

python 支持面向对象的 --》 class 类

go 不支持面向对象编程,可以使用结构体来实现类似的功能

  python => 面向对象
  class Student(object):
      def __init__(self, id, name, age):
           self.id = id
           ....

  go => 支持结构体
type struct_name struct{
	field_name1 field_type
	field_name2 field_type
	field_name3 field_type
	...
}

2、初用GO中的结构体:(实例化一个值类型的数据(结构体))

// 定义一个Student结构体
type Student struct {
	id int
	name string
	age uint
	school string
}

func main(){
    // 实例化一:实例化一个值类型的数据(结构体)
	// 实例化的时候,可以只初始化部分数据
	zrp := Student{
		id:     1,
		name:   "zrp",
	}
    //输出结果不同的三种方式
	fmt.Printf("%v\n", zrp)
	fmt.Printf("%+v\n", zrp)
	fmt.Printf("%#v\n", zrp)

    // 初始化的时候,如果不指定字段名,就需要每个字段都赋值
    // 否则会报错:too few values in Student{...}
    wbw :=Student{2,"wbw",20, "nongda"}
    // 值类型的数据要看地址的话,需要加&
	fmt.Printf("%#v,地址:%p\n", wbw, &wbw)

}

输出:
{1 zrp 0 }
{id:1 name:zrp age:0 school:}
main.Student{id:1, name:"zrp", age:0x0, school:""}
main.Student{id:2, name:"wbw", age:0x14, school:"nongda"},地址:0xc000100540

输出结果不同的三种方式

fmt.Printf("%v\n", zrp)
fmt.Printf("%+v\n", zrp)
fmt.Printf("%#v\n", zrp)

输出:

{1 zrp 0 }
{id:1 name:zrp age:0 school:}
main.Student{id:1, name:"zrp", age:0x0, school:""}

3、实例化一个引用类型的数据(结构体)

package main

import "fmt"

// 定义一个Student结构体
type Student struct {
	id int
	name string
	age uint
	school string
}

func main(){

	// 实例化一个引用类型
	// 使用new实例化开辟一片内存空间,创建一个实例对象,返回这个对象的内存地址
	mq := new(Student)   //使用new实例化开辟一片内存空间 , mq是引用类型的数据
	mq.id = 3            //
	mq.name = "mq"
	mq.age = 18
	fmt.Printf("%#v,地址:%p\n", mq, mq)
}

输出:
&main.Student{id:3, name:"mq", age:0x12, school:""},0xc00000a028

4、引用类型(指针类型) vs 值类型(两者的区别)

package main

import "fmt"

// 定义一个Student结构体
type Student struct {
	id int
	name string
	age uint
	school string
}

func main(){
    // 实例化一个值类型的数据
    wbw :=Student{2,"wbw",20, "nongda"}

    // 实例化一个引用类型的数据
	mq := new(Student)
	mq.id = 3
	mq.name = "mq"
	mq.age = 18

    // 引用类型(指针类型) vs 值类型 区别

	// 引用类型 => 指向了一个内存数据,注意:如果要修改的话,一同变化
	mq2 := mq
	mq2.name = "米强"
	fmt.Printf("type:%T,values:%+v,address:%p\n",mq, mq,mq)
	fmt.Printf("type:%T,values:%+v,address:%p\n",mq2, mq2,mq2)
	// 值类型:两份数据,相互不影响
	wbw2 := wbw
	wbw2.name = "王百文"
	fmt.Printf("type:%T,values:%+v,address:%p\n",wbw, wbw, &wbw)
	fmt.Printf("type:%T,values:%+v,address:%p\n",wbw2, wbw2,&wbw2)
}

输出:
type:*main.Student,values:&{id:3 name:米强 age:18 school:},address:0xc0001004e0
type:*main.Student,values:&{id:3 name:米强 age:18 school:},address:0xc0001004e0
type:main.Student,values:{id:2 name:wbw age:20 school:nongda},address:0xc0001004b0
type:main.Student,values:{id:2 name:王百文 age:20 school:nongda},address:0xc000100570

引用类型(指针类型) - 值类型内存拓扑图:

5、结构体匿名字段、匿名结构体

package main

import "fmt"

// 结构体匿名字段 => 如果没有定义字段名,会用类型的名字直接充当字段名
type Stu struct {
	string
	int
}

func main(){
	// 结构体匿名字段实例化
	st1 := Stu{"abc", 100}
	fmt.Printf("st1:%+v\n", st1)

    // 匿名结构体: 适合一次性使用
	stu2 := struct {
		name string
		age int
	}{"cali", 30}
	fmt.Printf("st2:%+v\n", stu2)
}

输出:
st1:{string:abc int:100}
st2:{name:cali age:30}

6、结构体的嵌套

package main

import "fmt"

// 结构体的嵌套
type Book struct {
	title string
	Author struct{
		name, tel string
		age int
	}
}

func main(){

	// 嵌套结构体的实例化
	b1 := Book{title: "GO从入门到精通"}
	b1.Author.name = "cici"
	b1.Author.tel = "186xxxxxxxx"
	fmt.Printf("b1:%+v\n", b1)
}

输出:
b1:{title:GO从入门到精通 Author:{name:cici tel:186xxxxxxxx age:0}}

7、结构体转json类型

package main

import (
	"encoding/json"
	"fmt"
)

// Web开发,数据定义都是结构体类型 结构体数据 <=> json <=>前端
// 加Tag(两个反引号``): Tag加上json配置项:他当将结构体转换成json的时候读取该配置
// Student结构体内的数据转换为json格式
type Student struct{
    // 转换json格式
	Id int			`json:"id"`
	Name string		`json:"username"`

	// 设置成"-" => 表示忽略该字段
	School string	`json:"-"`

	// 如果没有配置 => 使用默认字段名
	School2 string

	// omitempty如果当前字段School3有值的,会显示出来,如果没有值就不会显示
	School3 string 	`json:"school,omitempty"`
}

// 使用json模块
// go结构体数据 <=> json <=>前端
func main(){
    // 实例化
	s1 := Student{
		Id:     1,
		Name:   "user1",
		School: "nongda",
		School3: "nongda3",  // omitempty会导致如果School3没有值就不会显示School3字段
	}
    // 用于进行go的异常处理
	bmarshal, err := json.Marshal(s1)
	if err == nil {
        // 输出转换后的json格式数据
		fmt.Println(string(bmarshal))
	}else{
        // 输出其中的错误
		fmt.Println("err:", err)
	}
}

输出:
{"id":1,"username":"user1","School2":"","school":"nongda2"}

二、指针类型的种类(结构体指针、数据变量指针、指针数组、数组指针)

package main

import "fmt"

// 定义一个Student结构体
type Student struct {
	id int
	name string
	age uint
	school string
}

func main(){
	// 结构体指针
	mc := &Student{
		id: 4,
		name: "mc",
	}
	fmt.Printf("type:%T, values:%+v\n", mc, mc)

	// 结构体指针中,可以使用简化的语法
	fmt.Printf("%+v, %s\n", mc, (*mc).name)
	fmt.Printf("%+v, %s\n", mc, mc.name)

	// 数据变量指针获取数据的方法
	var n1 *int  // 定义n1为int指针
	n2 := 10     // 给n2赋值
	n1 = &n2     // 将n2的地址传给n1指针
	*n1 = 20     // 给n1指针赋值为20
	fmt.Printf("type:%T,address:%p, value:%d\n",n1, n1, *n1)
	fmt.Printf("address:%p, value:%d\n",&n2, n2)

    // 指针数组 parr是一个数组,有4个元素,每个元素都是一个int类型的指针
    var parr [4]*int
	a := 10
	parr[2] = &a
	fmt.Printf("value:%v, address:%v\n", *parr[2], parr[2])

    // 数组指针:是一个指针,指向了一个数组类型的数据(访问数据的时候,可以使用简化方式)
    var parr2 *[4]int
	arr := [4]int{1,2,3,4}
	parr2 = &arr
	fmt.Printf("arrvalue:%v, value:%v, value:%v\n", parr2, (*parr2)[0], parr2[0])
}

输出:
type:*main.Student, values:&{id:4 name:mc age:0 school:}
type:*int,address:0xc0000a60a0, value:20
address:0xc0000a60a0, value:20
&{id:4 name:mc age:0 school:}, mc
&{id:4 name:mc age:0 school:}, mc
value:10, address:0xc00000e138
arrvalue:&[1 2 3 4], value:1, value:1

三、结构体方法(普通方法、指针方法)

package main

import "fmt"
// 结构体方法的实现
// 在普通函数前加上一个接收者(receiver)
// func (s receiverType) funcName(args...)  --》 结构体方法的定义

// 定义一个Student结构体
type Student struct {
	id int
	name string
	age uint
	school string
}

// 为Student结构绑定一个changeSchool方法 (值类型的结构体,在函数内部修改数据并不会影响函数外面)
func (s Student) changeSchool(school string){
	s.school = school
}

// 为*Student(指针)结构体绑定一个changeSchool2方法 (指针类型的结构体,在函数中修改了数据会影响外部的数据)
func (s *Student) changeSchool2(school string){
	s.school = school
}

// 因此我们在调用结构体方法的时候,需要注意是什么结构体类型
func main(){
	// 实例化一个值类型的数据
	// 实例化一个结构体
	// 实例化的时候,可以只初始化部分数据
	zrp := Student{
		id:     1,
		name:   "zrp",
	} 

    // 结构体指针
	mc := &Student{
		id: 4,
		name: "mc",
	}

    // 使用结构体方法
    // 值结构(普通结构体)
	// 普通结构:外面的数据和函数中的数据是两个不同的数据,在函数内修改,不影响函数外
	zrp.changeSchool("湖南农业大学")
	fmt.Printf("新学校是:%v\n", zrp.school)
    // 输出为:新学校是: (没有传入值)

    // 指针结构体:外面和函数中是同一个数据,在函数中修改了,影响函数外
	mc.changeSchool2("湖南农业大学")
	fmt.Printf("新学校是:%v\n", mc.school)

}

输出:
新学校是:
新学校是:湖南农业大学

四、结构体继承:

package main

import "fmt"

// 创建Author作者结构体
type Author struct{
    // 定义字段
	name, tel string
	age int
}

// 继承:Book继承了Author结构体
type Book struct {
	title string
	author Author
}

// 给Book添加了一个结构体方法
func (b *Book) Print(){  
	fmt.Printf("%s的作者是:%s\n", b.title, b.author.name)
}

func main(){
	// 实例化方法
    // 先实例化Book,在将Author继承给Book
	b1 := Book{title: "《Go入门到精通》"}
	b1.author.name = "TeacherWen"
	b1.author.tel = "187xxxxxxx"
	fmt.Printf("%+v\n",b1)
	b1.Print()

	// 先实例化Author, 再把Author赋值给Book
	a1 := Author{name: "TeacherFeng"}
	b2 := Book{title: "《Docker从入门到精通》", author: a1}
	fmt.Printf("%+v\n",b2)
	b2.Print()
}

输出:
{title:《Go入门到精通》 author:{name:TeacherWen tel:187xxxxxxx age:0}}
《Go入门到精通》的作者是:TeacherWen
{title:《Docker从入门到精通》 author:{name:TeacherFeng tel: age:0}}
《Docker从入门到精通》的作者是:TeacherFeng

五、结构体多态:(interface接口的运用

多态:一个接口多个形态(为多个不同的数据类型提供统一的接口)
其实就是一个功能,展现多种形态
多态是指同一种操作或方法可以在不同的对象上产生不同的行为。

Go语言中实现多态需要用到interface

Interface接口类型可以定义一组方法(而非变量),并且不需要实现

// 定义一个函数MyPrint,我们可以通过MyPrint来使多个数据进行打印操作,但是当前MyPrint并不是多态的,需要下面的interface接口操作
// func MyPrint(s string){
// 	 fmt.Println("")
// }


// 如果WePay结构体实现了PayInterface接口所有的方法,那么可以说
// WePay结构是是PayInterface类型
type PayInterface interface {
	// 声明一些方法,但不需要实现
	// 方法名(参数列表) 返回值 --》pay()就为方法接口,他没有参数和返回值
	pay()
    // 可以定义多个方法接口
    // pay2()、

    // print()
    // 运行print()方法后报错:AliPay does not implement PayInterface (missing print method) 和 WePay does not implement PayInterface (missing print method)
    // 说明AliPay 和 WePay 没有实现print() 方法
    // 如果说WePay结构体和AliPay结构体实现了PayInterface接口所有的方法,那么可以说这个结构体是PayInterface的可以实现的接口类型。

// 下面我们将要实现微信支付和支付宝支付操作

// 定义微信支付结构体
type WePay struct {
	name string
}

// WePay实现了pay方法 等于  WePay实现PayInterface接口(wepay可以看作是PayInterface类型(上面定义的interface接口类型结构体))
func (w WePay) pay(){
	fmt.Printf("This is WePay:%s\n", w.name)
}

// 定义支付宝支付结构体
type  AliPay struct {
	name string
}

// AliPay实现PayInterface接口
func (a AliPay) pay(){
	fmt.Printf("This is AliPay:%s\n", a.name)
}

// 定义函数payment用于实现PayInterface接口的pay()方法
func payment(p PayInterface){
	p.pay()
}

func main(){
    // 实例化w1 和 a1,分别用于微信支付和支付宝支付
	w1 := WePay{name: "cici"}
	a1 := AliPay{name: "aiai"}
    // 调用payment函数传入实例,实现WePay和AliPay 
	payment(w1)
	payment(a1)
}

输出:
This is WePay:cici
This is AliPay:aiai

1、空接口的定义:

空接口可以表示任意类型的值。 空接口的作用在于可以在不确定类型的情况下,用于保存和传递各种不同类型的值。由于空接口可以表示任意类型的值,所以它在某些场景下非常有用,比如在函数参数中,可以接受不同类型的参数,或者在数据结构中,可以存储不同类型的元素。

package main

import "fmt"

// 空接口
type Empty interface {}

// 该test函数可以接收任意类型的数据,空接口的定义方式
func test(f interface{}){
	fmt.Printf("%v\n",f)
}

func main(){
	// 空接口的使用
	// 该实例希望它的方法是string类型,但是它的value值可以是任意类型的,如希望m1定义为:m1 = {"name":"cici", "age":20}这种value可以是任意类型的,因此我们可以定义一个空接口Empty interface
	// Empty结构体定义方式
	m1 :=map[string]Empty{
		"name":"cici",
		"age": 20,
	}

	//interface{}方法定义方式
	m2 :=map[string]interface{}{
		"name":"aiai",
		"age": "18",
	}
	fmt.Printf("%v\n%v\n", m1, m2)
}

输出:
map[age:20 name:cici]
map[age:18 name:aiai]

2、接口如何实现自定义error呢?

package main

import (

	"fmt"
    //"errors"
)

// 定义NameCheck函数,用于返回Error使用
// 如果name值为空,返回一个错误,否则就返回nil
func NameCheck(name string) error {  // 返回数据的类型是error类型
	if name == ""{
		// return errors.New("名字不能为空") // 通过errors包内New函数来进行error的提示, 比较复杂
		// 输出为:名字不能为空

		// 进行自定义错误(优点是比errors包内调用New方法简单快捷很多)
		return NameEmptyError{msg:"名字不能为空", code:1001}
		// 输出为:出错了:名字不能为空
	}
	return nil
}

// 自定义错误 => 给NameEmptyError实现一个Error方法,它就是一个error类型了
type NameEmptyError struct {
	msg string
	code int
}

// 定义NameEmptyError结构体方法Error()
func (e NameEmptyError) Error() string{
	// e.msg表示错误的信息
	return "出错了:"+e.msg
}

func main(){
	// 定义变量name
	name := ""

	// 调用NameCheck函数
	err := NameCheck(name)
	if err != nil{
		// 出现错误,输出错误
		fmt.Println(err)
	}else{
		fmt.Println(name)
	}
}

1、练习:判断Role(角色)是否存活

定义Role(角色) => 属性:name, blood, isAlive(是否存活)

isAlive => 判断blood是<=0 True or False

package main

import "fmt"

// 定义结构体
type Role struct {
	name string
	blood int
}

// 非指针型的绑定(将r 绑定为 Role 结构体) isAlive() 是一个函数
func (r Role) isAlive() bool{
	if r.blood <= 0{
		return false
	}else{
		return true
	}
}

// 指针型的绑定
//func (r *Role) isAlive() bool {
//	if r.blood <= 0{
//		return false
//	}else{
//		return true
//	}
//}

func main(){
	// 创建实例类型
	role1 := Role{"role1", 90}
	role2 := Role{"role2", 0}
	// 打印数据
	fmt.Printf("%s:%v\n", role1.name, role1.isAlive())
	fmt.Printf("%s:%v\n", role2.name, role2.isAlive())
}

输出:
role1:true
role2:false

2、练习:实现发邮件功能

功能介绍:

普通用户:结构体User => 字段:username, email, ShowUserInfo(), SendMail()

Root用户:结构体Root => 字段:username, email, ShowSysInfo(), SendMail()

邮件告警的功能 => sendNotification函数 --》可以接受所有权限用户

普通用户User和Root用户都能够使用sendNotification函数 => 并实现对对象的SendMail()

package main

import "fmt"

// 定义User结构体,内存字段username(用户名)、email(邮件地址)
type User struct {
	username string
	email string
}

// 定义Root结构体,内存字段username(用户名)、email(邮件地址)
type Root struct {
	username string
	email string
}

// 定义ShowUserInfo()结构体方法,调用User结构体,实现展示用户信息的功能
func (u User) ShowUserInfo(){
	fmt.Println("这是User的userInfo, User为:", u.username)
}

// 定义SendMail()结构体方法,调用User结构体,实现发送用户邮件的功能
func (u User) SendMail(){
	fmt.Printf("User:%s正在发送邮件到%s\n", u.username, u.email)
}

// 定义ShowSysInfo()结构体方法,调用Root结构体,实现展示Root信息的功能
func (r Root) ShowSysInfo(){
	fmt.Println("这是Root的sysInfo, Root为:", r.username)
}

// 定义SendMail()结构体方法,调用Root结构体,实现Root发送邮件的功能
func (r Root) SendMail(){
	fmt.Printf("Root:%s正在发送邮件到%s\n", r.username, r.email)
}

// 定义SendMailInterface结构体,内存SendMail()结构体方法
type SendMailInterface interface {
	SendMail()
}

// 定义sendNotification函数,作用是接收参数并作为SendMail的对象
func sendNotification(s SendMailInterface){
	s.SendMail()
}


func main()  {
	// 结构体实例化
	r := Root{username: "root", email: "root@sc.com"}
	u := User{username: "user1", email: "user1@sc.com"}
	// 调用sendNotification函数,并传入实例参数
	r.ShowSysInfo()
	sendNotification(r)
	u.ShowUserInfo()
	sendNotification(u)
}

输出:
这是Root的sysInfo, Root为: root
Root:root正在发送邮件到root@sc.com
这是User的userInfo, User为: user1
User:user1正在发送邮件到user1@sc.com

3、练习:定义标准化返回(json格式)

package main

/*
// 定义返回的数据格式,将返回的数据用json的方式打印出来
// Code, Message, Data
// s.json() => 将它转换成json格式(string)

后端开发:API => 访问url => 返回数据(无页面) => 访问者
标准化返回:
{
	"code": 1001,
	"message": "参数不完整",
	"data": {}/[]/other
}
*/
相关推荐
ModelBulider几秒前
SpringMVC应用专栏介绍
java·开发语言·后端·spring·springmvc
恬淡虚无真气从之2 分钟前
go 结构体方法
开发语言·后端·golang
licy__3 分钟前
Python BeautifulSoup 常用语句详解
开发语言·python·beautifulsoup
努力的Java程序员4 分钟前
后端接受大写参数(亲测能用)
java·开发语言
一雨方知深秋9 分钟前
WEB APIS(DOM对象,操作元素内容,属性,表单属性,自定义属性,定时器)
开发语言·前端·javascript
EasyNTS9 分钟前
视频流媒体播放器EasyPlayer.js网页直播/点播播放器:如何清除浏览器缓存
开发语言·javascript·缓存
天才少女爱迪生1 小时前
python代码制作数据集的测试和数据质量检测思路
开发语言·python·log4j
Stanford_11061 小时前
用c++做游戏开发至少要掌握哪些知识?
开发语言·c++·微信小程序·c·微信公众平台·twitter·微信开放平台
m0_748230211 小时前
【Spring Boot】Spring AOP中的环绕通知
spring boot·后端·spring
潘多编程1 小时前
动态定时任务在Spring Boot中集成Quartz的实践
java·spring boot·后端