经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » Go语言 » 查看文章
Golang 面向对象深入理解
来源：cnblogs　　作者：一流菜鸟　　时间：2023/11/1 9:00:51　　对本文有异议

1 封装

Java 中封装是基于类（Class），Golang 中封装是基于结构体（struct）

Golang 的开发中经常直接将成员变量设置为大写使用，当然这样使用并不符合面向对象封装的思想。

Golang 没有构造函数，但有一些约定俗成的方式：

  1. 提供 NewStruct(s Struct) *Struct 这样的函数
  2. 提供 (s *Struct) New() 这样的方法
  3. 也可以直接用传统的 new(struct) 或 Struct{} 来初始化，随后用 Set 方法对成员变量赋值
  1. type People struct {
  2. 	name string
  3. 	age  int
  4. }
  6. func (p *People) SetName(name string) {
  7. 	p.name = name
  8. }
  10. func (p *People) GetName() string {
  11. 	return p.name
  12. }
  14. func (p *People) SetAge(age int) {
  15. 	p.age = age
  16. }
  18. func (p *People) GetAge() int {
  19. 	return p.age
  20. }
  22. func main() {
  23. 	peo := new(People)
  24. 	peo.SetName("张三")
  25. 	peo.SetAge(13)
  26. 	fmt.Println(peo.GetName(), peo.GetAge())
  27.     // 张三 13
  28. }

2 继承 or 组合

Golang 不支持继承，支持组合，算是“组合优于继承”思想的体现。

虽然不支持继承，但 Golang 的匿名组合组合可以实现面向对象继承的特性。

2.1 非匿名组合和匿名组合

组合分为非匿名组合和匿名组合

非匿名组合不能直接使用内嵌结构体的方法，需要通过内嵌结构体的变量名，间接调用内嵌结构体的方法。

匿名组合可以直接使用内嵌结构体的方法，如果有多个内嵌结构体，可以直接使用所有内嵌结构体的方法。

非匿名组合实例：

  1. type People struct {
  2. 	name string
  3. 	age  int
  4. }
  6. func (p *People) SetName(name string) {
  7. 	p.name = name
  8. }
  10. func (p *People) GetName() string {
  11. 	return p.name
  12. }
  14. func (p *People) SetAge(age int) {
  15. 	p.age = age
  16. }
  18. func (p *People) GetAge() int {
  19. 	return p.age
  20. }
  22. type Student struct {
  23. 	people People
  24. 	grade  string
  25. }
  27. func (s *Student) SetGrade(grade string) {
  28. 	s.grade = grade
  29. }
  31. func (s *Student) GetGrade() string {
  32. 	return s.grade
  33. }
  35. func main() {
  36. 	stu := Student{}
  37. 	stu.people.SetName("张三")
  38. 	stu.people.SetAge(13)
  39. 	stu.SetGrade("七年级")
  40. 	fmt.Println(stu.people.GetName(), stu.people.GetAge(), stu.GetGrade())
  41. 	// 张三 13 七年级
  42. }

非匿名组合主要体现在 Student 结构体中对 People 的组合需要明确命名。

匿名组合实例：

  1. type People struct {
  2. 	name string
  3. 	age  int
  4. }
  6. func (p *People) SetName(name string) {
  7. 	p.name = name
  8. }
  10. func (p *People) GetName() string {
  11. 	return p.name
  12. }
  14. func (p *People) SetAge(age int) {
  15. 	p.age = age
  16. }
  18. func (p *People) GetAge() int {
  19. 	return p.age
  20. }
  22. type Student struct {
  23. 	People
  24. 	grade  string
  25. }
  27. func (s *Student) SetGrade(grade string) {
  28. 	s.grade = grade
  29. }
  31. func (s *Student) GetGrade() string {
  32. 	return s.grade
  33. }
  35. func (s *Student) GetName() string {
  36. 	return fmt.Sprintf("student-%s",s.People.GetName())
  37. }
  39. func main() {
  40. 	stu := Student{}
  41. 	stu.SetName("张三")
  42. 	stu.SetAge(13)
  43. 	stu.SetGrade("七年级")
  44. 	fmt.Println(stu.GetName(), stu.GetAge(), stu.GetGrade())
  45. 	// student-张三 13 七年级
  46. }

从上面实例可以看出，匿名组合中:

  1. Student 中的 People 没有显式命名
  2. Student 可以直接使用 People 的方法
  3. 注意 Student 的 GetName 方法，与 People 中的 GetName 方法重复，可以看做是面相对象编程中的重写(Overriding)
  4. Student 的 GetName 方法中使用 s.People.GetName() 调用People 中的 GetName 方法，这是对匿名组合的显式调用，类似 Java 中的 super 用法

可以看出，匿名组合的使用感官上类似面向对象编程的继承，可以说是一种『伪继承』的实现，但匿名组合并不是继承！

2.2 组合的使用方式

2.2.1 结构体中内嵌结构体

上面实例所用的就是结构体中内嵌结构体，不再多说。

2.2.2 结构体中内嵌接口

内嵌接口如下面例子：

  1. type Member interface {
  2. 	SayHello() // 问候语
  3. 	DoWork()   // 开始工作
  4. 	SitDown()  // 坐下
  5. }
  7. type Normal struct{}
  9. func (n *Normal) SayHello() {
  10. 	fmt.Println("normal:", "大家好！")
  11. }
  13. func (n *Normal) DoWork() {
  14. 	fmt.Println("normal:", "记笔记")
  15. }
  17. func (n *Normal) SitDown() {
  18. 	fmt.Println("normal:", "坐下")
  19. }
  21. type People struct {
  22. 	name string
  23. 	age  int
  24. }
  26. func (p *People) SetName(name string) {
  27. 	p.name = name
  28. }
  30. func (p *People) GetName() string {
  31. 	return p.name
  32. }
  34. func (p *People) SetAge(age int) {
  35. 	p.age = age
  36. }
  38. func (p *People) GetAge() int {
  39. 	return p.age
  40. }
  42. type Student struct {
  43. 	Member
  44. 	People
  45. 	grade string
  46. }
  48. func (s *Student) SetGrade(grade string) {
  49. 	s.grade = grade
  50. }
  52. func (s *Student) GetGrade() string {
  53. 	return s.grade
  54. }
  56. func (s *Student) SayHello() {
  57. 	fmt.Println("student:", s.name, "说: 老师好！")
  58. }
  60. type Teacher struct {
  61. 	Member
  62. 	People
  63. 	subject string
  64. }
  66. func (t *Teacher) SetSubject(subject string) {
  67. 	t.subject = subject
  68. }
  70. func (t *Teacher) GetSubject() string {
  71. 	return t.subject
  72. }
  74. func (t *Teacher) SayHello() {
  75. 	fmt.Println("teacher", t.name, "说: 同学们好！")
  76. }
  78. func (t *Teacher) DoWork() {
  79. 	fmt.Println("teacher", t.name, "讲课！")
  80. }
  82. func main() {
  83. 	stu := &Student{Member: &Normal{}}
  84. 	stu.SetName("张三")
  85. 	stu.SetAge(13)
  86. 	stu.SetGrade("七年级")
  88. 	tea := &Teacher{Member: &Normal{}}
  89. 	tea.SetName("李四")
  90. 	tea.SetAge(31)
  91. 	tea.SetSubject("语文")
  93. 	var member Member
  94. 	member = stu
  95. 	member.SayHello()
  96. 	member.SitDown()
  97. 	member.DoWork()
  98. 	// student: 张三 说: 老师好！
  99. 	// normal: 坐下
  100. 	// normal: 记笔记
  102. 	member = tea
  103. 	member.SayHello()
  104. 	member.SitDown()
  105. 	member.DoWork()
  106. 	// teacher 李四 说: 同学们好！
  107. 	// normal: 坐下
  108. 	// teacher 李四 讲课！
  109. }

从上面例子可以看出：

  1. Teacher 和 Student 结构体都没有完全实现 Member 的方法
  2. Normal 结构体实现了 Member 方法
  3. Teacher 和 Student 初始化时注入了 Normal 结构
  4. Teacher 和 Student 可以作为 Member 类型的接口使用，并默认使用 Normal 的实现。除非 Teacher 和 Student 有自己的实现。

Teacher 和 Student 并非没有实现 Member 接口。编译器自动为类型 *Teacher 和 *Student 实现了 Member 中定义的方法,类似：

  1. func (t *Teacher) SitDown() {  
  2.     t.Member.SitDown()  
  3. }

所以即使在初始化时没有指定 Normal，Teacher 和 Student 也可以赋值给 Member 类型的变量。但调用未实现的 Member 的方法时会报 panic

官方实践

可以参考 sort.Reverse 方法，reverse 结构体内嵌了 Interface 接口，并只实现了 Less 方法

  1. type IntSlice []int
  3. func (x IntSlice) Len() int           { return len(x) }
  4. func (x IntSlice) Less(i, j int) bool { return x[i] < x[j] }
  5. func (x IntSlice) Swap(i, j int)      { x[i], x[j] = x[j], x[i] }
  7. type Interface interface {
  8.     // 长度
  9. 	Len() int
  10.     // 对比两个数 i,j，返回结果作为排序的依据
  11. 	Less(i, j int) bool
  12.     // 交换两个数 i,j
  13. 	Swap(i, j int)
  14. }
  16. type reverse struct {
  17. 	Interface
  18. }
  20. func (r reverse) Less(i, j int) bool {
  21. 	return r.Interface.Less(j, i)
  22. }
  24. func Reverse(data Interface) Interface {
  25. 	return &reverse{data}
  26. }

使用时：

  1. lst := []int{4, 5, 2, 8, 1, 9, 3}
  2. sort.Sort(sort.Reverse(sort.IntSlice(lst)))
  3. fmt.Println(lst)
  4. // 打印：[9 8 5 4 3 2 1]

可以看出，Reverse 就是用内嵌接口的方式，接收一个 Interface 接口，将 Less 方法的两个参数反转了。

2.2.3 接口中内嵌接口

是针对方法的组合。如 Golang 的 ReadWriter 接口就是 Reader 和 Writer 接口的组合。

  1. type Reader interface {
  2. 	Read(p []byte) (n int, err error)
  3. }
  5. type Writer interface {
  6. 	Write(p []byte) (n int, err error)
  7. }
  9. // ReadWriter is the interface that groups the basic Read and Write methods.
  10. type ReadWriter interface {
  11. 	Reader
  12. 	Writer
  13. }

3 多态

多态的定义比较宽松：指一个行为具有多种不同的表现形式。

本质上多态分两种：编译时多态（静态）和运行时多态（动态）

  1. 编译时多态在编译期间，多态就已经确定。重载是编译时多态的一个例子。
  2. 运行时多态在编译时不确定调用哪个具体方法，一直延迟到运行时才能确定。

通常情况下，我们讨论的多态都是运行时多态。Golang 接口就是基于动态绑定实现的多态。

由于 Golang 结构体是『组合』而非『继承』，不能相互转换，所以只有基于接口的多态。

3.1 向上转型

向上转型是实现多态的必要条件。即用父类的引用指向一个子类对象，通过父类引用调用方法时会调用子类的方法。通过父类引用无法调用子类的特有方法，需要『向下转型』。

  1. type Member interface {
  2. 	SayHello() // 问候语
  3. 	DoWork()   // 开始工作
  4. 	SitDown()  // 坐下
  5. }
  7. type People struct {
  8. 	name string
  9. 	age  int
  10. }
  12. func (p *People) SetName(name string) {
  13. 	p.name = name
  14. }
  16. func (p *People) GetName() string {
  17. 	return p.name
  18. }
  20. func (p *People) SetAge(age int) {
  21. 	p.age = age
  22. }
  24. func (p *People) GetAge() int {
  25. 	return p.age
  26. }
  28. type Student struct {
  29. 	People
  30. 	grade string
  31. }
  33. func (s *Student) SetGrade(grade string) {
  34. 	s.grade = grade
  35. }
  37. func (s *Student) GetGrade() string {
  38. 	return s.grade
  39. }
  41. func (s *Student) SayHello() {
  42. 	fmt.Println("student:", s.name, "说: 老师好！")
  43. }
  45. func (s *Student) DoWork() {
  46. 	fmt.Println("student:", s.name, "记笔记")
  47. }
  49. func (s *Student) SitDown() {
  50. 	fmt.Println("student:", s.name, "坐下")
  51. }
  53. type Teacher struct {
  54. 	People
  55. 	subject string
  56. }
  58. func (t *Teacher) SetSubject(subject string) {
  59. 	t.subject = subject
  60. }
  62. func (t *Teacher) GetSubject() string {
  63. 	return t.subject
  64. }
  66. func (t *Teacher) SayHello() {
  67. 	fmt.Println("teacher", t.name, "说: 同学们好！")
  68. }
  70. func (t *Teacher) DoWork() {
  71. 	fmt.Println("teacher", t.name, "讲课！")
  72. }
  74. func (t *Teacher) SitDown() {
  75. 	fmt.Println("teacher:", t.name, "站着讲课，不能坐下！")
  76. }
  78. func main() {
  79. 	stu := &Student{}
  80. 	stu.SetName("张三")
  81. 	stu.SetAge(13)
  82. 	stu.SetGrade("七年级")
  84. 	tea := &Teacher{}
  85. 	tea.SetName("李四")
  86. 	tea.SetAge(31)
  87. 	tea.SetSubject("语文")
  89. 	var member Member
  90. 	member = stu
  91. 	member.SayHello()
  92. 	member.SitDown()
  93. 	member.DoWork()
  94. 	// student: 张三 说: 老师好！
  95. 	// student: 张三 坐下
  96. 	// student: 张三 记笔记
  98. 	member = tea
  99. 	member.SayHello()
  100. 	member.SitDown()
  101. 	member.DoWork()
  102. 	// teacher 李四 说: 同学们好！
  103. 	// teacher: 李四 站着讲课，不能坐下！
  104. 	// teacher 李四 讲课！
  105. }

这里是基于接口实现的『向下转型』，没有父类、子类之分。而在 Java 中，当子类没有重写父类方法时，父类的引用会调用到父类的方法里。其实也有类似的实现，在上面已经有了，即2.2.2 结构体中内嵌接口

3.2 向下转型

上面提到，用父类的引用指向一个子类对象，通过父类引用无法调用子类的特有方法。但在某些情况下需要调用子类的特有方法，例如子类有一些特殊逻辑需要处理，这时就需要『向下转型』还原出子类的引用。

在 Java 里，通常用 User user = (User) people; 来向下转型。

Golang 向下转型通过类型断言。基本用法是t,ok := intefaceValue.(T)。

一个例子：

  1. type Member interface {
  2. 	SayHello() // 问候语
  3. }
  5. type People struct {
  6. 	name string
  7. 	age  int
  8. }
  10. func (p *People) SetName(name string) {
  11. 	p.name = name
  12. }
  14. func (p *People) GetName() string {
  15. 	return p.name
  16. }
  18. func (p *People) SetAge(age int) {
  19. 	p.age = age
  20. }
  22. func (p *People) GetAge() int {
  23. 	return p.age
  24. }
  26. type Student struct {
  27. 	People
  28. 	grade string
  29. }
  31. func (s *Student) SetGrade(grade string) {
  32. 	s.grade = grade
  33. }
  35. func (s *Student) GetGrade() string {
  36. 	return s.grade
  37. }
  39. func (s *Student) SayHello() {
  40. 	fmt.Println("student:", s.name, "说: 老师好！")
  41. }
  43. func main() {
  44. 	stu := &Student{}
  45. 	stu.SetName("张三")
  46. 	stu.SetAge(13)
  47. 	stu.SetGrade("七年级")
  49. 	var member Member = stu
  50. 	member.SayHello()
  51. 	// student: 张三 说: 老师好！
  52. 	if student, ok := member.(*Student); ok {
  53. 		student.SetName("王五")
  54. 		student.SayHello()
  55. 		// student: 王五 说: 老师好！
  56. 	}
  57. }
  1. 使用 Member 类型的引用，指向一个 Student 对象
  2. 想对 Student 对象设置一个新名称，使用类型断言向下转型，可以调用 Student 的 SetName 方法（严格的说，是 People 的 SetName 方法）

除了上面场景，还有一种场景需要类型断言:当有一个函数，其参数是 interface{} 类型时：

  1. func SayHello(inter interface{}) {
  2. 	if member, ok := inter.(Member); ok {
  3. 		member.SayHello()
  4. 	}
  5. }
  7. func main() {
  8. 	stu := &Student{}
  9. 	stu.SetName("张三")
  10. 	stu.SetAge(13)
  11. 	stu.SetGrade("七年级")
  13. 	SayHello(stu)
  14. 	// student: 张三 说: 老师好！
  15. }

补充：除了类型断言，Golang 还有一种 type-switch 的方式可以用于对 interface 的类型探测，从而进行不同逻辑的处理。

4 参考资料

  1. Golang 中 struct 嵌入 interface
  2. 面向对象思考与 golang cobra 库实现原理
  3. 多态中的向上转型与向下转型

原文链接：https://www.cnblogs.com/ccwd/p/17800795.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Go语言热门文章

  • Golang从文件服务器获取图片显示到客户端
  • 谈谈Go语言中的内存重排
  • Golang&nbsp;模块引入及表格读写业务快速实现示例
  • 创建并使用https证书
  • golang的reflection（转）
  • TICK技术栈（一）TICK技术栈介绍
  • beego解读Cache之MemoryCache
  • go语言reflect包最佳实践之struct操作（遍历、赋值与方法调用）
  • golang中gin框架接入jwt使用token验证身份
  • Golang解析、验证、修改URL之Host、Port、Path

    • Go语言推荐文章

  • Go 互斥锁 Mutex 源码分析(二)
  • golang对遍历目录操作的优化
  • 美团VS饿了么，到底谁更胜一筹？
  • 解码 xsync 的 map 实现
  • [golang]在Gin框架中使用JWT鉴权
  • Golang 依赖注入设计哲学｜12.6K &#127775; 的依赖注入库 wire
  • 这么简单的问题都不会，那还面试什么！？
  • golang select 和外层的 for 搭配
  • Go语言的100个错误使用场景（61-68）｜并发实践
  • 实战：如何优雅的从 Skywalking 切换到 OpenTelemetry

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号