go语言学习笔记 — 基础 — 复合数据类型 — 结构体：类型内嵌与结构体内嵌（扩展和复用）

Posted 2021-11-08 Locutus

结构体内嵌类似OOP中的继承。

1. 类型内嵌

结构体允许其成员字段在声明时没有字段名，而只有类型。这种形式的字段称为匿名字段或类型内嵌。

type Data struct {
    int            // 定义结构体的匿名字段
    float32
    bool
}

ins := &Data{
    int: 10,       // 为Data实例中的字段赋初值
    float32: 3.14,
    bool: true,
}

结构体要求成员变量字段名称必须唯一，因此一个结构体中同类型的匿名字段只能有一个。

2. 声明结构体内嵌

如果匿名字段的类型为结构体，那么结构体实例化后，我们可以直接访问匿名结构体里的所有成员变量，此方式称为结构体内嵌。

• 传统写法

package main

import "fmt"

// 定义基础颜色
type BasicColor struct {
    R, G, B float32
}

// 定义完整颜色
type Color struct {
    Basic BasicColor    // 基础颜色结构体
    Alpha float32       // 透明度
}

func main() {
    var c Color         // 结构体实例化
    
    c.Basic.R = 1       // 访问结构体实例的结构体类型成员变量并赋值
    c.Basic.G = 1
    c.Basic.B = 0
    
    c.Alpha = 1
    
    fmt.Printf("%+v", c)
}

// {Basic:{R:1 G:1 B:0} Alpha:1}

• 结构体内嵌写法

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的匿名结构体里所有成员变量
    c.G = 1
    c.B = 0
    
    c.Alpha = 1
    
    fmt.Printf("%+v", c)
}

// {BasicColor:{R:1 G:1 B:0} Alpha:1}

3. 结构体内嵌特性

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

可以通过实例名直接访问嵌入结构体的成员变量。如果结构体有多层嵌入结构，通过实例访问任何一级嵌入结构成员变量时，只需给出字段名即可。如ins.a.b.c可以简写成ins.c。

• 结构体内嵌的类型名是它的成员变量字段名

结构体内嵌仍然可以使用传统方式进行一层层访问，结构体内嵌的类型名是它的成员变量字段名。

var c Color

c.BasicColor.R = 1
c.BasicColor.G = 1
c.BasicColor.B = 0

一个结构体只能嵌入一个同类型的成员，无须担心结构体重名和错误赋值。

4. 使用“组合”描述对象

在OOP中，实现对象关系需要使用“继承”特性，如人类不能飞行，鸟类可以飞行。人类和鸟类都可以从行走类继承，但只有鸟类从飞行类继承。OOP原则建议对象最好不要使用多重继承，鸟类同时继承行走类和飞行类，这显然是有问题的。在OOP中要正确实现对象多重继承，需要技巧。

go语言的结构体内嵌是一种组合，类似于OOP中的继承，可以快速构建对象的不同特性。

package main

import "fmt"

// 天上飞的 
type Flying struct {}

func (f *Flying) Fly() {
    fmt.Println("can fly")
}

// 地上走的
type Walking struct {}

// 给Walking结构体添加Walk方法
func (w *Walking) Walk() {
    fmt.Println("can walk")
}


// 结构体内嵌
// 人类
type Human struct {
    Walking
}

// 鸟类
type Bird struct {
    Walking
    Flying
}

func main() {
    b := new(Bird)         // 结构体实例化
    fmt.Println("Bird: ")
    b.Fly()                // 实例调用方法
    b.Walk()
    
    h := new(Human)
    fmt.Println("Human: ")
    h.Walk()
}


/*
Bird: 
can fly
can walk
Human: 
can walk
*/

使用go语言的结构体内嵌组合，可以自由地对实例进行实现增、删、改各种操作。

5. 初始化结构体内嵌

结构体内嵌初始化时，把结构体内嵌的类型作为成员变量字段名，像普通结构体一样初始化。

package main

import "fmt"

// 车轮，基础构件
type Wheel struct {
    Size int
}

// 引擎，基础构件
type Engine struct {
    Power int 
    Type string
}

// 车，整体结构，结构体内嵌
type Car struct {
    Wheel 
    Engine
}

func main() {
    c := Car {
        Wheel: Wheel{
            Size: 18,
        },
        
        Engine: Engine{
            Power: 143,
            Type: "1.4T",
        },
    }
    fmt.Printf("%+v\\n", c)
}

//{Wheel:{Size:18} Engine:{Power:143 Type:1.4T}}

6. 初始化匿名结构体内嵌

在初始化匿名内嵌结构体时，我们需要再次声明匿名结构体的结构，才能初始化赋值。使用“键值对”格式，初始化填充数据。

package main

import "fmt"

// 车轮，基础构件
type Wheel struct {
    Size int
}

// 车，整体结构
type Car struct {
    Wheel 
    Engine struct {    // 匿名内嵌结构体，匿名内嵌结构体不能被外部引用
        Power int 
        Type string
    }
}

func main() {
    c := Car {
        Wheel: Wheel{
            Size: 18,
        },
        
        Engine: struct { // 内嵌结构体类型名作为成员变量字段名
            Power int 
            Type  string
        }{
            Power: 143,
            Type: "1.4T",
        },
    }
    fmt.Printf("%+v\\n", c)
}

注：声明内嵌结构体时，多个成员之间换行不用","；在初始化赋值时，结构体成员变量之间要有","，这点需要注意。

7. 成员名字冲突

内嵌结构体内部可能有相同的成员名，成员重名会导致编译器无法选择是哪个内嵌结构体的成员变量字段，引起歧义和错误。

package main

import "fmt"

type A struct {
    a int
}

type B struct {
    a int
}

type C struct {
    A
    B
}

func main() {
    c := &C{}  // 内嵌结构体实例化
    c.A.a = 1  // 成员变量类型已经定义，所以不用:=类型推断赋值，而用=
    fmt.Println(c)
    
    // c.a = 1  
    // fmt.Println(c)
}

// &{{1} {0}}