Golang中面向对象的三大特性之多态的理解

多态：同一操作作用于不同对象，可以产生不同的行为，Go中通过接口实现。

比如：

Go 复制代码

// serializer/common.go
type Response struct {
    Status int         `json:"status"`
    Data   interface{} `json:"data"`  // interface{} 可以是任何类型
    Msg    string      `json:"msg"`
    Error  string      `json:"error"`
}

它的体现：

Go 复制代码

// 返回任务列表时
BuildListResponse(items []WaiCengTask, total uint) //返回任务列表时，data是dataList类型
// Data 是 DataList 类型

// 返回单个任务时
serializer.BuildTask(task)
// Data 是 WaiCengTask 类型

// 返回用户信息时
BuildUser(user)
// Data 是 User 类型

// 返回错误时
Response{Status: 400, Error: err.Error()}
// Data 是 nil

还有一种比如是说：gin框架的c.json-同一方法，不同数据

Go 复制代码

// api/task.go

// 场景1：返回任务列表
func ListTasks(c *gin.Context) {
    res := listService.List(chaim.Id, listService.Limit, listService.Start)
    c.JSON(200, res)  // 发送列表数据
}

// 场景2：返回创建成功消息
func CreateTask(c *gin.Context) {
    res := createService.Create(chaim.Id, createService.Title, createService.Content)
    c.JSON(200, res)  // 发送成功消息
}

// 场景3：返回错误信息
func ShowTask(c *gin.Context) {
    res := showTaskService.Show(c.Param("id"))
    c.JSON(200, res)  // 发送任务详情
}

最简单的例子就是：

先定义一个叫的接口

Go 复制代码

// 定义一个"叫"的接口
type Animal interface {
    Speak() string
}

其次，狗实现Animal：

Go 复制代码

type Dog struct{}

func (d Dog) Speak() string {
    return "汪汪汪"  // 狗的叫法
}

猫实现Animal：

Go 复制代码

type Cat struct{}

func (c Cat) Speak() string {
    return "喵喵喵"  // 猫的叫法
}

鸟实现Animal：

Go 复制代码

type Bird struct{}

func (b Bird) Speak() string {
    return "叽叽叽"  // 鸟的叫法
}

统一调用：

Go 复制代码

// 统一调用 Speak() 方法
func makeSpeak(animal Animal) {
    fmt.Println(animal.Speak())  // 不管是什么动物，都调用 Speak()
}

func main() {
    dog := Dog{}
    cat := Cat{}
    bird := Bird{}
    
    makeSpeak(dog)   // 输出: 汪汪汪
    makeSpeak(cat)   // 输出: 喵喵喵
    makeSpeak(bird)  // 输出: 叽叽叽
}