Go语言接口：理解与实践类型断言以实现多态行为

package main

import "fmt"

// Entity 接口定义了所有实体共有的行为
type Entity interface {
    a() string
}

// PhysEntity 接口继承了 Entity，并增加了物理行为
type PhysEntity interface {
    Entity // PhysEntity 包含了 Entity 的所有方法
    b() string
}

// BaseEntity 是 Entity 接口的一个具体实现
type BaseEntity struct{}

func (e *BaseEntity) a() string { return "Hello " }

// BasePhysEntity 是 PhysEntity 接口的一个具体实现
// 它内嵌了 BaseEntity，从而隐式实现了 Entity 接口的 a() 方法
type BasePhysEntity struct {
    BaseEntity // 内嵌 BaseEntity 使得 BasePhysEntity 自动拥有 BaseEntity 的方法
}

func (e *BasePhysEntity) b() string { return "World!" }

func main() {
    // 1. 创建一个 BasePhysEntity 的实例
    concretePhysEnt := new(BasePhysEntity)

    // 2. 将具体类型赋值给 PhysEntity 接口类型
    // 此时 physEnt 变量的静态类型是 PhysEntity，动态类型是 *BasePhysEntity
    physEnt := PhysEntity(concretePhysEnt)
    fmt.Print(physEnt.a()) // 调用 Entity 接口的方法
    fmt.Print(physEnt.b()) // 调用 PhysEntity 接口的方法

    // 3. 将 PhysEntity 接口类型赋值给更通用的 Entity 接口类型
    // 此时 entity 变量的静态类型是 Entity，动态类型仍然是 *BasePhysEntity
    entity := Entity(physEnt)
    fmt.Print(entity.a()) // 只能调用 Entity 接口的方法，因为 entity 的静态类型是 Entity

    // 4. 尝试将 Entity 接口类型直接转换回 PhysEntity 接口类型
    // original := PhysEntity(entity) // 这一行会编译错误！
    // 错误信息：cannot convert entity (type Entity) to type PhysEntity:
    //         Entity does not implement PhysEntity (missing b method)
    // 编译器在编译时只知道 entity 是一个 Entity 类型，它无法保证 entity 运行时也实现了 PhysEntity 接口。
    // 即使我们知道 underlying type 是 BasePhysEntity，编译器在静态检查时也无法得知。
}

package main

import "fmt"

type Entity interface {
    a() string
}

type PhysEntity interface {
    Entity
    b() string
}

type BaseEntity struct{}

func (e *BaseEntity) a() string { return "Hello " }

type BasePhysEntity struct {
    BaseEntity
}

func (e *BasePhysEntity) b() string { return "World!" }

func main() {
    concretePhysEnt := new(BasePhysEntity)
    physEnt := PhysEntity(concretePhysEnt)
    entity := Entity(physEnt) // entity 是一个 Entity 接口类型

    // 使用类型断言将 entity (Entity类型) 转换回 PhysEntity 类型
    original, ok := entity.(PhysEntity)
    if ok {
        fmt.Println("断言成功！")
        fmt.Print(original.a()) // original 现在是 PhysEntity 类型，可以调用 Entity 的方法
        fmt.Println(original.b()) // 也可以调用 PhysEntity 的方法
    } else {
        fmt.Println("断言失败：entity 不是 PhysEntity 类型")
    }

    // 尝试对一个不满足 PhysEntity 接口的类型进行断言
    type SimpleEntity struct{}
    func (s *SimpleEntity) a() string { return "Simple" }

    simple := Entity(new(SimpleEntity))
    _, ok2 := simple.(PhysEntity)
    if !ok2 {
        fmt.Println("断言失败，SimpleEntity 未实现 PhysEntity 接口。这是预期的。")
    }

    // 错误示例：不检查 ok 会导致 panic
    // invalidEntity := Entity(new(SimpleEntity))
    // assertedEntity := invalidEntity.(PhysEntity) // 运行时会 panic: interface conversion: main.Entity is *main.SimpleEntity, not main.PhysEntity
    // fmt.Println(assertedEntity.b())
}