Java 仔想在 Go 中写类似 interface -> abstract class -> sub class 的玩意

@mightybruce 他在 main 里面断言，我就问了下为什么不在编译时检测

我不想说了，我已经强调了 go 不是面向对象语言， 实现策略模式请用函数式和接口混用的方式。

go 不存在 抽象类，go 也不存在对象（ class) 这种， 所以不要再谈什么面向对象。

@mightybruce 了解，我这也是写了很多年 Java 思维转不过来，但又需要解决实际问题，只能按这样的写法起模板方便自己。

给一段策略模式代码
```
package main

import "fmt"

// 定义 RouteStrategy 为一个接口，包含 CalculateTime 方法
type RouteStrategy interface {
CalculateTime(origin, destination string) int
}

// 使用函数类型作为策略
type StrategyFunc func(origin, destination string) int

// 实现 RouteStrategy 接口的 CalculateTime 方法
func (sf StrategyFunc) CalculateTime(origin, destination string) int {
return sf(origin, destination)
}

// 实现三种策略：步行、骑行、驾车

func WalkStrategyFunc(origin, destination string) int {
// 假设固定耗时 30 分钟
return 30
}

func BikeStrategyFunc(origin, destination string) int {
// 假设固定耗时 15 分钟
return 15
}

func DriveStrategyFunc(origin, destination string) int {
// 假设固定耗时 10 分钟
return 10
}

// 路线规划器
type RoutePlanner struct {
strategy RouteStrategy
}

// 设置策略
func (rp *RoutePlanner) SetStrategy(strategy RouteStrategy) {
rp.strategy = strategy
}

// 估算出行时间
func (rp *RoutePlanner) EstimateTime(origin, destination string) int {
return rp.strategy.CalculateTime(origin, destination)
}

func main() {
planner := &RoutePlanner{}

// 使用步行策略
walkStrategy := StrategyFunc(WalkStrategyFunc)
planner.SetStrategy(walkStrategy)
fmt.Println("Walk Time:", planner.EstimateTime("Home", "School"))

// 使用骑行策略
bikeStrategy := StrategyFunc(BikeStrategyFunc)
planner.SetStrategy(bikeStrategy)
fmt.Println("Bike Time:", planner.EstimateTime("Home", "School"))

// 使用驾车策略
driveStrategy := StrategyFunc(DriveStrategyFunc)
planner.SetStrategy(driveStrategy)
fmt.Println("Drive Time:", planner.EstimateTime("Home", "Work"))
}
```

我没理解错的话，说白了你就是想实现一个 “模板方法模式” https://refactoringguru.cn/design-patterns/template-method/go/example

简单版的代码就是：

```go
type Worker interface {
MustImplementStep() // 必须被实现的方法
OptionalHook() // 一个有默认行为的、可选的钩子方法
}

type BaseWorker struct{}

func (b *BaseWorker) OptionalHook() {
fmt.Println("-> BaseWorker: 执行默认的钩子逻辑。")
}

type ConcreteWorker struct {
BaseWorker // 嵌入“基类”，OptionalHook 的默认实现。
}

// MustImplementStep 实现接口中必须被实现的方法
func (c *ConcreteWorker) MustImplementStep() {
fmt.Println("-> ConcreteWorker: 执行必须实现的步骤。")
}

// 编译期安全检查，如果 ConcreteWorker 未实现 MustImplementStep （注释掉上面方法）会报错
var _ Worker = (*ConcreteWorker)(nil)

// OptionalHook “重写”嵌入的钩子方法。
func (c *ConcreteWorker) OptionalHook() {
fmt.Println("-> ConcreteWorker: 开始执行重写的钩子逻辑。")

// super.method()
c.BaseWorker.OptionalHook()

fmt.Println("-> ConcreteWorker: 结束执行重写的钩子逻辑。")
}

func RunTemplate(w Worker) {
fmt.Println("--- 模板开始 ---")
w.MustImplementStep()
w.OptionalHook()
fmt.Println("--- 模板结束 ---")
}

func main() {
worker := &ConcreteWorker{}
RunTemplate(worker)
}
```

Base 里一部分是默认的方法实现，一部分是组合调用的逻辑，你需要把这两部分拆开。

@monmon 了解了，不把 Common 放在 Base 里面而是改成函数像 RunTemplate 注入 Worker ，就会简单很多

每个语言都有息的习惯 (idiomatic)。入乡随俗，写 Go 就按 Go 的语言习惯来，才能扩宽视野。有点说教

你都学 go 了为什么不学一学它的范式？推荐去看一下《七周七语言》，你需要看一些完全非 OOP 的语言开拓下对语言范式的视野，强迫自己去写一写 C 也是个方法。

go 的 interface 要简洁很多

让我想到了一个表情包：

无语，跟你说不下去，典型的 Java 思维

@EricYuan1 可以发一下，P 一个 Go 土拨鼠说的版本

有没有像 我这样的 go 里只会用 struct 连 interface 都很少用的...日常就是定义结构体. 写 function 好像也没啥..

@huangmiao233 我类比就像把 package 级 function 当 static 用

用组合来代替继承，忘记继承

典型的 Java 思维, 现代语言已经不搞继承了，组合优于继承。

跟你说不清楚，典型的 Java 思维
https://i.imgur.com/TKfLzat_d.webp