跳到主要内容

Go 面向对象笔记

Go 没有 class,但用 struct(数据)+ method(行为)+ interface(多态)+ embedding(复用)四件套实现"面向对象"。 这套设计是 Go 的精髓——比传统 OOP 简单,但需要换一种思维方式。 对应 demo:04_oop


1. struct:数据载体​

1.1 定义​

type Person struct {
Name string
Age int
City string
}

1.2 字段类型相同的简化​

type Point struct{ X, Y int }

1.3 6 种实例化方式​

// 1. 零值
var p1 Person
// 2. 字面量(按字段顺序,不推荐)
p2 := Person{"张三", 25, "北京"}
// 3. 字面量(指定字段名,✅ 推荐)
p3 := Person{Name: "李四", Age: 30}
// 4. 取指针
p4 := &Person{Name: "王五", City: "上海"}
// 5. new(零值指针)
p5 := new(Person)
p5.Name = "赵六"
// 6. 构造函数(约定返回 *T)
p6 := NewPerson("周八", 40, "广州")
func NewPerson(name string, age int, city string) *Person {
return &Person{Name: name, Age: age, City: city}
}

字段访问永远用 .:p1.Name、p4.Name(指针自动解引用)。

1.4 字段可见性(重要!)​

  • 首字母大写:导出(其他包可见)
  • 首字母小写:包内私有
type User struct {
Name string // 导出
email string // 不导出(其他包访问不到)
}

2. 方法(method)​

2.1 定义​

func (接收器) 方法名(参数) 返回值 { ... }

2.2 接收器两种类型​

值接收器​

func (p Person) Greet() string {
return "Hi, I'm " + p.Name
}
  • 操作的是副本
  • 不会修改原对象
  • 适合:只读、值很小、纯计算

指针接收器​

func (p *Person) HaveBirthday() {
p.Age++ // 改的是原对象
}
  • 操作的是原对象
  • 可以修改
  • 适合:要改 / 结构体大 / 接口一致性

2.3 选择规则​

情况选
方法要修改接收器指针
结构体字段多、避免拷贝指针
Map、Slice、Channel 内元素指针
其他情况值

混用规则:一个类型上的方法,要么全是值接收器,要么全是指针接收器。混用容易出 bug。

2.4 给自定义类型加方法​

type MyFloat float64
func (f MyFloat) Abs() float64 { ... }

不能给别的包定义的类型加方法(如 int、time.Time),但可以基于它们定义新类型再加方法。


3. 嵌入(embedding)—— Go 的"继承"​

3.1 是什么​

把一个 struct 当匿名字段放到另一个 struct 里,外层自动获得内层的字段和方法(字段提升)。

type Person struct { Name string; Age int; City string }
type Employee struct {
Person // 匿名字段
Salary int
Dept string
}
e := Employee{
Person: Person{Name: "钱七", Age: 28, City: "深圳"},
Salary: 30000,
}

// 字段提升:e.Name 等价于 e.Person.Name
fmt.Println(e.Name, e.City, e.Salary)

// 方法也提升:e.Greet() 等价于 e.Person.Greet()
fmt.Println(e.Greet())

3.2 vs 传统继承​

维度传统继承(Java)Go 嵌入
关系"is-a""has-a"(内部有)
多态通过父类不能当父类用(多态靠 interface)
重写override没有,要"重写"用同名字段遮蔽

3.3 同名字段遮蔽​

type Employee struct {
Person
Name string // 遮蔽了 Person.Name
}
e := Employee{Person: Person{Name: "内层"}, Name: "外层"}
fmt.Println(e.Name) // "外层"
fmt.Println(e.Person.Name) // "内层"

4. interface:多态 ⭐ 关键​

4.1 是什么​

一组方法签名的集合。任何类型只要实现了接口里所有方法,就自动实现了接口(鸭子类型,编译期检查)。

4.2 定义与实现​

// 任何有 Speak() string 的类型都实现 Speaker
type Speaker interface {
Speak() string
}

type Dog struct{ Name string }
func (d Dog) Speak() string { return d.Name + ": 汪" }

type Cat struct{ Name string }
func (c Cat) Speak() string { return c.Name + ": 喵" }

4.3 多态用法​

speakers := []Speaker{Dog{Name: "旺财"}, Cat{Name: "小花"}}
for _, s := range speakers {
fmt.Println(s.Speak()) // 调各自的实现
}

4.4 接口组合​

type Reader interface { Read(p []byte) (n int, err error) }
type Writer interface { Write(p []byte) (n int, err error) }

// 嵌入组合出新接口
type ReadWriter interface {
Reader
Writer
}

4.5 多类型 / 多接口关系​

场景Go 怎么写
一个类型实现多个接口直接满足多个接口的方法集即可
多个类型实现同一个接口同上,不需要 implements 关键字
一个类型嵌入另一个类型内嵌类型实现的接口,外层也自动实现

4.6 空接口 interface{} / any​

能存任意类型(Go 1.18+ 推荐用 any 替代 interface{}):

var x interface{} = 42
var y any = "hello"

fmt.Printf("%v %T\n", x, x) // 42 int

空接口的三个常见用途:

  1. fmt.Println(a ...any) — 接收任意类型
  2. map[string]any — 通用 KV
  3. JSON 反序列化到 map[string]any

4.7 类型断言(从 interface 拿回具体类型)​

var s Speaker = Dog{Name: "旺财"}

// 不安全(panic 风险)
dog := s.(Dog) // 断言失败 panic

// 安全(ok 模式)
dog, ok := s.(Dog)
if ok {
fmt.Println(dog.Name)
}

4.8 type switch​

switch v := s.(type) {
case Dog:
fmt.Println("dog:", v.Name)
case Cat:
fmt.Println("cat:", v.Name)
default:
fmt.Println("other")
}

5. 常见坑​

坑说明
混用值/指针接收器同一类型的方法要么全值,要么全指针
nil 接口 != 持有 nil 指针的接口后者调用方法会 panic("method on nil")
接口零值是 nilvar s Speaker 是 nil,调方法 panic
空接口性能any 涉及 boxing,开销比具体类型大;高频路径别用
接口"小而美"倾向于定义只含 1~3 个方法的小接口(io.Reader 只有一个方法)
接口断言没 ok没 ok 模式断言失败会 panic
嵌入遮蔽字段/方法名同优先级时,外层遮蔽内层

6. Go OOP 与传统 OOP 对比​

维度Java/C++/PythonGo
数据 + 行为classstruct + method
复用继承嵌入(has-a)
多态父类引用 + overrideinterface(鸭子类型)
封装private/public命名大小写
抽象类 / 接口继承abstract classinterface 嵌入

思维转换:从"is-a 继承链"切到"组合 + 小接口"。


7. 速记口诀​

  • 方法 = 函数 + 接收器
  • 嵌入 = has-a(不是 is-a)
  • 接口 = 方法签名集合,实现靠"长得像"
  • 空接口 = any,慎用(性能 + 类型丢失)
  • 类型断言:从 interface 拿回具体类型