Golang 面向对象编程
Go 语言虽然没有像 Java 或 C++ 那样的 class 关键字和经典的面向对象（OOP）体系，但它通过其独特的结构体（Struct）、方法（Method）、接口（Interface）以及组合（Composition），提供了一套同样强大且更简洁的面向对象编程范式。
其核心思想可以概括为：组合优于继承，接口定义行为。
封装（Encapsulation）
封装的目的是隐藏内部实现细节，只暴露必要的接口（API）供外部使用。这有助于保护数据不被意外修改，并降低模块间的耦合度。
Go 通过包（package）和标识符的大小写来实现封装：
- 首字母大写：标识符（如变量、常量、类型、函数、结构体字段）是公开的（Public），可以在任何包中被访问。
- 首字母小写：标识符是私有的（Private），只能在其定义的包内部被访问。
如何实现封装：
- 定义结构体，并将需要保护的字段设为首字母小写。
- 提供一个首字母大写的工厂函数（类似构造函数），用于创建结构体实例。
- 提供首字母大写的
Setter和Getter方法，用于安全地访问和修改私有字段。
代码示例：
假设我们有一个 employee 包。
employee/employee.go:
go
package employee
import "fmt"
// Employee 结构体的字段是小写的，外部包无法直接访问
type Employee struct {
name string
age int
salary float64
}
// New 是一个工厂函数，用于创建 Employee 实例
// 我们可以在这里加入初始化的逻辑和验证
func New(name string, age int, salary float64) (*Employee, error) {
if name == "" {
return nil, fmt.Errorf("name cannot be empty")
}
if age <= 0 {
return nil, fmt.Errorf("age must be positive")
}
return &Employee{
name: name,
age: age,
salary: salary,
}, nil
}
// Name 是一个 Getter 方法，用于获取 name 字段
func (e *Employee) Name() string {
return e.name
}
// SetSalary 是一个 Setter 方法，用于修改 salary 字段
// 可以在这里加入数据验证逻辑
func (e *Employee) SetSalary(newSalary float64) error {
if newSalary < 0 {
return fmt.Errorf("salary cannot be negative")
}
e.salary = newSalary
return nil
}
// GetSalary 是另一个 Getter
func (e *Employee) GetSalary() float64 {
return e.salary
}main.go:
go
package main
import (
"fmt"
"log"
"your_module_name/employee" // 替换为你的模块名
)
func main() {
// 只能通过工厂函数创建实例
emp, err := employee.New("Alice", 30, 5000)
if err != nil {
log.Fatal(err)
}
// emp.name = "Bob" // 这行代码会编译错误！因为 name 是私有的
// 只能通过公开的方法访问数据
fmt.Printf("Employee Name: %s\n", emp.Name())
// 通过 Setter 安全地修改数据
err = emp.SetSalary(6000)
if err != nil {
log.Fatal(err)
}
fmt.Printf("New Salary: %.2f\n", emp.GetSalary())
// 尝试设置一个无效值
err = emp.SetSalary(-100)
if err != nil {
fmt.Println("Error setting salary:", err)
}
}组合（替代继承）
Go 语言没有传统意义上的继承。它通过**结构体嵌入（Composition，即组合）**来鼓励代码复用，这种方式通常比继承更灵活、更清晰。
当一个结构体匿名地嵌入另一个结构体时，外部结构体可以直接访问被嵌入结构体的字段和方法，就好像是自己的一样。这在形式上看起来很像“继承”，但其本质是组合。
代码示例：
go
package main
import "fmt"
// 1. 定义一个基础结构体 Animal
type Animal struct {
Name string
Age int
}
// 为 Animal 添加方法
func (a *Animal) Eat() {
fmt.Printf("%s is eating.\n", a.Name)
}
// 2. 定义 Dog 结构体，匿名嵌入 Animal
type Dog struct {
Animal // 匿名嵌入，Dog "继承" 了 Animal 的所有字段和方法
Breed string
}
// Dog 也可以有自己的方法
func (d *Dog) Bark() {
fmt.Printf("%s is barking!\n", d.Name)
}
// 3. 定义 Bird 结构体，也匿名嵌入 Animal
type Bird struct {
Animal
CanFly bool
}
// Bird 可以 "重写" Animal 的方法
// 注意：这不是真正的重写，只是 Bird 类型有了一个同名的方法
// 它会覆盖掉从 Animal "继承" 来的 Eat 方法
func (b *Bird) Eat() {
fmt.Printf("%s is pecking at seeds.\n", b.Name)
}
func main() {
// 创建 Dog 实例
dog := Dog{
Animal: Animal{Name: "Buddy", Age: 5},
Breed: "Golden Retriever",
}
fmt.Println("Dog's name:", dog.Name) // 直接访问 Animal 的字段
fmt.Println("Dog's age:", dog.Age)
dog.Eat() // 调用从 Animal "继承" 的方法
dog.Bark() // 调用自己的方法
fmt.Println("---")
// 创建 Bird 实例
bird := Bird{
Animal: Animal{Name: "Tweety", Age: 2},
CanFly: true,
}
fmt.Println("Bird's name:", bird.Animal.Name) // 也可以这样访问
bird.Eat() // 调用 Bird 自己的 Eat 方法
}输出：
text
Dog's name: Buddy
Dog's age: 5
Buddy is eating.
Buddy is barking!
---
Bird's name: Tweety
Tweety is pecking at seeds.组合的注意事项：
- 清晰的所属关系: 组合使得关系非常明确（“Dog has an Animal”），避免了传统继承中复杂的“is-a”层级关系和脆弱的基类问题。
- 方法覆盖: 如上例所示，外层结构体可以定义与内层结构体同名的方法，调用时会优先使用外层的方法。这提供了类似方法重写（override）的功能。
- 避免滥用: 虽然组合很强大，但也不应滥用。只有当两个实体确实存在“has-a”关系时才适合使用。否则，独立的组件或接口可能是更好的选择。
接口（Interface）与多态
接口（Interface）是Go语言的核心特性之一，也是其实现抽象和多态的关键。与传统面向对象语言（如Java、C++）中的接口不同，Go的接口是非侵入式的，或者说是“鸭子类型”（Duck Typing）的体现——“如果一个东西走起来像鸭子，叫起来也像鸭子，那它就是一只鸭子”。
核心特性：
- 方法签名集合：接口类型定义了一组方法签名（方法名、参数列表、返回值列表），但没有实现。
- 隐式实现：任何类型，只要它实现了接口中所有的方法，就被视为自动地、隐式地实现了该接口。无需像Java那样使用
implements关键字显式声明。 - 解耦合：接口是连接不同代码模块的“插座”，它定义了模块间的“契约”，使得模块可以独立开发和替换，从而实现代码的解耦合。
接口的定义与实现
定义一个接口非常简单，就是将一组方法放在 interface{} 代码块中。
go
package main
import "fmt"
// 1. 定义一个接口 Shape，它有一个 Area() 方法
type Shaper interface {
Area() float64
}
// 2. 定义两个结构体类型
type Rectangle struct {
Width, Height float64
}
type Circle struct {
Radius float64
}
// 3. 为 Rectangle 类型实现 Area() 方法
func (r Rectangle) Area() float64 {
return r.Width * r.Height
}
// 4. 为 Circle 类型实现 Area() 方法
func (c Circle) Area() float64 {
return 3.14159 * c.Radius * c.Radius
}
// 5. 定义一个接收 Shaper 接口类型参数的函数
// 这个函数不关心传入的是 Rectangle 还是 Circle，只关心它有没有 Area() 方法
func printArea(s Shaper) {
fmt.Printf("Area of shape is: %.2f\n", s.Area())
}
func main() {
rect := Rectangle{Width: 10, Height: 5}
circ := Circle{Radius: 5}
// 因为 Rectangle 和 Circle 都实现了 Area() 方法，
// 它们都满足 Shaper 接口，所以可以被传递给 printArea 函数。
printArea(rect)
printArea(circ)
}
// 输出:
// Area of shape is: 50.00
// Area of shape is: 78.54说明：Rectangle 和 Circle 从未声明过自己要实现 Shaper 接口。Go编译器在调用 printArea 时，会自动检查传入的 rect 和 circ 是否拥有 Area() float64 方法，如果拥有，类型转换就自动完成。这就是Go接口非侵入式设计的魅力。
空接口 interface{}
空接口 interface{} 是一个特殊的接口类型，因为它不包含任何方法。
根据Go的接口规则，任何类型都至少实现了零个方法，因此，任何类型都满足空接口。
这使得空接口成为一种可以存储任意类型值的通用容器，类似于C语言的 void* 或Java的 Object。
go
package main
import "fmt"
func describe(i interface{}) {
fmt.Printf("Value: %v, Type: %T\n", i, i)
}
func main() {
var i interface{}
// 空接口可以持有任何类型的值
i = 42
describe(i)
i = "hello"
describe(i)
i = true
describe(i)
// 也可以用于创建能存储任意类型元素的集合
heterogeneousList := []interface{}{1, "world", false, 3.14}
for _, item := range heterogeneousList {
describe(item)
}
}
// 输出:
// Value: 42, Type: int
// Value: hello, Type: string
// Value: true, Type: bool
// Value: 1, Type: int
// Value: world, Type: string
// Value: false, Type: bool
// Value: 3.14, Type: float64当我们将一个具体类型的值存入接口后，其原始类型信息虽然被保留，但我们无法直接使用其特有的字段或方法。要从接口中“取回”原始的具体类型，就需要使用类型断言或类型选择。
类型断言 (Type Assertion)
语法: value.(T)
- 它断言接口
value中存储的动态类型是T。 - 如果断言成功，它返回
T类型的值。 - 如果失败，程序会
panic。
为了安全，应使用“comma, ok”范式：v, ok := value.(T)。
go
package main
import "fmt"
func main() {
var i interface{} = "hello"
// 安全的类型断言
s, ok := i.(string)
if ok {
fmt.Printf("断言成功: s = '%s'\n", s)
}
// 尝试断言为 int (会失败，但不会 panic)
n, ok := i.(int)
if !ok {
fmt.Printf("断言为 int 失败, n 的值为 int 的零值: %d\n", n)
}
}
// 输出:
// 断言成功: s = 'hello'
// 断言为 int 失败, n 的值为 int 的零值: 0类型选择 (Type Switch)
如果需要检查一个接口变量可能是多种类型中的哪一种，并据此执行不同操作，使用 switch 语句会更清晰。
go
package main
import "fmt"
func checkType(i interface{}) {
switch v := i.(type) { // v 在每个 case 块中是该 case 对应的类型
case int:
fmt.Printf("这是一个 int, 值是 %d\n", v)
case string:
fmt.Printf("这是一个 string, 值是 '%s'\n", v)
case bool:
fmt.Printf("这是一个 bool, 值是 %t\n", v)
default:
fmt.Printf("未知的类型: %T\n", v)
}
}
func main() {
checkType(42)
checkType("Go语言")
checkType(3.14)
}
// 输出:
// 这是一个 int, 值是 42
// 这是一个 string, 值是 'Go语言'
// 未知的类型: float64Common Pitfall:
nil接口与持有nil指针的接口这是一个非常重要且微妙的区别，是很多
bug的来源。
- 一个
nil接口值 ：其类型和值都为nil。if i == nil结果为true。- 一个持有
nil指针的接口值：其类型不为nil（例如是*os.File），但其值为nil。if i == nil结果为false！gopackage main import ( "fmt" "os" ) func main() { var f *os.File // f 是一个 nil 指针 var i interface{} // i 是 nil 接口值 fmt.Printf("i: type=%T, value=%v, is nil? %t\n", i, i, i == nil) i = f // 将 nil 指针赋给接口 i // i 现在持有类型 *os.File 和值 nil // 它不再是一个 nil 接口了！ fmt.Printf("i: type=%T, value=%v, is nil? %t\n", i, i, i == nil) } // 输出: // i: type=<nil>, value=<nil>, is nil? true // i: type=*os.File, value=<nil>, is nil? falseBest Practice: 当函数返回一个接口类型的错误时，永远不要返回一个具体的、值为
nil的指针类型，而应该直接返回nil。go// 错误的做法 func connect() error { var err *MyError = nil // 即使 err 是 nil return err // 返回的 error 接口不等于 nil！ } // 正确的做法 func connect() error { // ... return nil }