Java to Go 学习指南

这篇指南为了能够帮助Java程序员快速深入了解Go语言特性！

主要区别

面向对象：

• Go 语言的面向对象编程(OOP)非常简洁而优雅。说它简洁，简洁之处在于，它没有了OOP中很多概念，比如：继承、虚函数、构造函数和析构函数、隐藏的this指针等等。说它优雅，是它的面向对象(OOP)是语言类型系统(type system)中的天然的一部分。整个类型系统通过接口(interface)串联，浑然一体。

employee.go

1. package employee
3. import (
4. "fmt"
5. )
7. type employee struct {
8. firstName string
9. lastName string
10. totalLeaves int
11. leavesTaken int
12. }
14. func New(firstName string, lastName string, totalLeave int, leavesTaken int) employee {
15. e := employee {firstName, lastName, totalLeave, leavesTaken}
16. return e
17. }
19. func (e *employee) LeavesRemaining() {
20. fmt.Printf("%s %s has %d leaves remaining", e.firstName, e.lastName, (e.totalLeaves - e.leavesTaken))
21. }

main.go

1. package main
3. import "oop/employee"
5. func main() {
6. e := employee.New("Sam", "Adolf", 30, 20)
7. e.LeavesRemaining()
8. }

Go interface

1. package main
3. import "fmt"
4. import "math"
6. // Here's a basic interface for geometric shapes.
7. type geometry interface {
8. area() float64
9. perim() float64
10. }
12. // For our example we'll implement this interface on
13. // `rect` and `circle` types.
14. type rect struct {
15. width, height float64
16. }
17. type circle struct {
18. radius float64
19. }
21. // To implement an interface in Go, we just need to
22. // implement all the methods in the interface. Here we
23. // implement `geometry` on `rect`s.
24. func (r rect) area() float64 {
25. return r.width * r.height
26. }
27. func (r rect) perim() float64 {
28. return 2*r.width + 2*r.height
29. }
31. // The implementation for `circle`s.
32. func (c circle) area() float64 {
33. return math.Pi * c.radius * c.radius
34. }
35. func (c circle) perim() float64 {
36. return 2 * math.Pi * c.radius
37. }
39. // If a variable has an interface type, then we can call
40. // methods that are in the named interface. Here's a
41. // generic `measure` function taking advantage of this
42. // to work on any `geometry`.
43. func measure(g geometry) {
44. fmt.Println(g)
45. fmt.Println(g.area())
46. fmt.Println(g.perim())
47. }
49. func main() {
50. r := rect{width: 3, height: 4}
51. c := circle{radius: 5}
53. // The `circle` and `rect` struct types both
54. // implement the `geometry` interface so we can use
55. // instances of
56. // these structs as arguments to `measure`.
57. measure(r)
58. measure(c)
59. }

方法：

1. type MyType struct {
2. n int
3. }
5. func (p *MyType) Value() int { return p.n }
7. func main() {
8. pm := new(MyType)
9. fmt.Println(pm.Value()) // 0 (zero value)
10. }

函数类型：

1. type Operator func(x float64) float64
3. // Map applies op to each element of a.
4. func Map(op Operator, a []float64) []float64 {
5. res := make([]float64, len(a))
6. for i, x := range a {
7. res[i] = op(x)
8. }
9. return res
10. }
12. func main() {
13. op := math.Abs
14. a := []float64{1, -2}
15. b := Map(op, a)
16. fmt.Println(b) // [1 2]
18. c := Map(func(x float64) float64 { return 10 * x }, b)
19. fmt.Println(c) // [10, 20]
20. }

匿名函数与闭包：

1. func Slice(slice interface{}, less func(i, j int) bool)
3. people := []string{"Alice", "Bob", "Dave"}
4. sort.Slice(people, func(i, j int) bool {
5. return len(people[i]) < len(people[j])
6. })
7. fmt.Println(people)
8. // Output: [Bob Dave Alice]
10. // OR
11. people := []string{"Alice", "Bob", "Dave"}
12. less := func(i, j int) bool {
13. return len(people[i]) < len(people[j])
14. }
15. sort.Slice(people, less)
17. // Count prints the number of times it has been invoked.
18. func New() (Count func()) {
19. n := 0
20. return func() {
21. n++
22. fmt.Println(n)
23. }
24. }
26. func main() {
27. f1, f2 := New(), New()
28. f1() // 1
29. f2() // 1 (different n)
30. f1() // 2
31. f2() // 2
32. }

指针：

1. type Student struct {
2. Name string
3. }
5. var ps *Student = new(Student) // ps holds the address of the new struct
7. ps := new(Student)
9. s := Student{"Alice"} // s holds the actual struct
10. ps := &s // ps holds the address of the struct
12. // Bob is a function that has no effect.
13. func Bob(s Student) {
14. s.Name = "Bob" // changes only the local copy
15. }
17. // Charlie sets pp.Name to "Charlie".
18. func Charlie(ps *Student) {
19. ps.Name = "Charlie"
20. }
22. func main() {
23. s := Student{"Alice"}
25. Bob(s)
26. fmt.Println(s) // prints {Alice}
28. Charlie(&s)
29. fmt.Println(s) // prints {Charlie}
30. }

错误处理：

1. type error interface {
2. Error() string
3. }
5. f, err := os.Open("filename.ext")
6. if err != nil {
7. log.Fatal(err)
8. }
10. // coustome error
11. err := errors.New("Houston, we have a problem")

 
并发

未完待续。。。。