3. 接口基础概念：接口定义、隐式实现、空接口、类型断言、类型 switch

接口是 Go 语言中实现多态和松耦合的核心机制。与 Java、C# 等语言不同，Go 的接口采用隐式实现，即类型无需显式声明“implements”关键字，只要实现了接口要求的所有方法，就自动满足该接口。这种设计让代码更加灵活，也更容易进行单元测试和系统解耦。

3.1 接口定义

接口使用 type 关键字定义，内部只包含方法签名（方法名、参数列表、返回值列表），不包含任何实现代码。

// 定义一个文件读取器接口
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
}

3.2 隐式实现

在 Go 中，类型实现接口是自动的、隐式的。只要一个类型拥有接口中声明的所有方法，它就自动实现了该接口，无需显式声明。

package main

import "fmt"

// 定义接口
type Speaker interface {
    Speak() string
}

// 定义两个不同的类型
type Dog struct {
    Name string
}

type Robot struct {
    Model string
}

// Dog 实现了 Speaker 接口
func (d Dog) Speak() string {
    return d.Name + " says: 汪汪！"
}

// Robot 实现了 Speaker 接口
func (r Robot) Speak() string {
    return "Robot " + r.Model + " says: 哔哔哔——"
}

// 接受 Speaker 接口参数的函数
func Introduce(s Speaker) {
    fmt.Println(s.Speak())
}

func main() {
    dog := Dog{Name: "旺财"}
    robot := Robot{Model: "R2-D2"}

    Introduce(dog)   // 旺财 says: 汪汪！
    Introduce(robot) // Robot R2-D2 says: 哔哔哔——
}

3.3 空接口 interface{}

空接口不包含任何方法，因此所有类型都实现了空接口。它类似于 Java 中的 Object 或 C 中的 void*，可以持有任意类型的值。

// 空接口可以接收任意类型的值
var any interface{}

any = 42
any = "hello"
any = 3.14
any = []int{1, 2, 3}
any = struct{ Name string }{"Alice"}

// 空接口作为函数参数，可接受任意类型
func PrintValue(v interface{}) {
    fmt.Printf("值: %v, 类型: %T\n", v, v)
}

// 空接口作为 map 的值类型，实现异构数据存储
func main() {
    data := make(map[string]interface{})
    data["name"] = "张三"
    data["age"] = 30
    data["active"] = true
    data["scores"] = []int{95, 88, 92}
}

3.4 类型断言

类型断言用于从接口值中提取其底层的具体值。语法为：x.(T)，其中 x 是接口类型表达式，T 是目标类型。

var val interface{} = "Hello, Go!"

// 基本断言（不安全：如果类型不匹配会 panic）
s := val.(string)
fmt.Println(s) // Hello, Go!

// 安全断言（使用逗号 ok 模式）
s, ok := val.(string)
if ok {
    fmt.Println("字符串值:", s)
} else {
    fmt.Println("类型不匹配")
}

// 断言为其他类型
n, ok := val.(int)
if !ok {
    fmt.Println("val 不是 int 类型") // 输出此条
}

// 断言接口为另一个接口
var r io.Reader = os.Stdin
if w, ok := r.(io.Writer); ok {
    w.Write([]byte("可写\n"))
}

3.5 类型 switch

类型 switch 是一种特殊的 switch 语句，用于对接口值的动态类型进行多分支匹配。它比连续使用类型断言更简洁、更安全。

func DescribeType(v interface{}) {
    switch t := v.(type) {
    case nil:
        fmt.Println("值为 nil")
    case int:
        fmt.Printf("整数: %d\n", t)
    case string:
        fmt.Printf("字符串: %q (长度: %d)\n", t, len(t))
    case bool:
        fmt.Printf("布尔值: %v\n", t)
    case []int:
        fmt.Printf("整数切片: %v (长度: %d)\n", t, len(t))
    case map[string]interface{}:
        fmt.Printf("字典: %v (键数: %d)\n", t, len(t))
    default:
        fmt.Printf("未知类型: %T, 值: %v\n", t, t)
    }
}

func main() {
    DescribeType(42)
    DescribeType("Go语言")
    DescribeType(true)
    DescribeType([]int{1, 2, 3})
    DescribeType(nil)
}

3.6 综合示例：接口契约与类型安全

以下示例展示了接口定义、隐式实现、空接口、类型断言和类型 switch 的综合运用，模拟一个简单的日志处理系统。

package main

import (
    "fmt"
    "strings"
)

// 1. 定义接口契约
type Logger interface {
    Log(level string, message string)
}

// 2. 隐式实现：控制台日志器
type ConsoleLogger struct {
    Prefix string
}

func (c ConsoleLogger) Log(level string, message string) {
    fmt.Printf("[%s] %s: %s\n", c.Prefix, level, message)
}

// 3. 隐式实现：文件日志器（模拟）
type FileLogger struct {
    FilePath string
}

func (f FileLogger) Log(level string, message string) {
    fmt.Printf("写入文件 %s: [%s] %s\n", f.FilePath, level, message)
}

// 4. 使用空接口和类型 switch 处理不同格式的日志输入
func ProcessLogEntry(logger Logger, entry interface{}) {
    switch v := entry.(type) {
    case string:
        logger.Log("INFO", v)
    case error:
        logger.Log("ERROR", v.Error())
    case map[string]string:
        for key, val := range v {
            logger.Log("DEBUG", fmt.Sprintf("%s=%s", key, val))
        }
    case []byte:
        logger.Log("INFO", string(v))
    default:
        logger.Log("WARN", fmt.Sprintf("未知日志格式: %T", v))
    }
}

func main() {
    console := ConsoleLogger{Prefix: "APP"}
    file := FileLogger{FilePath: "/var/log/app.log"}

    // 接口变量可以持有任意实现
    var loggers []Logger = []Logger{console, file}

    // 不同类型的日志条目
    entries := []interface{}{
        "用户登录成功",
        fmt.Errorf("数据库连接超时"),
        map[string]string{"action": "query", "table": "users"},
        []byte("二进制日志数据"),
        12345, // 未知类型
    }

    for _, logger := range loggers {
        fmt.Println("--- 使用日志器 ---")
        for _, entry := range entries {
            ProcessLogEntry(logger, entry)
        }
    }
}

3.7 接口使用原则与避坑指南

// 接口 nil 陷阱示例
var p *int = nil
var i interface{} = p

fmt.Println(p == nil) // true
fmt.Println(i == nil) // false！因为 i 的动态类型是 *int

// 正确做法：检查动态值
if i == nil {
    fmt.Println("接口为 nil")
} else {
    // 需要进一步断言检查动态值
    if v, ok := i.(*int); ok && v == nil {
        fmt.Println("接口持有 nil 指针")
    }
}