Golang 嵌套结构

在Golang中，嵌套结构是一种非常常见的用法，它可以让我们在复杂的数据结构中轻松、简洁地访问和操作各个成员。

嵌套结构的定义

首先，让我们来看一个简单的嵌套结构的定义和初始化例子：

type Address struct {
    city    string
    country string
}

type Person struct {
    name    string
    age     int
    address Address
}

其中，我们定义了两个结构体：Address和Person。Address表示地址信息，包含了city和country两个属性；Person则表示人物信息，包含了name、age和address三个属性。可以看到，在Person结构体中，我们使用了另一个结构体Address作为其中一个属性的类型，这就是嵌套结构体。

接下来，我们来初始化一个Person对象，并访问其中的属性：

person := Person{
    name: "Tom",
    age:  18,
    address: Address{
        city:    "Beijing", 
        country: "China",
    },
}
fmt.Println(person.name, person.age, person.address.city, person.address.country)
// Tom 18 Beijing China

在初始化Person对象时，我们需要先初始化其中的嵌套结构体Address，并将其作为Person的属性赋值。在访问Person对象的属性时，我们可以直接通过“.”的方式来访问嵌套结构体中的属性，如person.address.city。

除了直接定义嵌套结构体作为属性，我们还可以在结构体中使用匿名嵌套结构体。

type Person struct {
    name string
    age  int
    Address
}

在这里，我们省略了Address结构体的定义，直接将其作为Person结构体的属性。这样，在初始化Person对象时，我们就可以更加简洁地表示：

person := Person{
    name: "Tom",
    age:  18,
    Address: Address{
        city:    "Beijing", 
        country: "China",
    },
}

嵌套结构的访问

在使用嵌套结构体时，我们可以通过“.”的方式来直接访问嵌套结构体中的属性，如person.address.city。但是，在嵌套结构体中，可能会出现同名的属性。

type Person struct {
    name    string
    age     int
    address struct{
        city  string
        state string
    }
}

person := Person{
    name: "Tom",
    age:  18,
    address: struct{city, state string}{"Beijing", "China"},
}

这里，我们定义了一个Person结构体，其中嵌套了一个匿名结构体，该结构体中有一个city属性和一个state属性。在初始化Person对象时，我们通过直接定义了一个匿名结构体并赋值，来初始化嵌套的匿名结构体。

当访问Person结构体的属性时，我们需要特别注意，因为同名属性的存在，访问“.属性名”时，并不确定其是哪个结构体中的属性。此时，需要在“.结构体名.属性名”的方式中明确区分。

fmt.Println(person.address.city) // 编译错误
fmt.Println(person.address.city) // Beijing
fmt.Println(person.address.state) // 编译错误
fmt.Println(person.address.struct{city:"Beijing", state:"China"}.state) // China

嵌套结构的继承

在Golang中，嵌套结构其实可以看做是一种继承关系。我们可以利用嵌套结构的特点，实现“继承”一些属性和方法，来避免代码重复。

// 定义一个父类结构体`Vehicle`
type Vehicle struct {
    weight float64
    height float64
}

// 定义一个子类结构体`Car`
// `Vehicle`作为`Car`的匿名字段，实现属性继承
type Car struct {
    brand string
    Vehicle
}

// 定义一个`Car`中的方法
func (c *Car) run() {
    fmt.Println(c.brand, "is running")
}

// 初始化一个`Car`对象，并访问其中的属性和方法
car := Car{brand: "BMW", Vehicle: Vehicle{weight: 1.5, height: 1.2}}
fmt.Println(car)
// {BMW {1.5 1.2}}
car.run()
// BMW is running

在这里，我们定义了一个父类结构体Vehicle，其中包含了weight和height两个属性。接着，我们定义了一个子类结构体Car，其中用匿名字段的方式，嵌套了之前定义的Vehicle结构体，实现了属性继承。

在Car中，我们又定义了一个run()方法，来实现对Car对象的操作。最后，我们初始化了一个Car对象，并通过“.属性名”的方式来访问其中的属性和方法。