go 没有继承机制，所谓“protected 成员”实为包级未导出字段的自然封装；本文详解如何通过接口抽象、嵌入组合、包内共享和 internal 包设计，安全地复用逻辑并限制字段访问，避免 java 式思维陷阱。
go 没有继承机制，所谓“protected 成员”实为包级未导出字段的自然封装；本文详解如何通过接口抽象、嵌入组合、包内共享和 internal 包设计，安全地复用逻辑并限制字段访问，避免 java 式思维陷阱。
在 Go 中尝试模拟面向对象语言（如 Java）中的 protected 继承机制，本质上是一场与语言哲学的对抗。Go 不提供类、父类、子类、访问修饰符（protected/private）或方法重写——它用接口（interface）定义契约、用结构体嵌入（embedding）实现组合复用、用包作用域（package scope）实现天然的“包内可见”封装。理解并接受这一范式，是写出地道 Go 代码的前提。
✅ 正确路径：用包封装 + 接口抽象 + 受限构造
回到原始需求：多个实现需共享 speed 和 deliveryChan 字段的 setter/getter，但不希望外部用户直接修改 deliveryChan；同时要求各实现分散在不同包中（如 child1、child2），又能复用基础逻辑。
核心原则是：把“可被子类访问但不可被外部访问”的字段和方法，放在一个共同的、非导出的包内（或 internal/ 子目录），而非试图跨包暴露内部状态。
✅ 推荐结构（符合 Go 习惯）
.
├── main.go
├── bottom/ // 主接口与基础实现（导出）
│ ├── bottom.go // 定义 Bottom 接口 & unexported base struct
│ └── new.go // 提供受控构造函数（关键！）
└── child/ // 具体实现（可跨包）
└── simple.go? 关键实现：bottom/bottom.go
// bottom/bottom.go
package bottom
import "fmt"
// Bottom 是公开接口，使用者只依赖此契约
type Bottom interface {
GetYouSome()
SetSpeed(int)
DeliveryMechanism() chan string
}
// baseBottom 是未导出的基础结构体，仅本包及同包实现可嵌入
type baseBottom struct {
speed int
deliveryChan chan string
}
func (b *baseBottom) SetSpeed(speed int) {
b.speed = speed
}
func (b *baseBottom) DeliveryMechanism() chan string {
return b.deliveryChan
}
// NewBaseBottom 是本包提供的唯一受控构造入口
// 返回 *baseBottom（指针），便于嵌入和后续扩展
func NewBaseBottom(speed int, chSize int) *baseBottom {
return &baseBottom{
speed: speed,
deliveryChan: make(chan string, chSize),
}
}⚠️ 注意：baseBottom 是小写开头，完全未导出；外部包无法直接声明 baseBottom 类型变量，也无法访问其字段——这正是 Go 的“protected”语义：包内可见，包外不可见。
✅ 具体实现：child/simple.go
// child/simple.go
package child
import (
"fmt"
"your-module/bottom" // 导入接口和构造器
)
// Composite 显式嵌入 *bottom.baseBottom（指针嵌入，支持方法提升）
type Composite struct {
*bottom.baseBottom // ← 关键：嵌入未导出类型，但能使用其导出方法
name string
}
// 实现接口方法（必须显式实现 GetYouSome）
func (c *Composite) GetYouSome() {
fmt.Printf("Inside %s: speed=%d\n", c.name, c.speed)
// 可安全使用 c.DeliveryMechanism()，因 baseBottom 的方法已提升
}
// New 构造函数返回接口类型（推荐）或具体类型（更灵活）
func New(speed int, name string) bottom.Bottom {
// 复用 bottom 包的受控构造逻辑
base := bottom.NewBaseBottom(speed, 10)
return &Composite{
baseBottom: base,
name: name,
}
}✅ 在 main.go 中使用
// main.go
package main
import (
"fmt"
"your-module/child"
)
func main() {
b := child.New(42, "simple")
b.GetYouSome() // ✅ OK
b.SetSpeed(99) // ✅ OK（方法提升）
ch := b.DeliveryMechanism() // ✅ OK（方法提升）
ch <- "hello" // ✅ OK（chan 可写）
// ❌ 编译错误：无法访问未导出字段或类型
// _ = b.speed // undefined: b.speed
// _ = b.baseBottom // undefined: b.baseBottom
}? 为什么其他方案不推荐？
- 添加 SetChannel() 方法？ → 破坏封装：任何拿到 *GenericBottom 的代码都能调用，违背“仅子类可设”的初衷。
- 跨包直接赋值 impl.deliveryChan = ...？ → 编译失败（字段未导出），且违背封装原则。
- 用 wrapper 手动透传所有方法？ → 冗余、易错、丧失嵌入带来的自动方法提升优势。
- 把 GenericBottom 放在 parent 包并导出？ → 外部包可随意实例化并滥用其字段，失去控制力。
✅ 进阶建议：internal/ 包保障强封装（Go 1.4+）
若需严格禁止其他模块（非 child）使用 baseBottom，可将其移至 bottom/internal/base/ 目录，并确保只有 bottom/ 和 child/ 能导入该 internal 包（Go 会强制检查）。这是比包级封装更严格的“内部 API”边界。
? 总结：Go 风格的“受保护继承”四要素
| 概念 | Go 实现方式 | 说明 |
|---|---|---|
| “基类”逻辑 | 未导出结构体（如 baseBottom） | 仅同包可用，天然 protected |
| “子类”复用 | 嵌入 *baseBottom（指针嵌入最佳） | 自动获得方法，无需手动透传 |
| “受控构造” | 导出 NewBaseBottom() 函数 | 封装初始化逻辑（如 channel 创建） |
| “接口契约” | 导出 Bottom 接口 | 上层依赖接口，解耦具体实现 |
? 最后忠告：当你的设计中频繁出现 “parent”、“child”、“subclass”、“override” 等词汇时，请暂停编码，重读 io、net/http 或 database/sql 的源码——你会发现：优雅的 Go 代码，从不模拟继承，而是在接口与组合的留白处，长出最健壮的枝干。
