Go语言数组与结构体嵌入模拟继承：定义、初始化及注意事项

准备条件

本教程内容基于Go语言的基础语法规则，主要涉及数据类型、变量声明及内存布局的基本概念。

数组的定义与特征

当需要批量存储相同类型的数据（如全班学生的成绩）时，数组是最基础的选择。数组是一系列同一类型数据的集合，在内存中开辟连续的空间。

第1步：数组定义与长度限制

目的：掌握固定长度数组的声明语法。

操作：使用 var 关键字定义数组，格式为 [长度]类型。注意，数组的长度必须是常量编译期可确定的值，不能是运行时可变的变量。

关键参数与状态：

• 数组元素默认值为对应类型的零值（如 int 为 0）。
• 数组长度不可变，使用内置函数 len() 获取。

package main
import "fmt"
func main() {
	// 定义长度为10的整型数组
	var a [10]int
	// 输出长度
	fmt.Println(len(a)) // 输出: 10
	// a[0] 默认为 0
}

结构体的定义与初始化

结构体（Struct）是用户自定义的类型，由一系列命名字段组成。

第2步：常规结构体初始化

目的：学习结构体的两种主要初始化方式。

入口：使用 {} 包裹初始化值。

操作说明：

1. 按序初始化：提供的值必须严格对应结构体定义的顺序。
2. 按名初始化：只写需要初始化的字段名和值，未指定的字段自动赋零值。

package main
import "fmt"
func main() {
	// 1. 定义结构体
	type Student struct {
		id   int
		name string
		age  int
		addr string
	}

	// 2. 按顺序初始化
	chary := Student{1, "chary", 18, "上海"}
	fmt.Println(chary)

	// 3. 按名称部分初始化 (未指明的字段自动归零)
	jeff := Student{name: "jeff"}
	fmt.Println(jeff) // {0 jeff 0 }

	// 4. 同类型赋值与比较
	user := jeff      // 直接拷贝
	fmt.Println(jeff == chary) // false
}

结构体“继承”机制（嵌入字段）

Go语言不支持传统的类继承，但支持将某个结构体作为另一个结构体的匿名字段（即嵌入）。这使得新结构体隐式包含内嵌结构体的所有字段和方法。

第3步：结构体嵌入与初始化

目的：理解如何组合多个结构体以及嵌套时的初始化语法。

操作：定义父结构体和子结构体，子结构体内包含父结构体的类型而非字段名。

注意点：初始化时，若需给嵌入结构体赋值，需显式写出其类型名。

package main
import "fmt"
type Person struct {
	name string
	sex  byte
	age  int
}
type Student struct {
	Person    // 嵌入匿名字段
	id       int
	addr     string
}
func main() {
	// 完整顺序初始化 (注意内部也要按Person的顺序)
	s1 := Student{Person{"mike", 'm', 18}, 1, "sz"}
	fmt.Printf("s1=%+v\n", s1)

	// 部分成员初始化
	s3 := Student{Person: Person{"lily", 'f', 19}, id: 2}
	fmt.Printf("s3=%+v\n", s3)
}

第4步：同名字段的访问规则

风险提醒：当内嵌结构体与新结构体拥有同名字段时，容易引发歧义。

操作说明：Go语言遵循“就近原则”，直接使用字段名访问的是当前层级（最外层）的字段；若要访问嵌入层级的字段，必须显式指明路径。

package main
import "fmt"
type Person struct {
	name string
	sex  byte
	age  int
}
type Student struct {
	Person
	id   int
	addr string
	name string // 新增同名字段
}
func main() {
	var s Student
	s.name = "mike"       // 赋值给Student自己的name
	s.Person.name = "yoyo" // 显式调用，赋值给Person的name
	fmt.Printf("%+v\n", s)
}

其他形式的嵌入

除了结构体之间的嵌入，Go还支持内置类型或指针类型的嵌入。

第5步：非结构体及指针类型嵌入

目的：探索更灵活的嵌套方式。

操作：可以将自定义类型、内置类型甚至指针类型作为匿名字段。

• 类型嵌入：可直接访问字段，如 s.int。
• 指针嵌入：类似于结构体嵌入，但当指针为 nil 时访问该字段会触发 panic。

package main
import "fmt"
type Person struct { name string; sex byte; age int }
type Student struct {
	*Person  // 指针类型嵌入
	id       int
	addr     string
}
func main() {
	// 初始化时传入地址
	s1 := Student{&Person{"mike", 'm', 18}, 1, "bj"}
	fmt.Printf("%+v\n", s1)
	fmt.Printf("%s,%c,%d\n", s1.name, s1.sex, s1.age) // 自动解引用

	var s2 Student
	s2.Person = new(Person) // 分配内存空间
	s2.name = "yoyo"
	fmt.Println(s2.name, s2.sex, s2.age, s2.id)
}

总结

Go语言的灵活性体现在其组合能力上。通过数组处理同质数据，通过结构体组合异质数据，而通过匿名嵌入（Embedding）实现代码复用与“继承”效果。在实际开发中需注意嵌入层级带来的字段可见性及初始化格式的规范。

以上就是Go语言数组及结构体继承和初始化示例解析的详细内容，更多关于Go语言高级数据结构设计的资料请关注本站其它相关文章！