Go语言学习笔记5-结构体

结构体

type 类型名 struct {
字段 字段类型
}

• 实例化

1. var 实例化
   var ins T
2. new关键字
   ins := new(T)

//var实例化
type Point struct{
  x int
  y int
}
  
var p Point
p.x = 1
p.y = 2
  
//创建指针型结构体
type Player struct {
  Name string
  Health int
  Magic int
}
  
tank := new(Player)
tank.Name = "Canon"
tank.Health = 100
  
player := &Player{}
player.Name = "Azella"
player.Health = 100

---

• 初始化
  结构体可以在实例化时直接对成员变量进行初始化

1. 键值对

ins := 结构体类型名 {
字段1: 字段1值,
字段2: 字段2值,
…
}

2. 列表形式
   可以在键值对初始化的基础上忽略键
   • 必须初始化就够提所有字段
   • 每一个初始值的填充顺序必须与字段在结构体中的声明顺序一致
   • 键值对与值列表的初始化形式不能混用

ins := 结构体类型名 {
字段1的值,
字段2的值,
…
}

type Address struct {
  Province string
  City string
  ZipCode int
}
  
//键值对
addr1 := Address {
  Province: "四川"
  City: "成都"
  ZipCode: 610000,
}
  
//值列表
addr2 := Address {
  "四川",
  "绵阳",
  610000,
}

3. 初始化匿名结构体
   匿名结构体没有类型名称，无须通过type关键字定义就可以直接使用

package main
  
import (
	"fmt"
)
  
func main() {
	msg := &struct {      //定义部分
		id int
		data string
	}{                    //初始化部分
		1024,
		"hello",
	}
  
	PrintMsgType(msg)
}
  
func PrintMsgType(msg *struct{
	id int
	data string
}) {
	fmt.Printf("%T\n", msg)
}

---

• 构造函数
  Go语言的类型或结构体没有构造函数的功能，结构体的初始化过程可以使用函数封装实现

type Cat struct {
	Color string
	Name string
}
  
//BlackCat嵌入Cat结构体，类似面向对象中的派生
//实例化时BlackCat中的Cat也会一并实例化
type BlackCat struct {
	Cat
}
  
func NewCat(name string) *Cat {
	return &Cat{
		Name: name,
	}
}
  
func NewBlackCat(color string) *BlackCat {
	cat := &BlackCat{}
	cat.Color = color
	return cat
}

---

• 方法
  方法是一种作用于特定类型变量的的函数，这种特定类型变量叫做接收器
  1. 指针类型的接收器
     指针类型的接收器由一个结构体的指针组成，更接近于面向对象中的this或者self。调用方法时，修改接收器指针的任意成员变量，在方法结束后，修改都是有效的
  2. 非指针型的接收器
     当方法作用于非指针接收器时，接收器的值会复制一分，在方法中可以获取接收器的成员值，但修改后无效
  3. Go语言可以对任何类型添加方法

package main
  
import (
	"fmt"
)
  
type Property struct {
	value int
}
  
type Point struct {
	x int
	y int
}
  
//将int定义为MyInt类型
type MyInt int
  
//为MyInt添加方法
func (m MyInt) IsZero() bool {
	return m == 0
}
  
//非指针型
func (p Point) Add(other Point) Point {
	return Point{
		x: p.x + other.x,
		y: p.y + other.y,
	}
}
  
//指针型
func (p *Property) SetValue(v int) {
	p.value = v
}
  
//指针型
func (p *Property) Value() int {
	return p.value
}
  
func main() {
  //指针型
	p := new(Property)
	p.SetValue(100)
	fmt.Println(p.Value())
  
  //非指针型
	p1 := Point{1,1}
	p2 := Point{2,2}
	result := p1.Add(p2)
	fmt.Println(result)
}

---

• 类型内嵌和结构体内嵌
  结构体允许其他成员字段在声明时没有字段名而只有类型，这种形式的字段被称为类型内嵌或匿名字段
  同一个结构体重同类型的匿名字段只能有一个
  • 内嵌结构体可以直接访问其成员变量
  • 内嵌结构体的字段名是他的类型名

package main
  
import (
	"fmt"
)
  
type BasicColor struct {
	R, G, B float32
}
  
type Color struct {
	BasicColor
	Alpha float32
}
  
func main() {
	var c Color
	c.R = 1
	c.G = 1
	c.B = 0
	c.Alpha = 1
}

Donate