Go语言中无法为接口定义方法，求避免重复实现的优雅方案

方案一：利用结构体嵌入与构造函数绑定（无重复代码） #

这种方式通过定义通用的starter结构体实现start()方法，再让car和motorbike嵌入该结构体，通过构造函数将自身绑定到starter上，实现方法逻辑的完全复用。

package main

import "fmt"

type vehicle struct {
    make  string
    model string
}

type runner interface {
    run()
}

// 通用starter类型，封装start的核心逻辑
type starter struct {
    r runner
}

func (s *starter) start() {
    s.r.run()
}

type car struct {
    *vehicle
    bootSpace float64
    *starter // 嵌入starter，自动提升start方法
}

type motorbike struct {
    *vehicle
    maxSpeed float64
    *starter // 嵌入starter，自动提升start方法
}

func (c *car) run() {
    fmt.Println("Running the car.")
}

func (m *motorbike) run() {
    fmt.Println("Running the motorbike.")
}

// 构造函数：初始化car并绑定自身到starter
func NewCar(make, model string, bootSpace float64) *car {
    c := &car{
        vehicle:   &vehicle{make: make, model: model},
        bootSpace: bootSpace,
    }
    c.starter = &starter{r: c}
    return c
}

// 构造函数：初始化motorbike并绑定自身到starter
func NewMotorbike(make, model string, maxSpeed float64) *motorbike {
    m := &motorbike{
        vehicle:   &vehicle{make: make, model: model},
        maxSpeed:  maxSpeed,
    }
    m.starter = &starter{r: m}
    return m
}

func main() {
    a := NewMotorbike("Yamaha", "R1", 299)
    b := NewCar("Toyota", "Camry", 524)

    a.start() // 直接调用复用的start方法
    b.start()
}

方案二：包级私有函数复用逻辑（最小重复代码） #

如果不想修改原有结构体定义，可将通用逻辑封装为包级私有函数，让car和motorbike的start()方法仅做一次调用转发，重复代码仅为一行。

package main

import "fmt"

type vehicle struct {
    make  string
    model string
}

type car struct {
    *vehicle
    bootSpace float64
}

type motorbike struct {
    *vehicle
    maxSpeed float64
}

func (c *car) run() {
    fmt.Println("Running the car.")
}

func (m *motorbike) run() {
    fmt.Println("Running the motorbike.")
}

type runner interface {
    run()
}

// 包级私有函数，仅内部可见，封装start的核心逻辑
func start(r runner) {
    r.run()
}

// 仅做逻辑转发，无重复实现
func (c *car) start() {
    start(c)
}

// 仅做逻辑转发，无重复实现
func (m *motorbike) start() {
    start(m)
}

func main() {
    a := motorbike{}
    b := car{}

    a.start() // 直接调用
    b.start()
}

内容的提问来源于stack exchange，提问作者decadenza