Go语言中处理共享字段的挑战
在go语言中，我们经常会遇到不同的结构体类型拥有相同的字段，例如：
type CoordinatePoint struct {
x int
y int
// 其他不相关的字段和方法
}
type CartesianPoint struct {
x int
y int
// 其他不相关的字段和方法
}假设我们希望编写一个通用方法，例如 ConvertXYToPolar(point XYPoint) PolarPoint，能够同时处理 CoordinatePoint 和 CartesianPoint 这两种类型，将它们的 x 和 y 坐标转换为极坐标表示。
然而，Go语言的接口设计不允许声明字段，只能声明方法。这意味着我们不能直接定义一个包含 x 和 y 字段的接口，让 CoordinatePoint 和 CartesianPoint 去实现它。如果这两种类型定义了 GetX() 和 GetY() 等方法，我们可以通过接口来抽象这些行为。但如果仅仅是共享字段，如何在不修改现有类型或不引入过多冗余代码的情况下实现多态，就成为了一个常见问题。
Go语言的惯用解法：结构体嵌入（Composition）
Go语言处理这种场景的惯用且推荐方式是使用结构体嵌入（Composition）。通过将一个包含共享字段的通用结构体嵌入到其他结构体中，可以实现字段的共享和行为的委托，同时保持类型安全。
1. 定义共享基础结构体
首先，我们定义一个包含所有共享字段的基础结构体，例如 Point：
立即学习“go语言免费学习笔记（深入）”；
type Point struct {
x int
y int
}2. 嵌入基础结构体
然后，将 Point 结构体嵌入到 CoordinatePoint 和 CartesianPoint 中。Go语言的嵌入语法使得外部结构体可以直接访问嵌入结构体的字段，如同它们是自己的字段一样：
type CoordinatePoint struct {
Point // 嵌入 Point 结构体
otherStuff string
}
type CartesianPoint struct {
Point // 嵌入 Point 结构体
irrelevantField bool
}通过这种方式，CoordinatePoint 和 CartesianPoint 都“拥有”了 x 和 y 字段。
3. 访问嵌入字段
现在，我们可以像访问自身字段一样访问嵌入结构体的字段：
func main() {
cp := CoordinatePoint{}
cp.x = 10 // 直接访问嵌入的 Point 结构体的 x 字段
cp.y = 20 // 直接访问嵌入的 Point 结构体的 y 字段
fmt.Printf("CoordinatePoint: x=%d, y=%d\n", cp.x, cp.y)
cartP := CartesianPoint{}
cartP.x = 30
cartP.y = 40
fmt.Printf("CartesianPoint: x=%d, y=%d\n", cartP.x, cartP.y)
}4. 对嵌入结构体进行操作
如果有一个函数需要接收 Point 类型作为参数，我们可以直接传递嵌入的 Point 实例：
func doAThingWithAPoint(p Point) {
fmt.Printf("处理 Point: x=%d, y=%d\n", p.x, p.y)
}
func main() {
cp := CoordinatePoint{Point: Point{x: 10, y: 20}}
doAThingWithAPoint(cp.Point) // 传递嵌入的 Point 实例
cartP := CartesianPoint{Point: Point{x: 30, y: 40}}
doAThingWithAPoint(cartP.Point)
}这种方法在处理通用字段时非常有效，它在语法上类似于其他语言中的继承，但在Go中其本质是组合。
将 WCAG 2 AA 无障碍标准应用于设计系统、UI 组件和网页——通过可运行的验证器进行对比度计算，采用设计 token 模式使颜色天生可访问，设定排版和焦点状态规则，并提供语义检查清单。适用于构建或审查 UI。
通过接口增强多态性
虽然结构体嵌入解决了字段共享的问题，但如果我们需要编写一个能接受 任何 包含 Point 字段的类型作为参数的函数，而不仅仅是 Point 本身，我们就需要结合接口。
1. 定义一个返回嵌入结构体的接口
我们可以定义一个接口，要求实现者提供一个方法来获取其内部的 Point 实例：
type Pointer interface {
GetPoint() *Point // 返回一个 Point 的指针
}2. 实现接口方法
然后，让 CoordinatePoint 和 CartesianPoint 实现这个 Pointer 接口：
func (cp CoordinatePoint) GetPoint() *Point {
return &cp.Point // 返回嵌入的 Point 结构体的地址
}
func (cartP CartesianPoint) GetPoint() *Point {
return &cartP.Point
}3. 编写接受接口参数的通用函数
现在，我们可以编写一个函数，它接受 Pointer 接口作为参数，从而能够处理任何实现了该接口的类型：
func processAnyPointer(p Pointer) {
point := p.GetPoint()
fmt.Printf("通过接口处理 Point: x=%d, y=%d\n", point.x, point.y)
// 假设 ConvertXYToPolar 需要一个 Point 类型
// polar := ConvertXYToPolar(*point) // 进一步处理
}
func main() {
cp := CoordinatePoint{Point: Point{x: 100, y: 200}}
cartP := CartesianPoint{Point: Point{x: 300, y: 400}}
processAnyPointer(cp) // 传入 CoordinatePoint
processAnyPointer(cartP) // 传入 CartesianPoint
}这种结合了结构体嵌入和接口的方法，提供了一种类型安全且灵活的多态实现，使得我们能够编写操作多种具有相似数据结构的通用代码。
关于Getter/Setter方法的考量
另一种实现多态的方法是为每个共享字段定义 GetX(), SetX(), GetY(), SetY() 等方法，然后定义一个包含这些方法的接口。例如：
type XYAccesser interface {
GetX() int
SetX(x int)
GetY() int
SetY(y int)
}
func (cp CoordinatePoint) GetX() int { return cp.x }
func (cp CoordinatePoint) SetX(x int) { cp.x = x }
// ... 为 CoordinatePoint 和 CartesianPoint 实现所有这些方法虽然这种方法也能达到目的，但通常被认为比结构体嵌入和 GetPoint() 接口方法更繁琐和冗长，尤其是在字段数量较多时。Go语言推崇简洁，除非有特定理由需要限制对字段的直接访问（例如进行额外的数据验证），否则直接通过嵌入字段或返回嵌入结构体的方式更为常见。
Go接口设计哲学：行为而非数据
Go语言接口不允许定义字段的设计决策，是其核心设计哲学的一部分。Go接口强调的是 行为契约，而非 数据结构契约。
- 关注行为： 接口定义了一组方法，这些方法描述了类型可以做什么，而不是它拥有什么数据。这促进了“鸭子类型”的实现，即只要一个类型表现得像某种东西（实现了接口的所有方法），它就可以被视为那种东西。
- 松散耦合： 接口将实现细节与使用方解耦。使用方只关心类型能提供的行为，而不必关心其内部如何存储数据。
- 简单性与明确性： 如果接口可以定义字段，那么关于字段的初始化、内存布局、访问权限等问题将变得复杂，可能引入类似于类继承中“钻石问题”的复杂性。Go的设计哲学倾向于简单和明确，通过组合而非继承来构建复杂结构。
- 组合优于继承： Go语言通过结构体嵌入和接口的组合，鼓励“组合优于继承”的设计模式。结构体嵌入提供了数据共享和行为委托的便利，而接口则提供了多态性的机制，两者协同工作，使得代码既灵活又易于理解。
总结与最佳实践
在Go语言中处理具有相同字段的不同类型并实现多态时：
- 首选结构体嵌入： 当多个结构体共享一组共同字段时，定义一个包含这些字段的基础结构体，并将其嵌入到其他结构体中，是Go语言的惯用方式。这提供了字段的直接访问和代码复用。
- 结合接口实现多态： 如果需要编写一个能够操作所有这些包含嵌入结构体的通用函数，可以定义一个接口，该接口包含一个返回嵌入结构体实例（通常是指针）的方法。然后让所有相关类型实现这个接口。
- 避免冗余的Getter/Setter： 除非有明确的封装或验证需求，否则避免为每个字段都创建 Getter/Setter 方法。Go语言鼓励直接访问字段，尤其是在同一个包内部。
- 理解Go接口的本质： Go接口是行为的抽象，而非数据的抽象。这一设计决策是Go语言简洁性和强大组合能力的基础。
通过灵活运用结构体嵌入和接口，开发者可以在Go语言中实现高效、类型安全且易于维护的多态代码，充分利用Go的结构化类型特性。
