``` go
type Task struct{
TaskExec
Status int
Name string
StratTime int64
EndTime int64
}
type TaskExec interface{
exec()
}
type TaskA struct{
Task
ParamA string
}
type TaskB struct{
Task
ParamA string
}
func (TaskA) exec(){
// 执行任务A的逻辑
}
func (TaskB) exec(){
// 执行任务B的逻辑
}
// 执行任务,问题点在入参这里,这样写入参就只能是Task,不能传TaskA和TaskB,
// 用go有什么办法可以实现像java一样传子类做为入参
func Exec(task *Task){
// 修改任务状态为执行中
task.Status = 1
// 记录任务开始执行时间
task.StartTime = uint64(time.Now().Unix())
// 这里还会有很共性逻辑处理被省略掉了
// 执行具体任务的逻辑
task.exec()
// 修改任务状态为执行结束
task.Status = 2
// 记录任务执行结束时间
task.EndTime = uint64(time.Now().Unix())
// 这里也是还会有很共性逻辑处理被省略掉了
}
func main(){
ta := TaskA{}
tb := TaskB{}
// 这里要怎么才能传子类到函数里面执行????
Exec(&ta)
Exec(&tb)
}
```
<a href="/user/lnktoking" title="@lnktoking">@lnktoking</a> 嗯,go的多态一般是结合interface接口去实现,你可以顺着这个思路结合你实际的需求尝试尝试
#5
更多评论
或许这么写可以满足你的想法(公共逻辑可以绑定到父结构体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)
}
#1
你看这样会不会好点, `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()
}
```
#2