empty_interface

  1. package main
  2. import "fmt"
  3. //type Empty interface {
  4. //}
  5. type Course struct {
  6. name string
  7. price int
  8. url string
  9. }
  10. type Printer interface {
  11. printInfo() string
  12. }
  13. func (c Course) printInfo() string {
  14. return "课程信息"
  15. }
  16. //func print(x interface{}) {
  17. // //此处的ok是bool类型
  18. // if v, ok := x.(int); ok { //判断是不是int类型
  19. // //x是int类型
  20. // fmt.Printf("%d, 整数\n", v)
  21. // }
  22. //
  23. // if s, ok := x.(string); ok {
  24. // fmt.Printf("%s,字符串\n", s)
  25. //
  26. // }
  27. // //牵扯到go的另一个默认的问题
  28. // //fmt.Printf("%v\n ", i)
  29. //}
  30. type AliOss struct {
  31. //保存
  32. //下载
  33. }
  34. type LocalFile struct {
  35. }
  36. func store(x interface{}) {
  37. switch v := x.(type) {
  38. case AliOss:
  39. //此处要做一些特殊的处理,比如设置阿里云的权限问题
  40. fmt.Println(v)
  41. case LocalFile:
  42. //检查路径的权限
  43. fmt.Println(v)
  44. }
  45. }
  46. func print(x interface{}) {
  47. //类型断言
  48. switch x := x.(type) {
  49. case string:
  50. fmt.Printf("%s,字符串\n", x)
  51. case int:
  52. fmt.Printf("%d, 整数\n", x)
  53. case float64:
  54. fmt.Printf("%f, 浮点数\n", x)
  55. }
  56. }
  57. func main() {
  58. //空接口
  59. var i interface{} //有点像多态
  60. //空接口可以类似于我们java和python中的object
  61. //i = Course{}
  62. //fmt.Println(i)
  63. i = 10
  64. print(i)
  65. i = "hello"
  66. fmt.Println(i)
  67. //i = []string{"django", "scrapy"}
  68. //fmt.Println(i)
  69. //1.空接口的第一个用途,可以把任何类型都赋值给空接口变量
  70. //2.参数传递 什么类型都可以打印 什么类型都可以接收
  71. //3.空接口可以作为map的值
  72. //var teacherInfo = make(map[string]interface{})
  73. //teacherInfo["name"] = "wozen"
  74. //teacherInfo["age"] = 18
  75. //teacherInfo["weight"] = 72.5
  76. //teacherInfo["courses"] = []string{"hello", "world"}
  77. //fmt.Printf("%v\n", teacherInfo)
  78. //类型断言
  79. //接口的一个坑, 接口引入了
  80. //接口还有一个默认的规范 接口的名称以 er 结尾
  81. //c := &Course{}
  82. //var c Printer = Course{}
  83. //c.printInfo()
  84. //fmt.Println()
  85. }

interface_test

  1. package main
  2. import (
  3. "fmt"
  4. )
  5. // Programmer 接口是一个协议 - 程序员 - 只要你能够1.写代码 2.解决bug 其实就是一组方法的集合
  6. type Programmer interface {
  7. Coding() string //方法只是声明
  8. Debug() string
  9. }
  10. type Designer interface {
  11. Design() string
  12. }
  13. type Manager interface {
  14. Programmer
  15. Designer
  16. Manage() string
  17. }
  18. type G struct {
  19. }
  20. type Pythoner struct {
  21. UIDesigner
  22. lib []string
  23. kj []string
  24. years []int
  25. }
  26. // Java的话 java里面一种类型只要继承一个接口才行 如果你继承了这个接口的话 那么这个接口里面的所有方法你必须要全部实现
  27. type UIDesigner struct {
  28. }
  29. func (d UIDesigner) Design() string {
  30. fmt.Println("我会UI设计")
  31. return "我会UI设计"
  32. }
  33. func (p G) Coding() string {
  34. fmt.Println("go开发者")
  35. return "go开发者"
  36. }
  37. func (p G) Debug() string {
  38. fmt.Println("我会 go 的debug")
  39. return "我会go的debug"
  40. }
  41. func (p Pythoner) Coding() string {
  42. fmt.Println("python开发者")
  43. return "python开发者"
  44. }
  45. func (p Pythoner) Debug() string {
  46. fmt.Println("我会python的debug")
  47. return "我会python的debug"
  48. }
  49. func (p Pythoner) Manage() string {
  50. fmt.Println("不好意思,管理我也懂")
  51. return "不好意思,管理我也懂"
  52. }
  53. //func (p Pythoner) Design() string {
  54. // fmt.Println("我是一个python开发者,但是我会搞UI设计")
  55. // return "我是一个python开发者,但是我会搞UI设计"
  56. //}
  57. //对于 Pythoner 这个结构体来说 你实现任何方法都可以 但是你只要不全部实现这两个方法 那么你Pythoner结构体就不是一个Programmer类型
  58. //1.Pythoner本身自己就是一个类型 那我何必在意我是不是Programmer
  59. //2.封装 继承 多态 -多态的概念对于很多 Pythoner来说会有点陌生
  60. //3.在讲解多态之前,我们来对interface做一个说明:在go语言中接口是一种类型 是一种抽象类型
  61. func HandlePy(pythoner Pythoner) {
  62. }
  63. func HandleGo(g G) {
  64. }
  65. //func HandleJava(pythoner Pythoner) {
  66. //
  67. //}
  68. type myError struct {
  69. }
  70. func (m myError) Error() string {
  71. return "错误"
  72. }
  73. func main() {
  74. //新的语言出来了 接口帮我们完成了go语言的多态
  75. //var pro Programmer = Pythoner{}
  76. //var g G = G{}
  77. //pro.Coding()
  78. var pros []Programmer
  79. pros = append(pros, Pythoner{})
  80. pros = append(pros, G{})
  81. //接口虽然是一种类型 但是和其他类型不太一样 接口是一种抽象类型 struct 是具象
  82. p := Pythoner{}
  83. fmt.Printf("%T\n", p)
  84. var pro Programmer = Pythoner{}
  85. var pro2 Programmer = G{}
  86. fmt.Printf("%T\n", pro)
  87. fmt.Printf("%T\n", pro2)
  88. //如果大家对于面向对象理解的话 java 里面的抽象类型有点像
  89. //1. go struct 组合 组合一起实现了所有的接的方法也是可以的
  90. //2.接口本身也支持组合
  91. var m Manager = Pythoner{}
  92. //struct 组合完成了接口 1.接口支持组合 - 继承2.结构体组合实现了所有的接口方法也没有问题
  93. m.Design()
  94. //python语言本身设计上是采用了完全的基于鸭子类型 - 协议 影响了python语法的for len()
  95. //go语言也推荐鸭子类型 error
  96. //var err error = error() //并不能实例化 抽象类型
  97. //var err error = myError{}
  98. //var err error = errors.New("错误")
  99. s := "文件不存在"
  100. var err error = fmt.Errorf("错误:%s", s)
  101. fmt.Println(err)
  102. }
  103. //开发中经常会遇到的问题
  104. //开发一个电商网站 支付环境 wx zfb yhk 你的系统支持各种类型的支付 每一种支付类型都有统一的接口
  105. //定一个协议 1. 支付 2.创建订单 3.查询支付状态 4.退款
  106. //支付发起了
  107. //type AliPay struct {
  108. //}
  109. //
  110. //type WeChat struct {
  111. //}
  112. //type Bank struct {
  113. //}
  114. //
  115. //var b Bank
  116. //var a AliPay
  117. //var w WeChat
  118. type Tongyong struct {
  119. }
  120. //多态 声明类型的时候你声明的类型是一种兼容类型,但是实际赋值的时候是另一种类型
  121. //接口是强制性
  122. //你现在有一个缓存系统 - 这个地方你一开始使用的缓存是redis 但是后期你考虑到可能使用其他的缓存技术 - 本地 memcache
  123. /*
  124. var x Tongyong
  125. x = Bank{}
  126. x = AliPay{}
  127. x = WeChat{}
  128. x.pay
  129. x.create
  130. x.query
  131. */
  132. //这种多态特性 其实在python中不需要多态 python是动态语言
  133. //go语言中并不支持继承
  134. //如果后期接入一种新的支付 或者取消已有的支付

sort_test

  1. package main
  2. import (
  3. "fmt"
  4. "sort"
  5. )
  6. type Course struct {
  7. Name string
  8. Price int
  9. Url string
  10. }
  11. type Courses []Course
  12. func (c Courses) Len() int {
  13. return len(c)
  14. }
  15. func (c Courses) Less(i, j int) bool {
  16. return c[i].Price < c[j].Price
  17. }
  18. func (c Courses) Swap(i, j int) {
  19. c[i], c[j] = c[j], c[i]
  20. }
  21. func main() {
  22. //通过sort来排序
  23. //让你写一个排序算法 冒泡 快速 桶 归并 桶排序 算法本质是一样的 比较 计数排序
  24. //你的排序算法是否能应付各种类型的排序
  25. courses := Courses{
  26. Course{"django",300,""},
  27. Course{"scrapy",100,""},
  28. Course{"go",150,""},
  29. Course{"tornado",200,""},
  30. }
  31. sort.Sort(courses) //协议 你的目的不是要告诉别人具体的类型,重要的是你的类型必须提供具体的方法
  32. for _ , v := range courses {
  33. fmt.Println( v)
  34. }
  35. //data := []int{1, 3, 6, 7, 2}
  36. //sort.Sort(data) //协议
  37. /*
  38. 无法将 'data' (类型 []int) 用作类型 Interface 类型未实现 'Interface',
  39. 因为缺少某些方法: Len() int Less(i int, j int) bool Swap(i int, j int)
  40. */
  41. //grpc
  42. //go语言的包以及编码规范 包管理 1.12之前 python java maven go-modules
  43. }