开篇引导

在前几章中，我们学习了Go的基本语法、项目结构、工具链以及核心数据结构。从本章开始，我们将深入Go语言的类型系统，这是理解Go编程范式的关键。Go是一门静态强类型语言，类型信息在编译时决定，这为编译器提供了性能优化的机会，也帮助我们在开发早期捕获大量错误。

但Go的类型系统并非传统面向对象语言的翻版。它没有继承，却通过组合实现了更灵活的代码复用；它有接口，却采用隐式实现的方式，让多态更自然；它支持方法，却允许你自由选择值接收者或指针接收者。本章将带你全面掌握Go类型系统的核心概念，包括如何定义类型、如何通过方法添加行为、如何利用接口实现多态、如何通过嵌入类型扩展功能，以及如何控制标识符的可见性。

学完本篇，你将能够熟练创建自定义类型，理解值接收者与指针接收者的本质区别，掌握接口的设计与使用，并学会利用嵌入类型优雅地复用代码。

【本篇核心收获】

• 掌握使用struct和基于已有类型定义新类型的方法
• 理解方法的概念，区分值接收者与指针接收者的适用场景
• 深入理解类型的本质，学会根据本质决定传递方式（值或指针）
• 掌握接口的定义、实现与多态，理解方法集对接口实现的影响
• 学会通过嵌入类型组合已有类型，实现代码复用与扩展
• 理解公开与未公开标识符的规则，设计安全的API

1. 用户定义的类型

Go语言允许用户通过两种方式定义新类型：结构体（struct）和基于已有类型（type alias/definition）。

1.1 结构体

结构体是将多个字段组合在一起的数据结构，每个字段有名称和类型。

声明结构体：

type user struct {
    name       string
    email      string
    ext        int
    privileged bool
}

创建结构体变量：

// 声明并初始化为零值
var bill user

// 使用结构体字面量（带字段名）
lisa := user{
    name:       "Lisa",
    email:      "lisa@email.com",
    ext:        123,
    privileged: true,
}

// 使用结构体字面量（省略字段名，按顺序）
lisa := user{"Lisa", "lisa@email.com", 123, true}

结构体字段可以是任何类型，包括其他结构体：

type admin struct {
    person user
    level  string
}

fred := admin{
    person: user{
        name:       "Lisa",
        email:      "lisa@email.com",
        ext:        123,
        privileged: true,
    },
    level: "super",
}

1.2 基于已有类型

可以基于内置类型或其他已定义类型声明新类型。例如标准库中的time.Duration：

type Duration int64

这种新类型与基础类型是完全不同的类型，不能直接赋值，需要显式转换：

var dur Duration
dur = int64(1000)  // 编译错误：类型不匹配
dur = Duration(1000)  // 正确

模块小结：结构体用于组合多个字段，基于已有类型则创建了新的语义类型，两者都让代码更清晰、类型更安全。

2. 方法

方法是带有接收者（receiver）的函数，用于为类型添加行为。接收者可以是值或指针。

值接收者：

func (u user) notify() {
    fmt.Printf("Sending User Email To %s<%s>\n", u.name, u.email)
}

指针接收者：

func (u *user) changeEmail(email string) {
    u.email = email
}

2.1 调用方式

无论是值还是指针，都可以调用值接收者或指针接收者的方法，编译器会自动转换：

bill := user{"Bill", "bill@email.com"}
bill.notify()                // 值调用值方法
bill.changeEmail("bill@newdomain.com")  // 值调用指针方法（编译器取地址）

lisa := &user{"Lisa", "lisa@email.com"}
lisa.notify()                // 指针调用值方法（编译器解引用）
lisa.changeEmail("lisa@newdomain.com") // 指针调用指针方法

2.2 选择接收者类型

接收者类型的选择由类型的本质决定：

• 如果类型本质是原始的（如int、string），应使用值接收者，因为操作的是副本，不修改原值。
• 如果类型本质是非原始的（如File、网络连接），应使用指针接收者，因为需要共享状态。

这个原则将在下一节详细讨论。

模块小结：方法让类型具有行为，值接收者操作副本，指针接收者操作原值。编译器会自动在值和指针之间转换，但选择哪种接收者应基于类型的本质。

3. 类型的本质

类型的本质决定了在函数/方法之间传递值时是应该复制还是共享。

3.1 内置类型

内置类型（数值、字符串、布尔值）本质是原始的。对它们进行操作时，总是产生新值，不应修改原值。

标准库示例（strings.Trim）：

func Trim(s string, cutset string) string {
    if s == "" || cutset == "" {
        return s
    }
    return TrimFunc(s, makeCutsetFunc(cutset))
}

函数接收字符串副本，返回新字符串，不修改原值。

3.2 引用类型

引用类型（切片、映射、通道、接口、函数）本质上是标头（header）值，包含指向底层数据结构的指针。复制引用类型的值只复制标头，底层数据共享。

因此，引用类型传递时，无需使用指针，直接复制即可。例如net.IP类型（字节切片）：

type IP []byte

func (ip IP) MarshalText() ([]byte, error) {
    // 使用值接收者，复制的是切片标头
}

3.3 结构类型

结构类型可能是原始的，也可能是非原始的，取决于其设计意图。

原始本质的结构体（如time.Time）：

type Time struct {
    sec  int64
    nsec int32
    loc  *Location
}

Time代表一个时间点，不可修改。所有方法都使用值接收者，返回新值：

func (t Time) Add(d Duration) Time {
    // 修改副本，返回新Time
    return t
}

非原始本质的结构体（如os.File）：

type File struct {
    *file  // 嵌入指针
}

File代表打开的文件，不应该被复制。工厂函数返回指针：

func Open(name string) (*File, error)

方法使用指针接收者：

func (f *File) Chdir() error {
    // 修改f的状态
}

模块小结：判断类型本质的关键是：这个类型是应该被复制（原始）还是应该被共享（非原始）。这决定了接收者类型和传递方式。

4. 接口

接口定义了一组行为（方法），任何实现了这些方法的类型都可以赋值给该接口类型。接口实现了多态。

4.1 标准库示例

io.Reader和io.Writer是标准库中最经典的接口。

示例：简单的curl程序

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
)

func init() {
    if len(os.Args) != 2 {
        fmt.Println("Usage: ./curl <url>")
        os.Exit(-1)
    }
}

func main() {
    r, err := http.Get(os.Args[1])
    if err != nil {
        fmt.Println(err)
        return
    }

    // r.Body实现了io.Reader，os.Stdout实现了io.Writer
    io.Copy(os.Stdout, r.Body)
    r.Body.Close()
}

io.Copy可以处理任何实现了io.Reader和io.Writer的类型，实现了高度复用。

4.2 接口的内部表示

接口值在内存中占用两个字（word），第一个字指向类型信息表（iTable），第二个字指向值指针。

图1：实体值赋值后接口值的简图

图2：实体指针赋值后接口值的简图

4.3 实现接口

Go的接口是隐式实现的，类型不需要显式声明“implements”，只要实现了接口中所有方法即可。

type notifier interface {
    notify()
}

type user struct {
    name  string
    email string
}

func (u *user) notify() {
    fmt.Printf("Sending user email to %s<%s>\n", u.name, u.email)
}

此时，*user类型实现了notifier接口。

4.4 方法集

方法集定义了接口的接受规则：

Values	Methods Receivers
T	(t T)
*T	(t T) 和 (t *T)

即：

• 值T的方法集只包含值接收者的方法。
• 指针*T的方法集包含值接收者和指针接收者的方法。

从接收者角度：

Methods Receivers	Values
(t T)	T 和 *T
(t *T)	*T

这意味着：

• 如果接口方法使用指针接收者实现，则只有指向该类型的指针才能赋值给接口。
• 如果接口方法使用值接收者实现，则值和指针都可以赋值给接口。

示例：下面代码会编译错误

func (u *user) notify() {}  // 指针接收者

u := user{"Bill", "bill@email.com"}
sendNotification(u)  // 错误：user类型没有实现notifier

因为notify需要指针接收者，而user值的方法集不包含指针接收者方法。改成&u即可。

为什么？ 因为编译器不能总是获取一个值的地址。例如字面量不能取地址：

type duration int

func (d *duration) pretty() string {
    return fmt.Sprintf("Duration: %d", *d)
}

func main() {
    duration(42).pretty()  // 编译错误：不能获取duration(42)的地址
}

4.5 多态

接口可以实现多态：同一个接口值可以保存不同类型的值，调用时执行对应的实现。

type notifier interface {
    notify()
}

type user struct { ... }
func (u *user) notify() { ... }

type admin struct { ... }
func (a *admin) notify() { ... }

func sendNotification(n notifier) {
    n.notify()
}

func main() {
    bill := user{"Bill", "bill@email.com"}
    sendNotification(&bill)   // 调用user.notify

    lisa := admin{"Lisa", "lisa@email.com"}
    sendNotification(&lisa)   // 调用admin.notify
}

模块小结：接口是Go多态的基础，隐式实现让代码解耦，方法集规则决定了哪些类型可以满足接口。理解接口的内部表示有助于掌握接口的底层行为。

5. 嵌入类型

嵌入类型（type embedding）是将一个类型直接嵌入到另一个结构体中，实现代码复用。被嵌入的类型称为内部类型，嵌入的类型称为外部类型。

5.1 基本嵌入

type user struct {
    name  string
    email string
}

func (u *user) notify() {
    fmt.Printf("Sending user email to %s<%s>\n", u.name, u.email)
}

type admin struct {
    user   // 嵌入类型
    level string
}

内部类型的方法被提升到外部类型，可以直接调用：

ad := admin{
    user: user{name: "John", email: "john@yahoo.com"},
    level: "super",
}

ad.user.notify()  // 显式访问
ad.notify()       // 提升后直接调用

5.2 嵌入与接口

如果内部类型实现了某个接口，那么外部类型也实现了该接口（因为方法被提升）。

type notifier interface {
    notify()
}

// user实现了notifier

ad := admin{...}
sendNotification(&ad)  // 有效，因为admin通过嵌入user获得了notify方法

5.3 覆盖方法

如果外部类型也实现了同名方法，则外部类型的方法会覆盖内部类型的方法，内部类型的方法不再被提升。

func (a *admin) notify() {
    fmt.Printf("Sending admin email to %s<%s>\n", a.name, a.email)
}

// 此时，ad.notify()调用admin.notify
// 但仍可通过ad.user.notify()访问user.notify

5.4 输出示例

执行上述代码，输出：

Sending admin email to john smith<john@yahoo.com>
Sending user email to john smith<john@yahoo.com>
Sending admin email to john smith<john@yahoo.com>

模块小结：嵌入类型是Go实现组合（而非继承）的核心机制。它允许将已有类型作为部件，自动提升其方法，也可按需覆盖，非常灵活。

6. 公开与未公开标识符

Go通过标识符大小写控制可见性：

• 大写字母开头：公开，包外可访问。
• 小写字母开头：未公开，仅包内可访问。

6.1 未公开的类型

即使类型未公开，如果包提供了工厂函数，外部可以获取该类型的值，但不能直接引用类型名。

// counters包
type alertCounter int  // 未公开

func New(value int) alertCounter {
    return alertCounter(value)
}

// main包
counter := counters.New(10)  // 可以，返回未公开类型的值
fmt.Printf("Counter: %d\n", counter)

6.2 公开结构中的未公开字段

公开结构体的字段如果未公开，包外无法直接访问。

type User struct {
    Name  string  // 公开
    email string  // 未公开
}

u := entities.User{
    Name:  "Bill",
    email: "bill@email.com",  // 编译错误：未知字段
}

6.3 未公开的内部类型中的公开字段

如果嵌入一个未公开的类型，但该类型有公开字段，则这些字段会被提升到外部类型，从而可以访问。

type user struct {  // 未公开
    Name  string    // 公开
    Email string    // 公开
}

type Admin struct {
    user   // 嵌入未公开类型
    Rights int
}

a := entities.Admin{Rights: 10}
a.Name = "Bill"   // 可以，因为Name被提升
a.Email = "bill@email.com"

模块小结：控制标识符的可见性是设计安全API的关键。合理使用公开/未公开，可以隐藏实现细节，仅暴露必要的接口。

7. 本篇核心知识点速记

• 用户定义类型：使用struct组合字段，或基于已有类型创建新类型（如type Duration int64）。
• 方法：函数前加接收者，值接收者操作副本，指针接收者操作原值。编译器自动在值和指针间转换。
• 类型本质：内置类型是原始的，传递副本；引用类型（切片、映射等）本质是标头，复制标头共享数据；结构体可能是原始（如time.Time）或非原始（如os.File），决定接收者和传递方式。
• 接口：定义行为，隐式实现，支持多态。接口值包含类型信息表和值指针。方法集规则：值的方法集只含值接收者，指针的方法集含两种接收者。
• 嵌入类型：将类型嵌入结构体，内部类型的方法被提升到外部类型，外部类型可覆盖方法。通过嵌入实现组合复用。
• 公开/未公开：大写字母开头公开，小写字母开头未公开。未公开类型可通过工厂函数创建，未公开字段无法直接访问，但未公开内部类型的公开字段会被提升。

文末小结

本章我们全面学习了Go语言的类型系统。从定义新类型到添加方法，从理解类型本质到使用接口实现多态，再到利用嵌入类型组合复用，最后掌握标识符的可见性控制。这些知识构成了Go编程的核心基础。

Go的类型系统摒弃了传统面向对象中的继承，代之以组合和接口，让代码更简洁、更灵活。理解类型的本质有助于写出高效、安全的代码。在后续的实战中，你会越来越体会到这种设计的优雅。