Go语言类型切换（Type Switch）中变量t的类型行为解析

package main

import (
    "fmt"
)

// 定义一个接口
type MyInterface interface {
    MyMethod() string
}

// 实现接口的结构体A
type MyStructA struct {
    Name string
}

func (m MyStructA) MyMethod() string {
    return "Hello from MyStructA: " + m.Name
}

// 实现接口的结构体B
type MyStructB struct {
    Value int
}

func (m MyStructB) MyMethod() string {
    return fmt.Sprintf("Hello from MyStructB with value: %d", m.Value)
}

func main() {
    var myVar MyInterface // 声明一个接口变量

    // 场景1: myVar 持有 MyStructA 类型
    myVar = MyStructA{Name: "Alice"}
    fmt.Println("--- 场景1: myVar 持有 MyStructA ---")
    processInterface(myVar)

    // 场景2: myVar 持有 MyStructB 类型
    myVar = MyStructB{Value: 123}
    fmt.Println("\n--- 场景2: myVar 持有 MyStructB ---")
    processInterface(myVar)

    // 场景3: myVar 持有 nil
    myVar = nil
    fmt.Println("\n--- 场景3: myVar 持有 nil ---")
    processInterface(myVar)

    // 场景4: myVar 持有实现了MyInterface但未在case中明确列出的类型
    type MyCustomStruct struct{}
    func (m MyCustomStruct) MyMethod() string { return "Custom method" }
    myVar = MyCustomStruct{}
    fmt.Println("\n--- 场景4: myVar 持有 MyCustomStruct ---")
    processInterface(myVar)
}

func processInterface(im MyInterface) {
    switch t := im.(type) {
    case MyStructA:
        // 在此case中，t的类型是MyStructA
        fmt.Printf("Case MyStructA: t的类型是 %T, 值为 %+v\n", t, t)
        fmt.Println("可以访问MyStructA特有的字段:", t.Name)
        fmt.Println("调用MyMethod:", t.MyMethod())
    case MyStructB:
        // 在此case中，t的类型是MyStructB
        fmt.Printf("Case MyStructB: t的类型是 %T, 值为 %+v\n", t, t)
        fmt.Println("可以访问MyStructB特有的字段:", t.Value)
        fmt.Println("调用MyMethod:", t.MyMethod())
    case nil:
        // 在此case中，t的值是nil，但其静态类型仍然是MyInterface
        fmt.Printf("Case nil: t的类型是 %T, 值为 %v\n", t, t)
    default:
        // 在此default中，t的类型是原始接口类型MyInterface
        fmt.Printf("Default case: t的类型是 %T, 值为 %v\n", t, t)
        // 此时t仍是MyInterface类型，可以直接调用接口方法
        if t != nil {
            fmt.Println("调用MyMethod:", t.MyMethod()) 
        }
    }
}

--- 场景1: myVar 持有 MyStructA ---
Case MyStructA: t的类型是 main.MyStructA, 值为 {Name:Alice}
可以访问MyStructA特有的字段: Alice
调用MyMethod: Hello from MyStructA: Alice

--- 场景2: myVar 持有 MyStructB ---
Case MyStructB: t的类型是 main.MyStructB, 值为 {Value:123}
可以访问MyStructB特有的字段: 123
调用MyMethod: Hello from MyStructB with value: 123

--- 场景3: myVar 持有 nil ---
Case nil: t的类型是 <nil>, 值为 <nil>

--- 场景4: myVar 持有 MyCustomStruct ---
Default case: t的类型是 main.MyInterface, 值为 {}
调用MyMethod: Custom method