GO开发[五]:golang结构体struct

Go结构体struct

Go语言的结构体(struct)和其他语言的类(class)有同等的地位,但Go语言放弃了包括继承在内的大量面向对象特性,只保留了组合(composition)这个最基础的特性。

package main

import (
"fmt"
)
//声明
type Student struct {
Id int
Name string
age int
} func main() {
var s Student
s.Id =1
s.Name ="greg"
s.age=20
fmt.Println(s)
fmt.Printf("Name:%p\n", &s.Name)
fmt.Printf("Id:%p\n", &s.Id)
fmt.Printf("Age: %p\n", &s.age) s1 := Student {
Id :2,
Name:"gregory",
age:20,
}
fmt.Println(s1)
s1=s
fmt.Println(s1) var s2 *Student = &Student{
Id:3,
age: 20,
Name: "greg",
}
fmt.Println(s2)
}

结构体指针

package main

import "fmt"

//结构体指针
type Student struct {
Id int
Name string
} func main(){
s1 := Student{
Id :2,
Name:"greg",
}
fmt.Println(s1) var p *Student
p = &s1
p.Id =3
fmt.Println(s1) var p1 *int
p1 = &s1.Id
*p1 = 4
fmt.Println(s1)
}

结构体性质

结构体是用户单独定义的类型,不能和其他类型进行强制转换

package main

import "fmt"

type integer int

type Student struct {
Id int
} type Stu Student //alias func main() {
var i integer = 1000
var j int = 100
//j = i cannot use
j = int(i)
fmt.Println(j) var a Student
a = Student{30}
fmt.Println(a) var b Stu
//a=b cannot use
a = Student(b) //转换
fmt.Println(a)
}

我们可以为struct中的每个字段,写上一个tag。这个tag可以通过反射的机制获取到,最常用的场景就是json序列化和反序列化。

type student struct {
Id int “this is Id field”
Name stirng “this is name field”
}

序列化和反序列化

package main

import (
"fmt"
"encoding/json"
"log"
) type Student struct {
Id int
Name string
} func main(){
s := Student{
Id:1,
Name:"greg",
}
fmt.Println(s)
buf,err := json.Marshal(s)
if err != nil{
log.Fatalf("marshal error:%s",err)
}
fmt.Println(string(buf)) str := `{"Id":2,"Name":"alice"}`
var s2 Student
err1 := json.Unmarshal([]byte(str),&s2)
if err1 != nil {
log.Fatalf("unmarshal error:%s",err)
}
fmt.Println(s2)
}
//将Student map的数据写入到文件

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

访问匿名字段

package main

import (
"fmt"
"time"
) type Student struct {
name string
age int
} type Class struct {
Student
name string
int
Start time.Time
age int
} type School struct {
Student
Class
} func main() {
var t Class
t.Student.name = "stu"
t.Student.age = 100 t.name="cls"
t.age=80
t.int=2000
fmt.Println(t)
}

匿名字段冲突处理

package main

import (
"fmt"
) type Student struct {
name string
age int
} type Class struct {
name string
age int
} type School struct {
Student
Class
} func main() {
var t School
t.Student.name = "stu"
t.Class.name = "cls"
fmt.Println(t)
}

方法

Golang中的方法是作用在特定类型的变量上,因此自定义类型,都可以有方法,而不仅仅是struct

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

方法调用

package main

type Point struct {
X, Y float64
} func (p *Point) ScaleBy(factor float64) {
p.X *= factor
p.Y *= factor
} func main() {
//直接指针
p := &Point{1,2}
p.ScaleBy(2) //声明结构体后再用指针指向
p1 := Point{1,2}
p2 := &p1
p2.ScaleBy(2) //使用结构体调用,隐式取地址
p3 := Point{1,2}
p3.ScaleBy(2) //等价于(&p3).ScaleBy(2)
}

结构体方法调用:

package main

import "fmt"

type Student struct {
Id int
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("stu", 10, 200) stu1 := stu.get()
fmt.Println(stu1)
}

练习:两点之间的距离

package main

import (
"fmt"
"math"
) type Point struct {
X,Y float64
} func (p Point) Distance(q Point) float64 {
return math.Hypot(q.X-p.X, q.Y-p.Y)
} func main() {
p := Point{1,2}
q := Point{4,6}
fmt.Println(p.Distance(q))
}

方法和函数的区别:

函数调用: function(variable, 参数列表)
方法:variable.function(参数列表)

指针receiver和值receiver:本质上和函数的值传递和地址传递是一样的

方法的访问控制:可见性

通过首字母大小写来控制可见性

可见性是package级别的

继承:

如果一个struct嵌套了另一个匿名结构体,那么这个结构可以直接访问匿名结构体的方法,从而实现了继承。

package main

import "fmt"

type Student struct {
Id int
name string
} func (p *Student) Run() {
fmt.Println("greg")
} type Class struct {
Student
golang string
} type School struct {
gregs Student
} func main() {
var c Class
c.Id = 100
c.name = "greg2"
c.golang = "一班" fmt.Println(c)
c.Run() var sch School
sch.gregs.Id = 100
sch.gregs.name = "train"
fmt.Println(sch)
sch.gregs.Run()
}

组合和匿名字段:

​ 如果一个struct嵌套了另一个匿名结构体,那么这个结构可以直接访问匿名结构体的方法,从而实现了继承。

​ 如果一个struct嵌套了另一个有名结构体,那么这个模式就叫组合。

多重继承:如果一个struct嵌套了多个匿名结构体,那么这个结构可以直接访问多个匿名结构体的方法,从而实现了多重继承。

上一篇:IOS Socket 05-XMPP开始&安装服务器openfire&安装配置客户端


下一篇:一、JAVA环境变量配置详解——JavaWeb点滴