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

这篇具有很好参考价值的文章主要介绍了go 结构体 - 值类型、引用类型 - 结构体转json类型 - 指针类型的种类 - 结构体方法 - 继承 - 多态(interface接口) - 练习。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、结构体

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

2、初用GO中的结构体：（实例化一个值类型的数据（结构体））

输出结果不同的三种方式

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

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的结构体。该结构体有两个字段，分别为Name和Age，分别用来存储人的姓名和年龄。

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

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、实例化一个引用类型的数据（结构体）（指针类型）

定义的两种方式：

1、mq := new(Student) （创建之后，只分配了内存，因此不能直接定义数据）

2、mq := &Student{ .... } (可以直接赋予初始值)

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"}
    // （如果指定了字段名，只需要给对应的字段名赋值即可）
    // wbw := Student{id:2, name:"wbw"}

    // 实例化一个引用类型的数据
	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

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

go 结构体 - 值类型、引用类型 - 结构体转json类型 - 指针类型的种类 - 结构体方法 - 继承 - 多态(interface接口) - 练习,golang,开发语言,后端

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类型

结构体可以直接转换为json格式

go 结构体 - 值类型、引用类型 - 结构体转json类型 - 指针类型的种类 - 结构体方法 - 继承 - 多态(interface接口) - 练习,golang,开发语言,后端

json.Marshal( 结构体实例 )

json字符串一般key都是由小写组成

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  // 大写开头表示公开
    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

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

结构体的定义方式：

func (结构体形参结构体类型) 函数名(函数参数) 函数返回值 { .... }

两种定义方式：值类型结构体、指针类型结构体

值类型结构体：在函数内部修改数据并不会影响函数外面

指针类型结构体：在函数中修改了数据会影响外部的数据

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格式）

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

后端开发：API => 访问url => 返回数据（无页面） => 访问者
标准化返回：
{
	”code": 1001,
	"message": "参数不完整“,
	"data": {}/[]/other
}
*/

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"os"
)

//标准化返回的结构
type Response struct {
	Code int  `json:"code"`
	Message string  `json:"message"`
	Data interface{} `json:"data"`
}
// 从后端获取数据，将其变为标准化的结构
func Getdata() Response {
	code := 1001
	message := "参数不完整"
	data := map[string]interface{}{
		"name": "North",
		"sex": "male",
		"age": "21",
		"email":"north.12468@gmail.com",
	}
	// 创建实例
	res := Response{
		Code: code,
		Message: message,
		Data: data,
	}
	return res
}

func main()  {
	filepath := "./暑假开发/2023-08-01-go结构体/data.json"
	result := Getdata()
	// 将后端的数据转换为json格式
	jsonresult,err := json.Marshal(result)
	if err != nil {
		fmt.Println("json错误：",err)
		return
	}else {
		//直接输出
		fmt.Println(string(jsonresult))

		//写入data.json文件中
		file,err1 := os.OpenFile(filepath,os.O_RDONLY|os.O_WRONLY,0666)
		if err1 != nil {
			fmt.Println("打开文件失败")
		}
		defer file.Close()
		write := bufio.NewWriter(file)
		write.WriteString("\n")
		write.WriteString(string(jsonresult))
		write.Flush()
	}
}

type ResponseData struct {
	Code	int		`json:"code"`
	Message	string	`json:"message"`
	Data	interface{}	`json:"data"`
}
func (r ResponseData) json() (string, error){
	data, err := json.Marshal(r)
	return string(data), err
}
func main(){
	r := ResponseData{1001, "失败了", ""}
	data, err := r.json()
	fmt.Printf("数据:%v,错误:%v\n", data, err)
}

文章来源地址https://www.toymoban.com/news/detail-622018.html

到了这里，关于go 结构体 - 值类型、引用类型 - 结构体转json类型 - 指针类型的种类 - 结构体方法 - 继承 - 多态(interface接口) - 练习的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！