Go 语言里没有 class

  • Go 和其它经典语言不同，它没有 class，没有对象，也没有继承。
  • 但是 Go 提供了 struct 和方法。

将方法关联到 struct

  • 方法可以被关联到你声明的类型上 
  1. package main
  3. import "fmt"
  5. // coordinate in degrees, minutes, seconds in a N/S/E/W hemisphere.
  6. type coordinate struct {
  7.     d, m, s float64
  8.     h       rune
  9. }
  11. // decimal converts a d/m/s coordinate to decimal degrees.
  12. func (c coordinate) decimal() float64 {
  13.     sign := 1.0
  14.     switch c.h {
  15.     case 'S', 'W', 's', 'w':
  16.         sign = -1
  17.     }
  18.     return sign * (c.d + c.m/60 + c.s/3600)
  19. }
  21. func main() {
  22.     // Bradbury Landing: 4º35'22.2" S, 137º26'30.1" E
  23.     lat := coordinate{4, 35, 22.2, 'S'}
  24.     long := coordinate{137, 26, 30.12, 'E'}
  26.     fmt.Println(lat.decimal(), long.decimal())
  27. }

构造函数

  • 可以使用 struct 复合字面值来初始化你所要的数据。
  • 但如果 struct 初始化的时候还要做很多事情，那就可以考虑写一个构造用的函数。
  • Go 语言没有专用的构造函数，但以 new 或者 New 开头的函数，通常是用来构造数据的。例如 newPerson()，NewPerson() 
  1. package main
  3. import "fmt"
  5. // location with a latitude, longitude.
  6. type location struct {
  7.     lat, long float64
  8. }
  10. // coordinate in degrees, minutes, seconds in a N/S/E/W hemisphere.
  11. type coordinate struct {
  12.     d, m, s float64
  13.     h       rune
  14. }
  16. // newLocation from latitude, longitude d/m/s coordinates.
  17. func newLocation(lat, long coordinate) location {
  18.     return location{lat.decimal(), long.decimal()}
  19. }
  21. // decimal converts a d/m/s coordinate to decimal degrees.
  22. func (c coordinate) decimal() float64 {
  23.     sign := 1.0
  24.     switch c.h {
  25.     case 'S', 'W', 's', 'w':
  26.         sign = -1
  27.     }
  28.     return sign * (c.d + c.m/60 + c.s/3600)
  29. }
  31. func main() {
  32.     curiosity := newLocation(coordinate{4, 35, 22.2, 'S'}, coordinate{137, 26, 30.12, 'E'})
  33.     fmt.Println(curiosity)
  34. }

New 函数

  • 有一些用于构造的函数的名称就是 New（例如 errors 包里面的 New 函数）。
  • 这是因为函数调用时使用 包名.函数名 的形式。
  • 如果该函数叫 NewError，那么调用的时候就是 errors.NewError()，这就不如 errors.New() 简洁

class 的替代方案

  • Go 语言没有 class，但使用 struct 并配备几个方法也可以达到同样的效果。 
  1. package main
  3. import (
  4.     "fmt"
  5.     "math"
  6. )
  8. // location with a latitude, longitude.
  9. type location struct {
  10.     lat, long float64
  11. }
  13. // world with a volumetric mean radius in kilometers
  14. type world struct {
  15.     radius float64
  16. }
  18. var mars = world{radius: 3389.5}
  20. // distance calculation using the Spherical Law of Cosines.
  21. func (w world) distance(p1, p2 location) float64 {
  22.     s1, c1 := math.Sincos(rad(p1.lat))
  23.     s2, c2 := math.Sincos(rad(p2.lat))
  24.     clong := math.Cos(rad(p1.long - p2.long))
  25.     return w.radius * math.Acos(s1*s2+c1*c2*clong)
  26. }
  28. // rad converts degrees to radians.
  29. func rad(deg float64) float64 {
  30.     return deg * math.Pi / 180
  31. }
  33. func main() {
  34.     spirit := location{-14.5684, 175.472636}
  35.     opportunity := location{-1.9462, 354.4734}
  37.     dist := mars.distance(spirit, opportunity)
  38.     fmt.Printf("%.2f km\n", dist)
  39. }

作业题

  • 使用例子（22.1、22.2、22.3）中的代码，编写一个程序。并为下表中每个位置都声明一个 location，以十进制度数打印出每个位置。

没有class - 图1 

  1. package main
  3. import "fmt"
  5. // location with a latitude, longitude.
  6. type location struct {
  7.     lat, long float64
  8. }
  10. // coordinate in degrees, minutes, seconds in a N/S/E/W hemisphere.
  11. type coordinate struct {
  12.     d, m, s float64
  13.     h       rune
  14. }
  16. // newLocation from latitude, longitude d/m/s coordinates.
  17. func newLocation(lat, long coordinate) location {
  18.     return location{lat.decimal(), long.decimal()}
  19. }
  21. // decimal converts a d/m/s coordinate to decimal degrees.
  22. func (c coordinate) decimal() float64 {
  23.     sign := 1.0
  24.     switch c.h {
  25.     case 'S', 'W', 's', 'w':
  26.         sign = -1
  27.     }
  28.     return sign * (c.d + c.m/60 + c.s/3600)
  29. }
  31. func main() {
  32.     spirit := newLocation(coordinate{14, 34, 6.2, 'S'}, coordinate{175, 28, 21.5, 'E'})
  33.     opportunity := newLocation(coordinate{1, 56, 46.3, 'S'}, coordinate{354, 28, 24.2, 'E'})
  34.     curiosity := newLocation(coordinate{4, 35, 22.2, 'S'}, coordinate{137, 26, 30.12, 'E'})
  35.     insight := newLocation(coordinate{4, 30, 0.0, 'N'}, coordinate{135, 54, 0, 'E'})
  37.     fmt.Println("Spirit", spirit)
  38.     fmt.Println("Opportunity", opportunity)
  39.     fmt.Println("Curiosity", curiosity)
  40.     fmt.Println("InSight", insight)
  41. }
  • 使用例子 22.4 中的 distance 方法，编写一个程序，来判定上题表中每对着陆点之间的距离。并回答：
    • 哪两个着陆点之间最近？
    • 哪两个着陆点之间最远？
    • 计算伦敦到巴黎之间的距离（51°30’N 0°08’W） ，（48°51’N 2°21’E）,地球半径为 6371 公里。
    • 计算你的城市到北京距离
    • 计算火星上 Mount Sharp (5°4’ 48”S, 137°51’E) 到 Olympus Mons (18°39’N, 226°12’E) 之间的距离。火星的半径是 3389.5 公里。
  1. package main
  3. import (
  4.     "fmt"
  5.     "math"
  6. )
  8. // location with a latitude, longitude.
  9. type location struct {
  10.     lat, long float64
  11. }
  13. // coordinate in degrees, minutes, seconds in a N/S/E/W hemisphere.
  14. type coordinate struct {
  15.     d, m, s float64
  16.     h       rune
  17. }
  19. // newLocation from latitude, longitude d/m/s coordinates.
  20. func newLocation(lat, long coordinate) location {
  21.     return location{lat.decimal(), long.decimal()}
  22. }
  24. // decimal converts a d/m/s coordinate to decimal degrees.
  25. func (c coordinate) decimal() float64 {
  26.     sign := 1.0
  27.     switch c.h {
  28.     case 'S', 'W', 's', 'w':
  29.         sign = -1
  30.     }
  31.     return sign * (c.d + c.m/60 + c.s/3600)
  32. }
  34. // world with a volumetric mean radius in kilometers
  35. type world struct {
  36.     radius float64
  37. }
  39. // distance calculation using the Spherical Law of Cosines.
  40. func (w world) distance(p1, p2 location) float64 {
  41.     s1, c1 := math.Sincos(rad(p1.lat))
  42.     s2, c2 := math.Sincos(rad(p2.lat))
  43.     clong := math.Cos(rad(p1.long - p2.long))
  44.     return w.radius * math.Acos(s1*s2+c1*c2*clong)
  45. }
  47. // rad converts degrees to radians.
  48. func rad(deg float64) float64 {
  49.     return deg * math.Pi / 180
  50. }
  52. var (
  53.     mars  = world{radius: 3389.5}
  54.     earth = world{radius: 6371}
  55. )
  57. func main() {
  58.     spirit := newLocation(coordinate{14, 34, 6.2, 'S'}, coordinate{175, 28, 21.5, 'E'})
  59.     opportunity := newLocation(coordinate{1, 56, 46.3, 'S'}, coordinate{354, 28, 24.2, 'E'})
  60.     curiosity := newLocation(coordinate{4, 35, 22.2, 'S'}, coordinate{137, 26, 30.12, 'E'})
  61.     insight := newLocation(coordinate{4, 30, 0.0, 'N'}, coordinate{135, 54, 0, 'E'})
  63.     fmt.Printf("Spirit to Opportunity %.2f km\n", mars.distance(spirit, opportunity))
  64.     fmt.Printf("Spirit to Curiosity %.2f km\n", mars.distance(spirit, curiosity))
  65.     fmt.Printf("Spirit to InSight %.2f km\n", mars.distance(spirit, insight))
  67.     fmt.Printf("Opportunity to Curiosity %.2f km\n", mars.distance(opportunity, curiosity))
  68.     fmt.Printf("Opportunity to InSight %.2f km\n", mars.distance(opportunity, insight))
  70.     fmt.Printf("Curiosity to InSight %.2f km\n", mars.distance(curiosity, insight))
  72.     london := newLocation(coordinate{51, 30, 0, 'N'}, coordinate{0, 8, 0, 'W'})
  73.     paris := newLocation(coordinate{48, 51, 0, 'N'}, coordinate{2, 21, 0, 'E'})
  74.     fmt.Printf("London to Paris %.2f km\n", earth.distance(london, paris))
  76.     edmonton := newLocation(coordinate{53, 32, 0, 'N'}, coordinate{113, 30, 0, 'W'})
  77.     ottawa := newLocation(coordinate{45, 25, 0, 'N'}, coordinate{75, 41, 0, 'W'})
  78.     fmt.Printf("Hometown to Capital %.2f km\n", earth.distance(edmonton, ottawa))
  80.     mountSharp := newLocation(coordinate{5, 4, 48, 'S'}, coordinate{137, 51, 0, 'E'})
  81.     olympusMons := newLocation(coordinate{18, 39, 0, 'N'}, coordinate{226, 12, 0, 'E'})
  82.     fmt.Printf("Mount Sharp to Olympus Mons %.2f km\n", mars.distance(mountSharp, olympusMons))
  83. }