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嵌套了多个匿名结构体，那么这个结构可以直接访问多个匿名结构体的方法，从而实现了多重继承。