Golang结构体入门-蒲公英云

" class="reference-link">

结构体基础

结构体示例

为结构体定义方法

组合结构体

嵌套结构体

指针结构体

匿名字段

面向对象

封装

继承

多态

结构体基础

1.结构体是值类型：在Go语言中，结构体是一种值类型，与数组和基本数据类型一样。当结构体被赋值给一个变量或传递给一个函数时，它的值会被复制一份。因此，对复制的结构体进行修改不会影响原来的结构体。

2.结构体可以定义方法：在Go语言中，结构体可以定义方法，方法是与特定类型关联的函数，可以访问和操作结构体的字段。方法的定义语法与函数类似，但需要在函数名前加上接收者，接收者可以是值类型或指针类型。

3.结构体的字段可以使用标签：在Go语言中，可以给结构体的字段加上一个标签（tag），用来描述该字段的一些元数据信息，比如字段名、数据类型、校验规则等。标签的内容可以通过反射机制进行读取和修改。

4.结构体可以进行序列化和反序列化：在Go语言中，结构体可以通过序列化和反序列化的方式进行数据的编码和解码。序列化是将数据结构转换成二进制格式的过程，反序列化是将二进制格式的数据解析成数据结构的过程。常用的序列化方式包括JSON、XML、Protobuf等。

5.结构体字段的命名规范：在Go语言中，结构体字段的命名规范是使用驼峰命名法，即首字母小写，每个单词的首字母大写。这种命名方式可以提高代码的可读性和可维护性。

在Go语言中，结构体是一种自定义的数据类型，它由一组数据字段组成，每个字段可以是任意类型。结构体可以用于描述一些复杂的数据结构，比如记录、链表、树等。

结构体的定义如下：

type StructName struct {
    Field1 type1
    Field2 type2
    ...
    FieldN typeN
}

结构体示例

下面是一个结构体的示例：

package main
import "fmt"
type Person struct {
    Name string
    Age  int
}
func main() {
    p := Person{
        Name: "Tom", 
        Age: 20,
    }
    fmt.Println(p)
    fmt.Printf("Name: %s, Age: %d\n", p.Name, p.Age)
}

在上面的示例中，我们定义了一个Person结构体，它包含两个字段：Name和Age。在main函数中，我们创建了一个Person类型的变量p，并初始化其Name和Age字段。最后，我们输出了这个变量的值，以及它的Name和Age字段的值。

为结构体定义方法

除了定义结构体之外，我们还可以为结构体定义方法。方法是一种与特定类型关联的函数，可以访问和操作结构体的字段。

下面是一个为Person结构体定义方法的示例：

package main
import "fmt"
type Person struct {
    Name string
    Age  int
}
func (p Person) SayHello() {
    fmt.Printf("Hello, my name is %s, and I am %d years old.\n", p.Name, p.Age)
}
func main() {
    p := Person{
        Name: "Tom", 
        Age: 20,
    }
    p.SayHello()
}

在上面的示例中，我们为Person结构体定义了一个SayHello方法，该方法输出一个字符串，包含Person的Name和Age字段的值。在main函数中，我们创建了一个Person类型的变量p，并调用了它的SayHello方法。

组合结构体

Go语言中的结构体也可以通过组合来实现复用的功能，具体实现方法如下：

package main
import "fmt"
type Person struct {
    Name string
    Age  int
}
type Student struct {
    P      Person // 组合了Person结构体
    School string
}
func main() {
    s := Student{
        Person{"Tom", 18}, 
        "High School",
    }
    fmt.Println(s.P.Name, s.P.Age, s.School) // 输出 Tom 18 High School
}

这段代码中定义了一个Person结构体，包含Name和Age两个字段，另外定义了一个Student结构体，它组合了Person结构体。在main函数中，我们通过构造函数创建了一个Student实例s，并访问了它的Name、Age和School字段，需要通过s.P来访问Person结构体中的字段。

通过组合其他结构体，子结构体可以复用父结构体中的字段和方法，但是它不会继承父结构体的特性和行为。与继承相比，组合更加灵活和简单，但也需要开发者更多的手动操作。

需要注意的是，Go语言中没有类的概念，因此结构体不是类，它不能实现继承和多态等面向对象的特性，而是一种数据类型的定义方式。

嵌套结构体

可以在结构体中嵌套另一个结构体，从而形成一个复合的结构体类型。嵌套结构体可以直接使用内部结构体的字段，也可以通过内部结构体名来访问内部结构体的字段。

例如：

package main
import "fmt"
type Address struct {
    Province string
    City     string
}
type Person struct {
    Name    string
    Age     int
    Address Address
}
func main() {
    p := Person{Name: "Tom", Age: 18, Address: Address{Province: "Beijing", City: "Chaoyang"}}
    fmt.Println(p.Name, p.Age, p.Address.Province, p.Address.City)
}

指针结构体

结构体变量通常会占用比较大的内存空间，为了节省内存，可以使用指针结构体。指针结构体可以通过&操作符获取结构体变量的地址，并通过*操作符访问结构体变量的值。

例如：

package main
import "fmt"
type Person struct {
    Name string
    Age  int
}
func mian() {
    p:= &Person{
        Name: "Tom", 
        Age: 18,
    }
    fmt.Println((*p).Name, (*p).Age) // 输出：Tom 18
    fmt.Println(p.Name, p.Age)       // 输出：Tom 18
}

匿名字段

可以将一个结构体类型作为另一个结构体类型的字段，这个字段就称为匿名字段。匿名字段的类型可以是任意类型，可以是基本类型、结构体类型、指针类型等。匿名字段可以直接访问内部结构体的字段，也可以通过内部结构体名来访问内部结构体的字段。

例如：

package main
import "fmt"
type Address struct {
    Province string
    City     string
}
type Person struct {
    Name string
    Age  int
    Address
}
func main() {
    p := Person{Name: "Tom", Age: 18, Address: Address{Province: "Beijing", City: "Chaoyang"}}
    fmt.Println(p.Name, p.Age, p.Province, p.City)
}

面向对象

Go语言虽然不是一种纯面向对象编程语言，但它提供了一些面向对象编程的基本特性，比如封装、继承和多态等。

封装

Go语言通过大写字母开头的字段或方法来实现封装，这些字段或方法可以在包外部访问。小写字母开头的字段或方法则只能在当前包内部访问。

例如：

package main
import "fmt"
type Person struct {
    name string
    age int
}
func (p *Person) SayHello() {
    fmt.Println("Hello, my name is", p.name, ", I'm", p.age, "years old.")
}
func main() {
    p := &Person{"Tom", 18}
    p.SayHello()
}

在上面的代码中，我们定义了一个名为Person的结构体，它有两个字段name和age，并且定义了一个方法SayHello，用于打印个人信息。在main函数中，我们创建了一个Person对象p，并调用它的SayHello方法，输出了它的信息。

继承

Go语言不支持传统的继承方式，但是可以通过结构体组合的方式实现继承。具体来说，我们可以在一个结构体中包含另一个结构体，并通过嵌套结构体的方式来继承其字段和方法。

例如：

package main
import "fmt"
type Person struct {
    name string
    age  int
}
func (p *Person) SayHello() {
    fmt.Println("Hello, my name is", p.name, ", I'm", p.age, "years old.")
}
type Student struct {
    Person
    score int
}
func main() {
    s := &Student{Person{"Tom", 18}, 90}
    s.SayHello()
    fmt.Println("My score is", s.score)
}

在上面的代码中，我们定义了两个结构体Person和Student，Student结构体包含了一个Person类型的字段，并且定义了一个自己的score字段。在main函数中，我们创建了一个Student对象s，并调用它的SayHello方法，输出了它的信息，然后输出了它的成绩。

多态

Go语言不支持传统的多态方式，但是可以通过接口实现多态。具体来说，我们可以定义一个接口，并让不同的结构体实现这个接口，从而实现多态。

例如：

package main
import "fmt"
type Animal interface {
    Say()
}
type Cat struct{}
func (c *Cat) Say() {
    fmt.Println("Meow!")
}
type Dog struct{}
func (d *Dog) Say() {
    fmt.Println("Woof!")
}
func main() {
    var a Animal
    a = &Cat{}
    a.Say()
    a = &Dog{}
    a.Say()
}

这段Go语言代码定义了一个Animal接口和两个实现了该接口的结构体：Cat和Dog。Animal接口中只有一个Say()方法。Cat和Dog分别实现了Say()方法并输出相应的声音。在main函数中，定义了一个a变量，类型为Animal接口。首先将a赋值为一个Cat结构体的指针，然后调用a的Say()方法输出”Meow!”。接着将a赋值为一个Dog结构体的指针，再次调用a的Say()方法输出”Woof!”。