go里面的继承实现，父类类型做为函数入参，怎么传子类作为参数

或许这么写可以满足你的想法（公共逻辑可以绑定到父结构体Task上）

package main

import ( "log" "time" )

type Task struct { TaskExec Status int Name string StratTime int64 EndTime int64 }

func (t Task) start() { // 修改任务状态为执行中 t.Status = 1 // 记录任务开始执行时间 t.StratTime = time.Now().Unix() // 这里还会有很共性逻辑处理被省略掉了

}

func (t Task) end() { // 修改任务状态为执行结束 t.Status = 2 // 记录任务执行结束时间 t.EndTime = time.Now().Unix() }

type TaskExec interface { exec() }

type TaskA struct { Task ParamA string }

type TaskB struct { Task ParamA string }

func (a TaskA) exec() { // 执行任务A的逻辑 a.start() //A特有逻辑 log.Println("A特有逻辑") a.end()

}

func (b TaskB) exec() {

b.start()
//B特有逻辑
log.Println("B特有逻辑")
b.end()

}

// 执行任务，问题点在入参这里，这样写入参就只能是Task，不能传TaskA和TaskB， // 用go有什么办法可以实现像java一样传子类做为入参 func Exec(task TaskExec) {

// 这里也是还会有很共性逻辑处理被省略掉了
//具体逻辑
task.exec()

}

func main() { ta := TaskA{} tb := TaskB{}

// 这里要怎么才能传子类到函数里面执行？？？？
Exec(&ta)
Exec(&tb)

}

你看这样会不会好点, Task 作为执行者，实际 exec 可以根据需求设置为实现 TaskExec 的对象。

type Task struct {
    exec      TaskExec
    Status    int
    Name      string
    StartTime int64
    EndTime   int64
}

func NewTask(exec TaskExec) *Task {
    return &Task{
        exec: exec,
    }
}

type TaskExec interface {
    exec()
}

type TaskA struct {
    ParamA string
}

type TaskB struct {
    ParamA string
}

func (TaskA) exec() {
    // 执行任务A的逻辑
}

func (TaskB) exec() {
    // 执行任务B的逻辑
}

// 执行任务，问题点在入参这里，这样写入参就只能是Task，不能传TaskA和TaskB，
// 用go有什么办法可以实现像java一样传子类做为入参
func (t *Task) Exec() {
    // 修改任务状态为执行中
    t.Status = 1
    // 记录任务开始执行时间
    t.StartTime = time.Now().Unix()
    // 这里还会有很共性逻辑处理被省略掉了

    // 执行具体任务的逻辑
    t.exec.exec()
    // 修改任务状态为执行结束
    t.Status = 2
    // 记录任务执行结束时间
    t.EndTime = time.Now().Unix()
    // 这里也是还会有很共性逻辑处理被省略掉了
}

func main() {
    ta := NewTask(&TaskA{})
    tb := NewTask(&TaskB{})

    // 这里要怎么才能传子类到函数里面执行？？？？
    ta.Exec()
    tb.Exec()
}

你这个接近我描述需要的要求，但我实际要实现逻辑要复杂一点，这里只是简化了。实际具体的任务逻辑还有几个函数要实现的，例如前置后置通知，异常通知等，你这样实现每个任务的执行方法都要重复这个代码逻辑，我大概要实现10来个任务，还是会有很多冗余代码，不过还是感谢回复

感谢回复，你这个基本达到了我的要求， 但在 NewTask 之后已经不是原来的对象，执行任务里面的逻辑改了任务状态不是原来任务对象的状态。就这里还有点问题，我顺着你的思路想想怎么搞

@lnktoking 嗯，go的多态一般是结合interface接口去实现，你可以顺着这个思路结合你实际的需求尝试尝试

java 的上转型确实巧妙，回归正题，用 go 的话我会这样写

type ITask interface {
    TaskExec

    // 通过接口方法间接访问属性
    Info() *TaskInfo
}

type Task struct {
    TaskExec
    TaskInfo
}

func (task *Task) Info() *TaskInfo {
    return &task.TaskInfo
}

// 封装属性
type TaskInfo struct {
    Status    int
    Name      string
    StartTime uint64
    EndTime   uint64
}

type TaskExec interface {
    exec()
}

type TaskA struct {
    Task
    ParamA string
}

type TaskB struct {
    Task
    ParamA string
}

func (TaskA) exec() {
    // 执行任务A的逻辑
}

func (TaskB) exec() {
    // 执行任务B的逻辑
}

// 在 go 中用接口实现多态
func Exec(task ITask) {
    // 接口无法访问属性，通过 Info 方法间接访问
    // 修改任务状态为执行中
    task.Info().Status = 1
    // 记录任务开始执行时间
    task.Info().StartTime = uint64(time.Now().Unix())
    // 这里还会有很共性逻辑处理被省略掉了

    // 执行具体任务的逻辑
    task.exec()
    // 修改任务状态为执行结束
    task.Info().Status = 2
    // 记录任务执行结束时间
    task.Info().EndTime = uint64(time.Now().Unix())
    // 这里也是还会有很共性逻辑处理被省略掉了
}

func main() {
    ta := TaskA{}
    tb := TaskB{}

    // 嵌入 Task 的类型自动实现 ITask 接口，可以被传入 Exec 函数
    Exec(&ta)
    Exec(&tb)
}