Go Interface

Phase 02 — Go Core 涵盖：interface

---

1. 学习目标

完成本知识点后，你应该能够：

• 理解 Go interface 的隐式实现机制（duck typing）
• 定义和使用 interface 类型，编写多态代码
• 区分空接口 interface{} / any 与具体 interface
• 使用 type assertion 和 type switch 处理动态类型
• 设计面向接口的 API，而非面向具体 struct
• 在数字孪生后端中为设备、传感器抽象统一行为

---

2. 为什么需要

Phase 01 你已用 struct 建模 AGV、传感器等设备。随着设备类型增多（AGV、机械臂、摄像头），如果每个 handler 都依赖具体 struct，代码会充满 if type == "agv" 的分支，难以扩展和测试。

interface 让不同 struct 只要实现了相同方法集，就可以互换使用——这是 Go 组合优于继承的核心体现。后端服务中，Repository、Logger、Notifier 等层都依赖 interface，便于 mock 和替换实现。

---

3. 核心概念

3.1 隐式实现

Go 没有 implements 关键字。类型只要实现了 interface 声明的全部方法，就自动满足该 interface。

type Mover interface {
    Move(dx, dy float64)
}

任何拥有 Move(dx, dy float64) 方法的类型都实现了 Mover，无需显式声明。

3.2 interface 是一组方法签名

interface 只描述行为，不包含字段。方法集必须完全匹配（方法名、参数、返回值）。

3.3 空接口

interface{}（Go 1.18+ 别名 any）表示任意类型，类似 TS 的 unknown / any，但使用时需要 type assertion。

3.4 值接收者 vs 指针接收者

• 值接收者方法 → 值和指针都能满足 interface
• 指针接收者方法 → 只有指针能满足 interface

3.4 面向 interface 编程

依赖 interface 而非具体类型：

func ReportPosition(d DeviceReporter) { ... }

调用方传入任何实现了 DeviceReporter 的类型。

---

4. 基础语法

完整示例见 workspace/phase-02/interface/main.go。

package main

import "fmt"

// 定义 interface
type DeviceReporter interface {
    ID() string
    Status() string
}

// AGV 实现 DeviceReporter
type AGV struct {
    DeviceID string
    Online   bool
}

func (a AGV) ID() string { return a.DeviceID }

func (a AGV) Status() string {
    if a.Online {
        return "online"
    }
    return "offline"
}

// Sensor 同样实现 DeviceReporter
type Sensor struct {
    Name   string
    Active bool
}

func (s Sensor) ID() string { return s.Name }

func (s Sensor) Status() string {
    if s.Active {
        return "active"
    }
    return "inactive"
}

// 接受 interface，而非具体 struct
func printDevice(d DeviceReporter) {
    fmt.Printf("%s: %s\n", d.ID(), d.Status())
}

func main() {
    devices := []DeviceReporter{
        AGV{DeviceID: "AGV-001", Online: true},
        Sensor{Name: "temp-01", Active: false},
    }
    for _, d := range devices {
        printDevice(d)
    }

    // type assertion
    var anyVal any = AGV{DeviceID: "AGV-002", Online: true}
    if agv, ok := anyVal.(AGV); ok {
        fmt.Println("asserted:", agv.DeviceID)
    }
}

运行：

cd workspace/phase-02/interface
go run main.go

---

5. 代码解析

type DeviceReporter interface {
    ID() string
    Status() string
}

interface 定义方法集。任何类型实现了这两个方法，就满足 DeviceReporter。

func printDevice(d DeviceReporter) { ... }

函数参数是 interface 类型，调用时可传入 AGV、Sensor 或任何其他实现了方法集的类型——编译期检查，运行时多态。

devices := []DeviceReporter{ AGV{...}, Sensor{...} }

slice 元素类型是 interface，可存放不同具体类型的值（每个元素是一个 (type, value) 对）。

if agv, ok := anyVal.(AGV); ok { ... }

type assertion：从 interface 值中提取具体类型。ok 为 false 表示断言失败，不会 panic。

---

6. JavaScript / TypeScript 对比

概念	Go	TypeScript
接口定义	type X interface { M() }	interface X { m(): void }
实现方式	隐式，无需声明	显式 implements X
结构类型	方法集必须完全匹配	结构兼容，多余属性通常允许
任意类型	any / interface{}	any / unknown
运行时	interface 有运行时类型信息	编译后类型消失
多态	通过 interface 值动态分发	通过 class implements 或 duck typing

关键差异：

1. Go interface 是运行时概念，type assertion 在运行时检查
2. TS interface 只在编译期存在，Go interface 会影响内存布局（itab）
3. Go 小 interface 更 idiomatic（1–3 个方法），大 interface 难以 mock

---

7. 常见错误

错误 1：指针接收者导致值类型不满足 interface

type Mover interface { Move() }
type AGV struct{}
func (a *AGV) Move() {}  // 指针接收者

var m Mover = AGV{}     // ❌ AGV 未实现 Mover
var m Mover = &AGV{}    // ✅

错误 2：nil interface 与 nil 具体值

var p *AGV = nil
var d DeviceReporter = p  // d != nil（类型是 *AGV，值是 nil）
if d != nil { ... }       // 可能 true！

错误 3：断言失败导致 panic

var d DeviceReporter = Sensor{...}
agv := d.(AGV)  // ❌ panic if wrong type

agv, ok := d.(AGV)  // ✅ 安全断言

错误 4：interface 过大

// ❌ 一个 interface 包含 10+ 方法，难以测试和替换
type MegaDevice interface { Method1(); Method2(); ... }

---

8. 实际应用

数字孪生 — 统一设备上报

type TelemetryReporter interface {
    ID() string
    ToJSON() ([]byte, error)
}

func BroadcastAll(reporters []TelemetryReporter) error {
    for _, r := range reporters {
        data, err := r.ToJSON()
        if err != nil {
            return err
        }
        // 推送给 WebSocket / 写入 Redis
        _ = data
    }
    return nil
}

AGV、Sensor、Camera 各自实现 TelemetryReporter，广播逻辑无需知道具体设备类型。

Web3D 后端 — 存储抽象

type SceneStore interface {
    SaveScene(id string, data []byte) error
    LoadScene(id string) ([]byte, error)
}

开发时用内存实现，上线后换 PostgreSQL 实现，handler 代码不变。

---

9. 深入理解

9.1 interface 底层

interface 值由 (type, data) 两部分组成。动态类型是具体类型的元信息，动态值是指向数据的指针或拷贝。

9.2 小 interface 原则

Go 标准库推崇小 interface：io.Reader、io.Writer、fmt.Stringer 都只有 1–2 个方法。组合多个小 interface 比定义一个大 interface 更灵活。

9.3 接受 interface，返回 struct

idiomatic Go：函数参数用 interface，返回值用具体类型。调用方依赖抽象，实现方暴露具体。

9.4 编译期 vs 运行时

interface 满足关系在编译期检查；type assertion 和 method dispatch 在运行时完成。

---

10. 练习

请独立完成，不要查看答案。详细题目见 exercises/phase-02-core/01-interface.md。

Level 1 — 基础

练习 1.1：定义 Stringer-like interface Describer，包含 Describe() string，让 AGV struct 实现它。

练习 1.2：编写函数 printAll([]Describer)，遍历打印描述。

练习 1.3：对 any 类型做 type assertion，区分 AGV 和 Sensor。

Level 2 — 应用

练习 2.1：定义 Movable interface（Move(dx, dy float64)），AGV 和 Robot 分别实现。

练习 2.2：用 type switch 处理 []any 中的多种设备类型。

练习 2.3：设计 BatteryChecker interface，判断设备是否需要充电。

Level 3 — 综合

练习 3.1：实现设备注册表 Registry，支持 Register(DeviceReporter) 和 ListAll()。

练习 3.2：为 Telemetry 数据设计 interface + 两种实现（AGV、Sensor），统一序列化输出。

Level 4 — 项目实践

练习 4.1：在 workspace/phase-02/interface/ 构建 mini 设备管理模块：interface 定义、3 种设备实现、注册与批量状态报告。

---

11. 学习检查

完成练习后，确认你能回答：

1. Go interface 与 TS interface 的实现方式有何本质区别？
2. 值接收者和指针接收者对 interface 满足有何影响？
3. var d DeviceReporter = (*AGV)(nil) 时 d == nil 是 true 还是 false？
4. type assertion 的 value, ok := x.(T) 形式为什么更安全？
5. 为什么说「接受 interface，返回 struct」是 idiomatic Go？
6. 空接口 any 在什么场景下使用？有什么代价？

---

12. 下一步

已完成	下一知识点	关系
interface	error handling	多态函数同样要处理 error 返回值
	JSON	interface 常配合 json.Unmarshal 解析动态数据
	package design	interface 是包边界抽象的关键工具

建议顺序：先学 error handling，再学 JSON 和 package design，最后进入并发专题。

---

前置知识提醒

本知识点假设你已掌握 Phase 01 的 struct、method、指针接收者。如有疑问，回顾 docs/phase-01-fundamentals/ 中 struct 与 method 章节。

---

学习导航

上一篇：method · 对应练习 · 下一篇：Go Error Handling