Go 语言入门指南：基础语法和常用特性解析 | 豆包MarsCode AI刷题

Go 语言入门指南：基础语法和常用特性解析

---

一、Hallow World

1、在vscode中新建GO项目

创建文件夹，打开文件夹终端,在终端中输入go mod init Day1.

Go 的依赖管理系统是比较现代化的，相比于传统的 GOPATH 模式，go.mod 带来了更简洁的依赖控制。这种设计受到了现代编程语言（如 Rust 和 Python）影响，使得开发者能更轻松地管理依赖关系，从而加快开发流程。

创建文件hello.go，写如下代码。

// package main 声明了这个文件属于 main 包，每个 Go 程序都必须包含一个 main 包。
package main

// import "fmt" 导入了 fmt 包
import "fmt"

// func main() 定义了程序的入口点，每个可执行的 Go 程序都必须有一个 main 函数。
func main() {
	// fmt.Println("Hello, world!") 使用 fmt 包中的 Println 函数在控制台输出 "Hello, world!"。
	fmt.Println("Hello, world!")
}

标识符

在 Go 语言中，标识符是变量、常量、函数、类型和包等命名的基础，直接影响代码的可读性和可维护性。标识符必须符合一定的规则：只能使用字母、数字和下划线，且不能以数字开头。此外，Go 是区分大小写的语言，标识符首字母的大写或小写决定了其可见性。

在 Go 中，小写字母开头的标识符仅在包内可见，而大写字母开头的标识符在包外也可见。这种设计为代码的封装和模块化提供了便利，因为我们可以根据标识符的命名明确其作用范围。例如，库的开发者可以使用小写标识符来隐藏内部实现，确保用户只能访问对外提供的接口。

这种大小写区分的方式让代码变得更直观，无需特别的关键字来限定可见性，简单直观。这也在一定程度上约束了代码的设计，促使开发者遵循模块化的思想，将不对外暴露的逻辑限制在包内，增强了代码的封装性。

导包

在 Go 语言中，导入包的方式有两种，分别是单行导入和分组导入。

单行导入

可以逐行导入包，每个 import 语句对应一个包：

import "fmt"
import "math"

这种方式适合在只导入少量包的情况下使用，但对于依赖较多的文件，会显得冗余。

分组导入

Go 还提供了一种更加简洁的分组导入方式，用一个 import 语句包裹多个包：

import (
    "fmt"
    "math"
)

这种方式在需要导入多个包时更为简洁，代码结构清晰且便于管理，是推荐的方式。在 Go 语言开发中，分组导入已经成为一种惯用写法，有助于维护代码的整洁性。

分组导入让代码显得更为整齐清晰，特别是在大型项目中，按功能分组导入依赖包能够提升代码的可读性。而单行导入在特定场景下也有其用途，比如在条件编译的代码片段中，这两种方式的灵活组合可以让代码更具适应性和可维护性。

2、启动GO程序

• 可以使用终端命令行启动GO程序，在命令行里输入go run hello.go命令。可以在终端看到Hello, world!的字样。
• 还可以使用go build命令来生成二进制文件：

$ go build hello.go 
$ ls
hello    hello.go
$ ./hello 
Hello, World!

• 也可以用vscod的插件来启动go程序。安装插件Code Runner。

在编码区点击鼠标右键弹出菜单,点击"Run Code"或按下快捷键"Ctrl + Alt + N"。下面输入区框架自动弹出并切换到"Output"窗口,显示代码结果。 查看Code Runner使用详情

---

二、GO语言基础语法

1、注释

注释不会被编译，每一个包应该有相关注释。

go语言注释分为单行注释、多行注释（块注释）。

• 行注释是以//开头的注释，用于在单行中注释代码。行注释通常用于解释特定行的作用、实现细节、注意事项等。

// 这是一个行注释示例 fmt.Println("Hello, World!")

• 块注释是以/*开头和*/结尾的注释，可以跨多行注释代码块。块注释通常用于注释函数、方法、包、重要功能模块等。

/* 
这是一个块注释示例 
可以跨多行注释 
*/ 
fmt.Println("Hello, World!")

2、变量与函数

变量

go语言中，变量可以用var声明且将变量的类型放在最后。

var i, j int = 1, 2

func main() {
	var c, python, java = true, false, "no!"
	fmt.Println(i, j, c, python, java)
}

在函数中，也可以用短赋值语句 := 。但函数外的每个语句都 必须 以关键字开始（var、func 等），因此 := 结构不能在函数外使用。

func main() {
	var i, x int = 1, 2
	k := 3
	java := "no!"

	fmt.Println(i, x, k,java)
}

其中没有明确初始化的变量会被赋予对应类型的零值。

例如：

• 数值类型为 0，
• 布尔类型为 false，
• 字符串为 ""（空字符串）。

类型转换

在go语言中使用将要转换的类型包裹要转换的值进行类型转换。

func main() {
	x := 42
	y := float64(x)
	z := uint(y)
	fmt.Println(x, y, z)
}

与 C 不同的是，Go 在不同类型的项之间赋值时需要显式转换。如果在上述程序中z := uint(y)转换时将uint 的类型转换去掉，程序就会报错

cannot use x (variable of type float64) as uint value in variable declaration

常量

常量的声明与变量类似，只不过使用 const 关键字。

常量可以是字符、字符串、布尔值或数值。

常量不能用 := 语法声明。

const Pi = 3.14

func main() {
	const World = "世界"
	fmt.Println("Hello", World)
	fmt.Println("Happy", Pi, "Day")

	const Truth = true
	fmt.Println("Go rules?", Truth)
}

运行结果如下：

函数

Go 语言中的函数设计简洁而灵活。函数可以接受任意数量的参数，并且参数的类型在参数名的后面定义，返回值的类型也在函数声明的后面。以下是一些 Go 语言函数的常见特性。

参数类型的简洁写法

在 Go 中，如果一个函数的多个参数类型相同，可以省略重复的类型说明。例如：

func add1(x int, y int) int {
    return x + y
}
func add2(x, y int) int {
    return x + y
}

在 add2 函数中，x 和 y 都是 int 类型，因此可以将类型合并写在最后。这种设计简化了代码，使函数声明更为简洁明了。这种省略的设计不仅提高了代码的可读性，还符合 Go 的简洁性原则，减少了不必要的重复。

多返回值

Go 语言允许函数返回多个值。这对于需要返回多个结果的函数非常有用，比如 swap 函数可以返回两个字符串的交换结果：

func swap(x, y string) (string, string) {
    return y, x
}

在调用 swap 时，直接接收返回的多个值，非常方便。例如：

a, b := swap("hello", "world")
fmt.Println(a, b) // 输出: world hello

多返回值在错误处理、函数需要返回多项数据时非常实用。Go 中，多个返回值常用于函数同时返回数据和错误信息，方便调用者进行错误检查。这种机制使得错误处理更为自然（笔起java的错误判断更加方便易懂，高级！）减少了使用异常等机制的需求，这也是 Go 设计中强调明确控制流的体现。

命名返回值和裸返回

在 Go 语言中，函数返回值可以被命名。这些命名的返回值会在函数体中作为局部变量存在。例如：

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return
}

在 split 函数中，返回值 x 和 y 已经被命名，因此 return 语句可以直接返回它们的当前值，这种写法称为「裸返回」。裸返回可以让代码更简洁，但在复杂函数中，可能不利于可读性。

命名返回值适合用于简单函数中，它可以使代码更加直观，同时为返回值提供文档化的功能。然而，在复杂函数中，为了可读性，最好显式地返回值，以便于理解。

Go 语言的函数设计遵循简洁、清晰的原则，支持多返回值和命名返回值，这种设计使得函数定义直观易懂。参数类型的简洁写法、多返回值的支持以及返回值的命名等特性都增强了 Go 的代码可读性。这些特性使得go语言代码更优雅、灵活，在复杂逻辑处理中显得尤为重要。

3、流程控制语句

for循环

Go 语言中只有一种循环结构：for 循环。for 循环由三部分组成，它们用分号隔开：

• 初始化语句：通常用于声明一个循环变量，并初始化它的值。这个变量的作用域仅限于 for 语句内部。
• 条件表达式：在每次迭代开始前进行求值。如果条件表达式的值为 false，则循环终止。
• 后置语句：在每次迭代结束后执行，通常用于更新循环变量的值。

for 初始化语句; 条件表达式; 后置语句 { 
// 循环体 
}

• Go 语言的 for 语句后面没有小括号 ()，但大括号 {} 是必须的。
• 初始化语句可以省略，此时 for 循环将不会执行任何初始化操作。
• 条件表达式也可以省略，此时 for 循环将无限循环，
• 直到遇到 break 语句或程序终止。
• 后置语句也可以省略，此时 for 循环将不会执行任何后置操作。

i := 0 
for ; i < 5; i++ { 
    fmt.Println(i) 
} 
// 省略条件表达式（无限循环） 
for { 
    fmt.Println("无限循环") 
    break // 使用 break 语句终止循环 
} 

Go 的 for 结构统一了所有循环形式，简洁而灵活。不再需要 while 或 do-while 等循环结构，减少了冗余的代码语法，这种简化在大型项目中有助于保持代码的一致性。

if语句

Go 语言中的 if 语句用于根据条件表达式的布尔值来决定是否执行某个代码块。if 语句的基本结构如下：

if 初始化语句;条件表达式 { 
    // 条件为 true 时执行的代码块 
} else { 
    // 条件为 false 时执行的代码块 
}

1. 条件表达式：必须是一个布尔表达式，即其结果必须为 true 或 false。
2. 代码块：当条件表达式为 true 时，执行 {} 中的代码块。
3. else 子句（可选）：如果条件表达式为 false，则执行 else 子句中的代码块。

Go 语言的 if 语句还支持在条件表达式之前声明一个初始化语句，这个初始化语句的作用域仅限于 if 语句内部。

if num := 10; num%2 == 0 {
    fmt.Println(num, "是偶数")
} else {
    fmt.Println(num, "是奇数")
}

if 语句的初始化特性避免了额外的变量声明，简化了逻辑判断语句。同时，通过局部作用域控制，减少了变量对外部的影响，这种设计既提升了代码的安全性，又增强了简洁性。（刚学go的时候感觉有些小奇怪，感觉和其他语言的差别有些大）

defert推迟

defer 语句用于延迟函数调用的执行，直到包含 defer 语句的函数返回之前。这在资源管理、错误处理和清理操作中非常有用。

1. 延迟执行：defer 语句会立即评估参数，但函数调用会被推迟到外层函数返回之前。
2. 后进先出：多个 defer 语句按照后进先出（LIFO）的顺序执行。
3. 返回值：defer 语句可以与函数的返回值一起使用，但需要注意返回值的评估时机。

func main() {
    fmt.Println("开始")
    defer fmt.Println("第一个 defer")
    defer fmt.Println("第二个 defer")
    fmt.Println("中间")
}

//输出
开始
中间
第二个 defer
第一个 defer

defer 的设计在资源清理时非常方便，例如文件关闭、数据库连接关闭等操作，你可以在打开文件等资源代码的下一行就直接用defer语句来关闭以确保之后不会忘记关闭相关资源。可以确保代码在函数结束前完成所需的清理，且其后进先出的特性帮助按期望顺序执行。这种设计避免了资源泄露，提高了代码的可靠性。

### 4、结构体、切片和映射

指针

Go 拥有指针。指针保存了值的内存地址。

类型 *T 是指向 T 类型值的指针，其零值为 nil。

var p *int

& 操作符会生成一个指向其操作数的指针。

i := 42
p = &i

* 操作符表示指针指向的底层值。

fmt.Println(*p) // 通过指针 p 读取 i
*p = 21         // 通过指针 p 设置 i

这也就是通常所说的「解引用」或「间接引用」。

与 C 不同，Go 没有指针运算。

结构体

Go 语言中的结构体（struct）是一种用户自定义的数据类型，可以包含多个不同类型的字段。通过结构体，可以将相关的数据组织在一起，形成一个逻辑上的整体。结构体在 Go 语言中广泛用于表示复杂的数据结构。

使用 type 关键字和 struct 关键字来定义结构体。 结构体字段可以通过结构体指针来访问。

如果我们有一个指向结构体的指针 p 那么可以通过 (*p).X 来访问其字段 X。 不过这么写太啰嗦了，所以语言也允许我们使用隐式解引用，直接写 p.X 就可以。

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

func main() {
    // 创建结构体实例
    p1 := Person{Name: "Alice", Age: 30, City: "New York"}
    fmt.Println(p1)

    // 访问结构体字段
    fmt.Println("Name:", p1.Name)
    fmt.Println("Age:", p1.Age)
    fmt.Println("City:", p1.City)

    // 修改结构体字段
    p1.Age = 31
    fmt.Println("Updated Age:", p1.Age)
}

数组

类型 [n]T 表示一个数组，它拥有 n 个类型为 T 的值。

var a [10]int

会将变量 a 声明为拥有 10 个整数的数组。

数组的长度是其类型的一部分，因此数组不能改变大小。 这看起来是个限制，不过没关系，Go 拥有更加方便的使用数组的方式。

切片

Go 语言中的切片（slice）是一种灵活且强大的数据结构，用于管理动态数组。切片与底层数组关联，提供了动态扩展和缩减的功能，因此在 Go 中经常用来替代数组以实现更加灵活的数据操作。

切片包含三个主要组成部分：指向底层数组的指针、长度（len）和容量（cap）。长度表示当前切片中元素的个数，而容量则是从切片的起始位置到底层数组末尾的元素总数。这种设计使得切片可以在原有数据基础上进行扩展，且避免了频繁的内存分配。

定义和初始化切片的方式

可以使用多种方式定义及初始化切片。

• 使用 make 函数：通过 make 函数可以创建一个特定长度和容量的切片。以下代码展示了如何使用 make 创建一个长度为 3、容量为 5 的切片：

func main() {
    slice := make([]int, 3, 5)
    fmt.Println(slice) // 输出: [0 0 0]
    fmt.Println("Length:", len(slice)) // 输出: Length: 3
    fmt.Println("Capacity:", cap(slice)) // 输出: Capacity: 5
}

这里，我们指定了长度和容量，Go 自动初始化切片中的元素为零值。这个方式在需要预定义容量时很有用。需要注意的是，切片的容量不能缩小，只能增大，因此预先分配合适的容量可以优化性能，减少扩容时的内存分配。

• 使用字面量：

func main() {
    slice := []string{"apple", "banana", "cherry"}
    fmt.Println(slice) // 输出: [apple banana cherry]
}

这种方式类似于数组初始化，但不需要指定长度，可以根据提供的元素自动确定长度。

• 从数组创建切片：从数组生成切片非常常见，可以用于对数组的部分数据进行操作。如下所示：

func main() {
    array := [5]int{1, 2, 3, 4, 5}
    slice := array[1:4]
    fmt.Println(slice) // 输出: [2 3 4]
}

这里我们创建了一个包含数组部分内容的切片。值得注意的是，切片并不复制数组中的内容，而是引用它的一部分。这意味着对切片的更改会影响到原数组，除非使用 copy 函数进行深拷贝。

切片的常见操作

我们可以对切片进行追加、再次切片、遍历和删除等操作。

1、追加元素

使用 append 函数向切片追加元素。如果切片的容量不足，append 会自动分配新的底层数组。

func main() {
    slice := []int{1, 2, 3}
    slice = append(slice, 4)
    fmt.Println(slice) // 输出: [1 2 3 4]

    // 追加多个元素
    slice = append(slice, 5, 6)
    fmt.Println(slice) // 输出: [1 2 3 4 5 6]
}

这里的 append 操作会检查切片的容量，如果容量不足，会重新分配更大的底层数组，并将原数据复制到新数组中。注意： 切片扩容时的性能开销可能较大，因此在大数据量情况下应谨慎使用。

2、切片可以包含任何类型，当然也包括其他切片。

func main() {
    slice := []int{1, 2, 3, 4, 5}
    subSlice := slice[1:3]
    fmt.Println(subSlice) // 输出: [2 3]
}

我们对 slice 进行了再次切片，得到一个新的 subSlice。切片的这种特性使得数据的分区操作变得更加方便，但需要小心底层数据的共享问题。修改 subSlice 的数据会影响到 slice，除非明确需要共享数据，建议谨慎使用再切片。

3、遍历切片

for 循环的 range 形式可遍历切片或映射。

当使用 for 循环遍历切片时，每次迭代都会返回两个值。 第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。

func main() {
    slice := []int{1, 2, 3, 4, 5}
    for i, v := range slice {
        fmt.Printf("Index: %d, Value: %d\n", i, v)
    }
}

这里 range 生成了切片的索引和值，便于我们访问切片内容。如果只需要其中一个变量，Go 支持使用 _ 忽略不需要的变量。

for i, _ := range slice // 仅使用索引
for _, value := range slice // 仅使用值
for i := range slice // 忽略值

4、删除元素

Go 中没有直接删除切片元素的内置方法，但可以通过 append 和切片操作来实现。以下示例展示了如何删除指定索引的元素

func main() {
    slice := []int{1, 2, 3, 4, 5}
    index := 2
    slice = append(slice[:index], slice[index+1:]...)
    fmt.Println(slice) // 输出: [1 2 4 5]
}

slice[:index] 和 slice[index+1:] 组合成了一个新切片，这样就实现了删除指定索引处的元素。这种方法虽然简单，但对于较大切片可能会有性能问题，因为涉及数据的重新分配和复制。

map映射

Go 语言中的映射（map）是一种键值对（key-value）集合，用于存储和检索数据。映射类似于其他编程语言中的字典或哈希表，它在 Go 语言中的实现方式有一些特别之处，比如其类型安全的定义方法和对键的独特处理方式。

在 Go 中，映射的定义通常有两种方式，分别是使用 make 函数和使用字面量。接下来，将对这两种定义方法进行详细说明，并分享一些常见的操作方法。

• 使用make函数：首先，我们可以使用 make 函数来创建一个映射，这种方法可以动态地添加键值对，比较适合需要逐步添加数据的场景。示例如下：

func main() {
    ages := make(map[string]int)
    ages["Alice"] = 30
    ages["Bob"] = 25
    ages["Charlie"] = 35

    fmt.Println(ages) // 输出: map[Alice:30 Bob:25 Charlie:35]
}

上面的代码使用 make 函数创建了一个 map[string]int 类型的映射，其中键为字符串，值为整数。初始化后，我们可以直接为映射添加键值对。例如 ages["Alice"] = 30 表示将 "Alice" 的年龄设置为 30。

• 使用字面量：字面量定义方式更为简洁，适合在初始化时就确定了全部键值对的情况。示例如下：

func main() {
    ages := map[string]int{
        "Alice": 30,
        "Bob":   25,
        "Charlie": 35,
    }

    fmt.Println(ages) // 输出: map[Alice:30 Bob:25 Charlie:35]
}

这里使用花括号 {} 定义映射的键值对。与 make 函数相比，字面量方式在可读性上更好，因为映射的内容直接呈现在代码中，适合需要快速初始化的情形。 我们可以对映射进行增删改查。

• 添加和更新元素

  通过键来添加或更新映射中的值。

  func main() {
      ages := map[string]int{
          "Alice": 30,
          "Bob":   25,
      }
  
      // 添加新元素
      ages["Charlie"] = 35
  
      // 更新现有元素
      ages["Alice"] = 31
  
      fmt.Println(ages) // 输出: map[Alice:31 Bob:25 Charlie:35]
  }
  

在上述代码中，我们首先创建了一个映射，之后使用 ages["Charlie"] = 35 添加了一个新的键值对，并通过 ages["Alice"] = 31 更新了 "Alice" 的年龄。这种方式非常灵活，可以随时为映射添加或更新值。

• 访问元素

  通过键来访问映射中的值。如果键不存在，返回值类型对应的零值。

  func main() {
      ages := map[string]int{
          "Alice": 30,
          "Bob":   25,
      }
  
      age := ages["Alice"]
      fmt.Println("Alice's age:", age) // 输出: Alice's age: 30
  
      // 访问不存在的键
      age = ages["David"]
      fmt.Println("David's age:", age) // 输出: David's age: 0
  }
  

注意：访问了一个不存在的键 "David"，结果返回 0，因为 int 类型的零值是 0。这个特性在处理缺省值时需要注意，可以通过进一步判断键是否存在来避免误解。

• 检查键是否存在

  使用value , ok 语法来检查键是否存在。

  func main() {
      ages := map[string]int{
          "Alice": 30,
          "Bob":   25,
      }
  
      age, exists := ages["Alice"]
      if exists {
          fmt.Println("Alice's age:", age) // 输出: Alice's age: 30
      } else {
          fmt.Println("Alice not found")
      }
  
      age, exists = ages["David"]
      if exists {
          fmt.Println("David's age:", age)
      } else {
          fmt.Println("David not found") // 输出: David not found
      }
  }
  

• 删除元素

  使用 delete 函数删除映射中的键值对。

  func main() {
      ages := map[string]int{
          "Alice": 30,
          "Bob":   25,
          "Charlie": 35,
      }
  
      delete(ages, "Bob")
      fmt.Println(ages) // 输出: map[Alice:30 Charlie:35]
  }
  

• 遍历映射：我们可以使用 for 循环结合 range 关键字来遍历映射。

  func main() {
      ages := map[string]int{
          "Alice": 30,
          "Bob":   25,
          "Charlie": 35,
      }
  
      for key, value := range ages {
          fmt.Printf("Key: %s, Value: %d\n", key, value)
      }
  }
  

遍历映射时，每次迭代都会返回键和值。需要注意的是，映射的遍历顺序是不确定的，因为 Go 的映射底层并没有顺序概念。如果顺序重要，则需要自行对键进行排序。

5、接口

接口是 Go 语言中实现多态性的核心机制之一，能够帮助我们编写灵活且高效的代码。接口允许我们通过不同类型的实现来调用通用的方法，从而实现更具扩展性的设计。以下将详细介绍接口的定义、使用场景、示例代码，并分析接口在实际开发中的应用与优势。

接口的定义与特点

Go 语言中的接口采用隐式实现，即只要某个类型实现了接口定义的所有方法，就自动实现了该接口。因此，接口在 Go 中扮演着解耦合的角色，能够让代码更具弹性。例如，当我们需要处理多种类型的对象时，可以将接口作为参数来实现不同类型的调用，这样避免了为每种类型编写单独的代码。

下面就是一个go语言接口的定义：

type InterfaceName interface {
    MethodName1(parameters) returnType
    MethodName2(parameters) returnType
}

通过使用接口，我们可以避免直接依赖具体实现，从而让代码更加模块化，便于维护与扩展。特别是在大型项目中，使用接口能极大地提高代码的复用性和可测试性。

接口的使用场景与实例

假设我们需要定义一个接口 Greeter，并使用该接口来创建不同类型的问候者。通过接口，我们可以灵活地将任何实现了 SayHello 方法的类型作为 Greeter 使用：

/* 定义接口 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* 定义结构体 */
type struct_name struct {
   /* variables */
}

/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* 方法实现*/
}

实现接口

只要一个类型实现了接口中定义的所有方法，它就自动实现了该接口。

type Person struct {
    Name string
}

func (p Person) SayHello() string {
    return "Hello, " + p.Name
}

var g Greeter = Person{Name: "Alice"}
fmt.Println(g.SayHello()) // 输出: Hello, Alice

空接口

指定了零个方法的接口值被称为 空接口：

interface{}

空接口的特点是可以接受任何类型的值，因为每种类型都至少实现了零个方法。这种特性使得空接口可以用于处理未知类型的值。在标准库中，fmt.Print 等函数接受 interface{} 类型的任意数量参数，便于处理多种类型的数据。这在实际开发中极为方便，可以简化函数的参数定义，让函数更通用。

package main

import "fmt"

func main() {
	var i interface{}
	describe(i)

	i = 42
	describe(i)

	i = "hello"
	describe(i)
}

func describe(i interface{}) {
	fmt.Printf("(%v, %T)\n", i, i)
}

我们也可以通过多个接口来创建新的接口。

type Speaker interface {
    Speak() string
}

type Walker interface {
    Walk() string
}

type Animal interface {
    Speaker
    Walker
}

type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return "Woof!"
}

func (d Dog) Walk() string {
    return d.Name + " is walking."
}

var a Animal = Dog{Name: "Buddy"}
fmt.Println(a.Speak()) // 输出: Woof!
fmt.Println(a.Walk())  // 输出: Buddy is walking.

接口的应用

go语言中的接口有着广泛的应用场景。（就像java中的接口一样，可以实现代码的解耦，也可以提高程序的可拓展性和可维护性）

多态性

接口的一个关键特性就是多态性，允许我们通过同一个接口调用不同类型的实现。Go 语言的接口是隐式实现的，这意味着只要一个类型实现了接口的所有方法，该类型就自动实现了该接口，从而使得多态性在 Go 中更加灵活。通过接口实现的多态性，可以在编写代码时只关心接口定义，而不关心具体类型的实现，这样代码的扩展性更强。

比如，我们定义了一个 Shape 接口，包含一个 Area 方法，用于计算形状的面积。通过实现该接口，不同的形状（如圆形、矩形等）可以各自定义 Area 方法，从而让调用者无需关心具体的形状类型。这样设计的好处在于新增形状时，只需让新类型实现 Shape 接口即可，无需修改现有代码。

type Shape interface {
    Area() float64
}

插件化架构

接口在设计插件化架构中非常有效。通过定义一组接口，系统可以允许不同模块实现这些接口，以便模块间相互协作。这样，不同模块可以灵活替换，而无需更改系统的其他部分逻辑，从而实现插件化和高扩展性。

在构建 Web 应用时，可能会需要不同的存储方式（如文件存储和数据库存储）。通过定义 Store 接口，不同的存储方式都可以实现该接口，应用程序可以在任何实现该接口的存储方式之间切换，而不改变核心逻辑。

解耦与依赖倒置

接口还可以用于实现代码的解耦和依赖倒置。解耦指的是通过接口隔离模块间的依赖关系，使得模块的内部实现不会影响其他模块。依赖倒置原则则要求高层模块不依赖于低层模块，而是依赖于接口，通过这种设计，代码之间的耦合度降低，提高了可测试性和维护性。

比如在支付系统中，系统可能支持多种支付方式（如信用卡和 PayPal）。通过定义 PaymentProcessor 接口，不同的支付方式可以实现该接口，从而使得系统的核心逻辑与支付方式解耦。新增支付方式时，只需实现 PaymentProcessor 接口即可，核心逻辑不需要改动。