复合类型

复合类型是由其他类型组成的类型。主要的复合类型有数组、切片、映射、结构体等。

数组

在 Go 中，数组是相同类型元素的固定长度序列。数组的大小是其类型的一部分，一旦声明，就不能改变大小。

package main

import "fmt"

func main() {
    // 声明一个有固定大小为5的整数数组
    var intArray [5]int

    // 初始化数组
    intArray = [5]int{1, 2, 3, 4, 5}

    // 访问元素
    fmt.Println(intArray[2]) // => 3
}

切片

切片是一种轻量级的数据结构，它包装了一个数组，并提供了一种访问该数组部分元素的方式。 切片是动态的，可以增长或缩小，因此比数组更灵活。

package main

import "fmt"

func main() {
    // 声明一个整数切片
    var intSlice []int

    // 向切片追加元素
    intSlice = append(intSlice, 1, 2, 3, 4, 5)

    // 访问元素
    fmt.Println(intSlice[2]) // => 3
}

排序

在 Go 中，通常使用 sort 包进行排序，该包提供了用于对切片和其他数据结构进行排序的函数。

package main

import (
	"fmt"
	"sort"
)

func main() {
	// 对整数进行排序
	intSlice := []int{4, 2, 7, 1, 9, 3}
	fmt.Println("Before sorting:", intSlice)

	sort.Ints(intSlice)
	fmt.Println("After sorting:", intSlice)
}

也可以对字符串进行排序。

package main

import (
	"fmt"
	"sort"
)

func main() {
	// 对字符串进行排序
	strSlice := []string{"banana", "apple", "orange", "grape"}
	fmt.Println("Before sorting:", strSlice)

	sort.Strings(strSlice)
	fmt.Println("After sorting:", strSlice)
}

映射

映射是键值对，每个键必须是唯一的。它提供了一种根据键查找值的高效方式。

package main

import "fmt"

func main() {
    // 声明并初始化一个映射
    person := map[string]int{
        "Alice": 25,
        "Bob":   30,
        "Charlie": 35,
    }

    // 访问值
    fmt.Println(person["Bob"])
}

结构体

结构体通过将不同类型的变量组合到一个实体中来创建自定义数据类型。

package main

import "fmt"

// 定义一个结构体
type Person struct {
    Name string
    Age  int
}

func main() {
    // C创建一个 Person 结构体的实例
    alice := Person{
        Name: "Alice",
        Age:  25,
    }

    // 访问字段
    fmt.Println(alice.Name)
}

嵌入

结构体嵌入是通过在结构体内部包含另一类型的匿名字段来实现组合的一种方式。这允许你在新类型中复用已有类型的字段和方法。

package main

import "fmt"

type Person struct {
	Name string
	Age  int
}

type Employee struct {
	Person // 嵌入 Person 结构体
	EmployeeID int
}

func main() {
	// 创建嵌套结构体的实例
	employee := Employee{
		Person:     Person{Name: "Alice", Age: 25},
		EmployeeID: 12345,
	}

	// 嵌套结构体访问字段
	fmt.Println("Name:", employee.Name)
	fmt.Println("Age:", employee.Age)
	fmt.Println("Employee ID:", employee.EmployeeID)
}

指针

指针是存储另一个变量内存地址的变量。它指向存储实际值的内存位置。Go 中的指针允许你间接访问变量的值，其常用于动态内存分配。

package main

import "fmt"

func main() {
    var num int = 42

    // 声明指向变量的指针
    var ptr *int = &num

    // 通过指针访问值
    fmt.Println("Value:", *ptr) // => 42
}

接口

接口是指定一组方法签名的类型。如果一个类型实现了接口的所有方法，就称为该类型满足或实现了该接口。Go 中的接口提供了实现多态和将实现与接口定义解耦的方法。

package main

import "fmt"

// 定义一个接口
type Shape interface {
    Area() float64
}

// 为 Circle 实现接口
type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

func main() {
    // 创建 Circle 实例
    circle := Circle{Radius: 5.0}
    fmt.Println("Area:", circle.Area()) // => Area: 78.5
}

代码挑战

使用 Go 创建一个简单的书库系统。定义一个 Book 结构体，具有以下字段：

• Title (string)
• Author (string)
• ISBN (string)
• Quantity (int)