Go-04-结构体、方法与接口

2026-08-29

字数统计: 1.6k字 | 阅读时长≈ 7分

Go-04-结构体、方法与接口

本节目标：理解 Go 的”无 class 但有 struct+method+interface”组合，掌握封装、组合（代替继承）、多态。

1. 结构体（struct）

struct 是字段的集合，是 Go 的”类”：

type Person struct {
    Name string
    Age  int
}

// 三种初始化方式
p1 := Person{"Alice", 25}                  // 按顺序
p2 := Person{Name: "Bob", Age: 30}         // 按名字（推荐）
p3 := Person{Name: "Carol"}                // 部分字段，Age 默认为 0
p4 := new(Person)                          // 返回 *Person，所有字段为零值

访问字段：

1
2
3

p := Person{Name: "Alice", Age: 25}
fmt.Println(p.Name)            // Alice
p.Age = 26                     // 直接修改

匿名字段（嵌入） —— Go 的”继承”：

type Address struct {
    City, State string
}

type Employee struct {
    Name    string
    Salary  float64
    Address             // 匿名字段，Employee 直接拥有 City/State
}

e := Employee{
    Name:   "Alice",
    Salary: 5000,
    Address: Address{
        City:  "Beijing",
        State: "BJ",
    },
}
fmt.Println(e.City)   // Beijing ← 直接访问，等价于 e.Address.City

2. 方法（method）

方法就是绑定到特定类型的函数：

type Rectangle struct {
    Width, Height float64
}

// 值接收者
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// 指针接收者（可以修改接收者）
func (r *Rectangle) Scale(factor float64) {
    r.Width *= factor
    r.Height *= factor
}

r := Rectangle{Width: 10, Height: 5}
fmt.Println(r.Area())     // 50
r.Scale(2)
fmt.Println(r.Area())     // 200

值接收者 vs 指针接收者：

想要修改接收者 → 必须用指针
接收者是大结构体 → 用指针避免复制
保持一致性：一个类型的方法，要么全用值接收者，要么全用指针接收者

r := Rectangle{3, 4}
p := &r

// 调用时 Go 自动转换
r.Area()       // 值调用
p.Area()       // 自动解引用
r.Scale(2)     // 自动取地址
p.Scale(2)     // 直接传指针

3. 接口（interface）

接口是方法签名的集合。一个类型只要实现了接口的所有方法，就隐式满足该接口（不需要 implements 关键字）：

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

type Rectangle struct{ Width, Height float64 }
type Circle struct{ Radius float64 }

// Rectangle 满足 Shape
func (r Rectangle) Area() float64      { return r.Width * r.Height }
func (r Rectangle) Perimeter() float64  { return 2 * (r.Width + r.Height) }

// Circle 也满足 Shape
func (c Circle) Area() float64      { return 3.14159 * c.Radius * c.Radius }
func (c Circle) Perimeter() float64  { return 2 * 3.14159 * c.Radius }

func printShapeInfo(s Shape) {
    fmt.Printf("Area=%.2f Perimeter=%.2f\n", s.Area(), s.Perimeter())
}

func main() {
    printShapeInfo(Rectangle{3, 4})   // Area=12.00 Perimeter=14.00
    printShapeInfo(Circle{5})         // Area=78.54 Perimeter=31.42
}

4. 接口的”鸭子类型”

Go 的接口是结构化类型（structural typing），也叫”鸭子类型”——只要长得像鸭子，就当作鸭子：

1
2
3

type Duck interface {
    Quack()
}

任何类型只要有 Quack() string 方法就满足 Duck，不需要显式声明 implements。

5. 空接口 interface{}

interface{}（或 Go 1.18+ 的 any）没有任何方法，所有类型都满足它。常用于”可以接受任意类型”的场景：

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

describe(42)             // type=int value=42
describe("hello")        // type=string value=hello
describe([]int{1, 2, 3}) // type=[]int value=[1 2 3]

// 类型断言
var x interface{} = "hello"
s, ok := x.(string)
if ok {
    fmt.Println("是字符串:", s)
}

// type switch
switch v := x.(type) {
case int:
    fmt.Println("int:", v)
case string:
    fmt.Println("string:", v)
default:
    fmt.Println("unknown:", v)
}

6. 多态实战：通用排序

Go 的 sort.Sort 接口：

type Interface interface {
    Len() int
    Less(i, j int) bool  // i 应该排在 j 前面？
    Swap(i, j int)
}

实现这个接口就能被 sort.Sort 排序：

type ByLength []string

func (s ByLength) Len() int           { return len(s) }
func (s ByLength) Less(i, j int) bool { return len(s[i]) < len(s[j]) }
func (s ByLength) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }

func main() {
    fruits := []string{"peach", "banana", "kiwi"}
    sort.Sort(ByLength(fruits))
    fmt.Println(fruits)  // [kiwi peach banana]
}

Go 1.21+ 内置 slices.Sort / slices.SortFunc（推荐）：

import "slices"

fruits := []string{"peach", "banana", "kiwi"}
slices.SortFunc(fruits, func(a, b string) int {
    return len(a) - len(b)
})

7. 嵌入与接口的组合

type Reader interface {
    Read(p []byte) (n int, err error)
}

type Writer interface {
    Write(p []byte) (n int, err error)
}

// 接口嵌入接口
type ReadWriter interface {
    Reader
    Writer
}

// 结构体嵌入接口（必须有具体类型实现）
type File struct {
    // ...
}

func (f *File) Read(p []byte) (int, error)  { /* ... */ }
func (f *File) Write(p []byte) (int, error) { /* ... */ }

// 现在 *File 满足 ReadWriter
var rw ReadWriter = &File{}

8. 多态实战：策略模式

type PaymentStrategy interface {
    Pay(amount float64) string
}

type CreditCard struct{ Name string }
func (c *CreditCard) Pay(amount float64) string {
    return fmt.Sprintf("信用卡 %s 支付 %.2f 元", c.Name, amount)
}

type Alipay struct{ Account string }
func (a *Alipay) Pay(amount float64) string {
    return fmt.Sprintf("支付宝 %s 支付 %.2f 元", a.Account, amount)
}

type Wechat struct{ ID string }
func (w *Wechat) Pay(amount float64) string {
    return fmt.Sprintf("微信 %s 支付 %.2f 元", w.ID, amount)
}

type Order struct {
    Amount   float64
    Strategy PaymentStrategy
}

func (o *Order) Checkout() string {
    return o.Strategy.Pay(o.Amount)
}

func main() {
    o := &Order{Amount: 99.9}
    o.Strategy = &CreditCard{Name: "Alice"}
    fmt.Println(o.Checkout())  // 信用卡 Alice 支付 99.90 元

    o.Strategy = &Alipay{Account: "alice@alipay"}
    fmt.Println(o.Checkout())  // 支付宝 alice@alipay 支付 99.90 元

    o.Strategy = &Wechat{ID: "wxid_123"}
    fmt.Println(o.Checkout())  // 微信 wxid_123 支付 99.90 元
}

9. 实战：等价于 Java equals/hashCode

Go 没有 equals/hashCode，但可以用接口实现：

type Equaler interface {
    Equal(Eq) bool
    Hash() uint32
}

// 用容器
type StringSet struct {
    data map[uint32][]string
}

func (s *StringSet) Add(v string) {
    h := hash(v)
    s.data[h] = append(s.data[h], v)
}

func hash(s string) uint32 {
    h := uint32(2166136261)
    for i := 0; i < len(s); i++ {
        h ^= uint32(s[i])
        h *= 16777619
    }
    return h
}

实际生产用 map[string]struct{} 就行，不需要自己写 hash。

小结

概念	Java/C++	Go
类	`class`	`struct` + `method`
继承	`extends`	嵌入（组合）
接口	`implements Interface`	隐式实现（鸭子类型）
多态	父类引用指向子类对象	接口变量指向任何实现者
抽象类	`abstract class`	没有，但有未导出的 struct 嵌入

核心思想：

组合优于继承：用结构体嵌入而不是 class 继承
小接口：Go 社区推崇”小而美的接口”（如 io.Reader 只有 Read 一个方法）
接受接口，返回结构体：函数参数用接口类型，返回值用具体类型

下一节讲 Go 的函数与闭包（一等公民的函数）。

本文作者： CoderSong
本文链接： https://jack-song-gif.github.io/2026/08/29/Go-04-结构体、方法与接口/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！