9.13Go之结构体之类型内嵌和结构体内嵌

9.13Go之结构体之类型内嵌和结构体内嵌

类型内嵌和结构体内嵌的含义

概念：

• 结构体可以包含一个或多个匿名（或内嵌）字段--->这些字段没有显式的名字,只有字段的类型

• 类型也就是字段的名字。匿名字段本身可以是一个结构体类型，即结构体可以包含内嵌结构体。

这个概念在C当中也是一样的，这样的概念类似于Java当中的类的继承机制。可以使用父类的属性和公开的方法

示例代码：

需求：

• 实现一个结构体

• 实现另一个结构体，内嵌第一个结构体和一个匿名结构体

• 实例化第二个结构体来访问第一个结构体当中的成员并且初始化他们

package main
​
import "fmt"
​
/*
定义一个内嵌结构体
 */
type inner struct {
    num1 int
    num2 int
}
​
/*
定义另一个外部结构体嵌入内嵌结构体
 */
type outer struct {
    num3 int
    num4 float64
    //匿名结构体
    int
    //内嵌结构体
    inner
}
​
func main() {
    //实例化外部结构体
    outer1 := new(outer)
    //访问变量并且选择性的初始化
    outer1.num3 = 30
    outer1.int = 80
    outer1.num1 = 20 //这个成员在inner当中
    outer1.num2 = 30 //这个成员在inner当中
    //打印结果
    fmt.Printf("outer.num3 is:%d\n", outer1.num3)
    fmt.Printf("outer.int is:%d\n", outer1.int)
    fmt.Printf("outer.num1 is:%d\n", outer1.num2)
    fmt.Printf("outer.num2 is:%d\n", outer1.num2)
    fmt.Println("############################")
    //使用结构体字面量赋值
    outer2 := outer{6, 3.14, 60, inner{5, 8}}
    fmt.Printf("outer2 is:", outer2)
}

内嵌结构体

概念：

• 是一种数据类型，可以作为一个匿名字段来使用

• 外层结构体的实例可以直接进入内层结构体当中--->类似于继承的概念

可以从另外一个或一些类型继承部分或全部实现

示例代码：

package main
​
import "fmt"
​
/*
定义一个内嵌结构体
 */
type inner struct {
    num1 int
    num2 int
}
​
/*
定义另一个外部结构体嵌入内嵌结构体
 */
type outer struct {
    num3 int
    num4 float64
    //匿名结构体
    int
    //内嵌结构体
    inner
}

结构内嵌特性

• 内嵌的结构体可以直接访问其成员变量

  • 嵌入结构体的成员，可以通过外部结构体的实例直接访问

  • 如果有多层可以层层访问--->一次.下去

• 内嵌结构体的字段名是它的类型名

  • 示例代码：

  • var c Color
    c.BasicColor.R = 1
    c.BasicColor.G = 1
    c.BasicColor.B = 0

注意：

• 一个结构体只能嵌入一个同类型的成员，编译器在发现可能的赋值歧义时会报错。

构体内嵌模拟类的继承

概念：

• 面向对象思想中，实现对象关系需要使用“继承”特性。例如，人类不能飞行，鸟类可以飞行。人类和鸟类都可以继承自可行走类，但只有鸟类继承自飞行类。

• java或者c#从语言设计层面就禁止了多继承机制

Go语言的结构体内嵌特性就是一种组合特性

可以快速构建对象的不同特性

示例代码：

package main
​
import "fmt"
​
/*
定义一个飞行结构体--->和Java当中定义类不一样，是一种存在于类之上的抽象的东西
 */
type Flying struct {
    
}
​
/*
定义这个飞行结构体能够拥有的方法--->类似于Java中类的方法
由于结构体当中的特性，结构体当中只能够定义成员不能够定义函数
 */
func (f *Flying) Fly() {
    fmt.Println("can fly")
}
​
/*
定义一个可行走的结构体--->行走类
 */
type Walking struct {
    
}
​
/*
定义这个行走结构体当中的方法
 */
func (w *Walking) Walk() {
    fmt.Println("can walk")
}
​
/*
定义人类，人类能够行走不能飞--->到这里定义的人类的结构体才是类似于Java当中的类
内嵌的结构体相当于类当中的方法。只是Go当中使用了另外一种展现了面向对象的思想
 */
type Human struct {
    Walking
}
​
/*
定义鸟类
 */
type Bird struct {
    Flying
    Walking
}
​
func main() {
    //实例化人类
    hu := new(Human)
    fmt.Println("Human is:")
    hu.Walk() //访问到内嵌结构体当中的方法
    fmt.Println("##########")
    //实例化鸟类
    br := new(Bird)
    fmt.Println("Bird is:")
    br.Fly()
    br.Walk()
}

注意：

使用Go语言的内嵌结构体实现对象特性，可以自由地在对象中增、删、改各种特性