golang基础-结构体tag、匿名字段、结构体的方法(作用域)、继承、String()方法

struct中的tag

我们可以为struct中的每个字段，写上一个tag。这个tag可以通过反射的

机制获取到，最常用的场景就是json序列化和反序列化

package main

import "fmt"
import "encoding/json"

type student struct {
Name string `json:"stu_name"`
Age int
}

func main() {
var stu student = student{
Name:"safly",
Age:10,
}

data,err := json.Marshal(stu)

if err != nil{
fmt.Println("json encode stu failed",err)
return
}

fmt.Println(string(data))

}

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
{"stu_name":"safly","Age":10}
PS E:\golang\go_pro\src\safly>

匿名字段

结构体中字段可以没有名字，即匿名字段

package main

import (
"fmt"
)

type student struct {
name string
age int
}

type stu struct{
student
int
}

func main() {
var stu1 stu
stu1.name = "saly"
stu1.age =10
stu1.int = 100

fmt.Println(stu1)
fmt.Println("---------------------")

var stu2 stu
stu2.name = "salyyy"
stu2.age =100
stu2.int = 1000
//都设置age name时候，就看自己的
stu2.student.name = "ss"
stu2.student.age = 11
fmt.Println(stu2)

}

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
{{saly 10} 100}
---------------------
{{ss 11} 1000}
PS E:\golang\go_pro\src\safly>

方法

[b]方法作用在结构体上[/b]

Golang中的方法是作用在特定类型的变量上，因此自定义类型，都可以

有方法，而不仅仅是struct

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

package main

import (
"fmt"
)

type Student struct {
Name string
Age int
Score int
}
/*结构体方法*/
func (p Student) init(name string,age int ,score int){
p.Name = name
p.Age = age
p.Score = score
fmt.Println(p)
}

func (p Student)get() Student{
return p
}

func main() {
var stu Student
stu.init("safly",1,1)
stu1 := stu.get()

fmt.Println(stu1)
fmt.Println(stu)

}

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
{safly 1 1}
{ 0 0}
{ 0 0}
PS E:\golang\go_pro\src\safly>

我们发现上例中init方法没有修改对象的值，我们接下来修改下代码如下：

/*结构体方法*/
func (p *Student) init(name string,age int ,score int){
p.Name = name
p.Age = age
p.Score = score
fmt.Println(p)
}

看看输出结果：

PS E:\golang\go_pro\src\safly> go run demo.go
&{safly 1 1}
{safly 1 1}
{safly 1 1}
PS E:\golang\go_pro\src\safly>

当然我们还可以在上例修改的基础上，在此修改如下代码

var stu Student
(&stu).init("safly",1,1)
stu1 := stu.get()

fmt.Println(stu1)
fmt.Println(stu)

结果输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
&{safly 1 1}
{safly 1 1}
{safly 1 1}
PS E:\golang\go_pro\src\safly>

[b]方法作用在其他变量上[/b]

我们看下讲方法作用在其他的变量类型上

package main

import (
"fmt"
)

type mInt int

func (p mInt)onInt(){
fmt.Println("p is",p)
}

func (p *mInt)set(b mInt){
*p = b
}

func main() {
var a mInt =100
fmt.Println(a)

a.onInt()
//&a是传递内存地址值，当时如果传a
//go会自动转换成内存地址来看待所以都是可以的
a.set(200)
(&a).set(200)
fmt.Println(a)
}

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
100
p is 100
200
PS E:\golang\go_pro\src\safly>

继承

如果一个struct嵌套了另一个匿名结构体，那么这个结构可以直接访问

匿名结构体的方法，从而实现了继承。

package main

import (
"fmt"
)

type Car struct{
weight int
name string
}

func (p *Car)Run(){
fmt.Println("running")
}
/*继承Car*/
type Bike struct{
Car
lunzi int
}
/*继承Car*/
type Train struct{
Car
}
func main() {
var bike Bike
bike.weight = 100
bike.name = "bike"
bike.lunzi = 4
fmt.Println(bike)
bike.Run()

fmt.Println("-------")
var train Train
train.weight = 111
train.name = "train"
fmt.Println(train)
train.Run()
}

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
{{100 bike} 4}
running
-------
{{111 train}}
running
PS E:\golang\go_pro\src\safly>

String

如果一个变量实现了String()这个方法，那么fmt.Println默认会调用这个

变量的String()进行输出。

package main

import (
"fmt"
)

type Car struct{
weight int
name string
}

func (p *Car)Run(){
fmt.Println("running")
}

/*继承Car*/
type Train struct{
Car
}
/*
如果一个变量实现了String()这个方法，
那么fmt.Println默认会调用这个
变量的String()进行输出。
*/
func (t *Train)String() string{
str:= fmt.Sprintf("name=%s weight=%d",(*t).name,(*t).weight)
return str
}

func main() {
var train Train
train.weight = 1111
train.name = "train"
fmt.Println(train)
train.Run()

fmt.Printf("%s",&train)
}

输出如下：

PS E:\golang\go_pro\src\safly> go run demo.go
{{1111 train}}
running
name=train weight=1111
PS E:\golang\go_pro\src\safly>