随着 Go 语言的流行，很多公司的技术栈在往 Go 上转，但很多招进来的后端开发工程师都是 Java 技术栈，然后在工作中边学边上手。
那么 Java 程序员要想极速上手 Go，应该从哪些方面入手呢？
对于已经有一定基础的 Java 工程师，可以思考自己以前用 Java 编程时，最常使用的语言特性，列一个清单出来。然后按照这个清单，去学习 Go 语言的对应实现方式，这样能够有针对性的的学习，有的放矢。
下面是我使用 Java 进行日常工作中经常使用的5个编程要点，我会介绍这些要点对应的 Go 实现，仅供大家参考。
1. 并发编程（Concurrency）
Go语言通过goroutine和channel提供了轻量级的并发编程模型，与Java的线程模型相比更加简洁和高效。下面是一个简单的并发示例：
package main
import (
"fmt"
"time"
)
func main() {
// 创建一个 go routine
go sayHello("World")
// 主 goroutine 打印 Hello
sayHello("Gopher")
}
func sayHello(name string) {
for i := 0; i < 5; i++ {
fmt.Println("Hello", name)
time.Sleep(time.Second)
}
}执行上述 go 代码，打印输出：
笔者另外一篇文章，曾经详细介绍过 Go 的并发编程，大家可以移步我这篇腾讯云社区文章：
通过三个例子，学习 Go 语言并发编程的利器 - goroutine
2. 内置并发安全的Map（Built-in concurrency-safe Map）
在Go语言中，内置了并发安全的map类型（sync.Map），可以在多个goroutine中安全地读写数据，而无需额外的锁。以下是一个使用sync.Map的示例：
package main
import (
"fmt"
"sync"
)
func main() {
var m sync.Map
// 写入键值对
m.Store("key", "value")
// 读取键对应的值
value, ok := m.Load("key")
if ok {
fmt.Println(value)
}
}执行上述代码，最后打印 value：
这段代码是一个简单的Go语言程序，它演示了如何使用sync.Map进行并发安全的键值对操作。下面是逐行解释这段代码的含义：
package main：声明这个文件属于main包，表明这是一个可执行程序的入口文件。import (：引入需要使用的外部包，这里使用了"fmt"和"sync"包。"fmt"：引入了用于格式化输出的标准库包。"sync"：引入了用于同步操作的标准库包。func main() {：定义了程序的主函数。var m sync.Map：声明了一个变量m，类型为sync.Map。sync.Map是Go语言提供的一种并发安全的map类型，可以在多个goroutine中安全地读写数据，而无需额外的锁。m.Store("key", "value")：向map m中存储键值对，键为"key"，值为"value"。value, ok := m.Load("key")：从map m中读取键为"key"的值，如果键存在，则将值赋给变量value，并将ok设置为true；如果键不存在，则value为nil，ok为false。这里使用了多重赋值的方式。if ok {：判断变量ok是否为true，如果为true，说明键存在。fmt.Println(value)：打印键"key"对应的值value。}：if语句的结束。
整个程序的逻辑很简单，就是先向sync.Map中存储了一个键值对，然后再从中读取出来并打印出对应的值。由于sync.Map是并发安全的，所以可以在多个goroutine中安全地进行这些操作。
3. 错误处理（Error Handling）
Go语言采用显式的错误处理机制，通过返回error类型来传递错误信息，而不是Java中的异常。下面是一个简单的错误处理示例：
package main
import (
"errors"
"fmt"
)
func divide(x, y int) (int, error) {
if y == 0 {
return 0, errors.New("division by zero")
}
return x / y, nil
}
func main() {
result, err := divide(10, 0)
if err != nil {
fmt.Println("Error:", err)
return
}
fmt.Println("Result:", result)
}执行之后的输出：
以下是对代码逐行解释的含义：
import (
"errors"
"fmt"
)这里使用了import关键字引入了两个标准库包。errors包用于创建和处理错误信息，fmt包用于格式化输出。
func divide(x, y int) (int, error) {这行代码定义了一个名为divide的函数。这个函数接受两个int类型的参数x和y，并返回两个值，第一个值是int类型的商，第二个值是error类型的错误信息（如果有错误的话）。
if y == 0 {
return 0, errors.New("division by zero")
}在函数内部，首先检查y是否为零。如果y为零，就会调用errors.New函数创建一个新的错误，其中包含字符串"division by zero"，然后返回0和该错误。
return x / y, nil如果y不为零，则返回x / y作为商，并且返回nil表示没有错误发生。
func main() {这行代码定义了程序的主函数。
result, err := divide(10, 0)在主函数中，调用了divide函数，传入了参数10和0。result接收到divide函数返回的商，err接收到可能返回的错误。
if err != nil {检查err是否不为nil，如果不为nil，说明函数调用过程中发生了错误。
fmt.Println("Error:", err)如果有错误发生，使用fmt.Println打印错误信息。
return然后通过return语句结束函数执行。
fmt.Println("Result:", result)如果没有发生错误，则打印商的结果。
整体而言，这段代码展示了一个简单的除法函数，并演示了如何处理可能的错误情况。
4. defer和panic/recover（defer and panic/recover）
Go语言提供了defer关键字用于延迟执行函数调用，以及panic和recover机制用于处理异常。以下是一个使用defer和panic/recover的示例：
package main
import "fmt"
func recoverName() {
if r := recover(); r != nil {
fmt.Println("recovered from", r)
}
}
func fullName(firstName *string, lastName *string) {
defer recoverName()
if firstName == nil {
panic("runtime error: first name cannot be nil")
}
if lastName == nil {
panic("runtime error: last name cannot be nil")
}
fmt.Printf("%s %s\n", *firstName, *lastName)
fmt.Println("returned normally from fullName")
}
func main() {
defer fmt.Println("deferred call in main")
firstName := "John"
fullName(&firstName, nil)
fmt.Println("returned normally from main")
}执行之后，打印的输出结果：
这段代码演示了在Go语言中如何使用defer、panic和recover来处理运行时错误。具体来说，它包含了以下几个关键点：
recoverName()函数定义了一个延迟函数，它通过调用recover()函数来恢复从panic状态中返回的错误信息。如果recover()函数返回的值不为nil，则说明有panic发生，并且在该函数中进行了错误恢复处理。fullName()函数展示了如何在运行时可能出现错误的情况下使用panic来中断程序执行，并在发生错误时抛出错误信息。在这个函数中，首先使用defer关键字来延迟执行recoverName()函数，以确保无论是否发生panic，都能在函数退出时执行恢复处理。然后，通过检查传入的指针是否为nil来判断是否存在运行时错误，如果存在错误，就会触发panic，并且程序会跳转到最近的defer语句执行。main()函数是程序的入口点。在这个函数中，通过使用defer语句来延迟执行fmt.Println("deferred call in main")，确保该语句会在函数退出时被执行。然后定义了一个firstName变量，并调用了fullName()函数，将firstName的地址和一个nil指针作为参数传递给该函数。由于lastName参数为nil，因此会触发panic，并且程序会跳转到fullName()函数中执行错误处理。最后，fmt.Println("returned normally from main")语句会在main()函数正常返回时执行，但由于在调用fullName()函数时已经发生了panic，因此该语句不会被打印出来。
5. 结构体（Structs）和接口（Interfaces）
Go语言中的结构体和接口是非常灵活和强大的，可以有效地组织代码和实现多态性。下面是一个使用结构体和接口的示例：
package main
import (
"fmt"
)
type Shape interface {
Area() float64
}
type Rectangle struct {
Width float64
Height float64
}
func (r Rectangle) Area() float64 {
return r.Width * r.Height
}
type Circle struct {
Radius float64
}
func (c Circle) Area() float64 {
return 3.14 * c.Radius * c.Radius
}
func printArea(s Shape) {
fmt.Println("Area:", s.Area())
}
func main() {
rect := Rectangle{Width: 5, Height: 3}
circle := Circle{Radius: 4}
printArea(rect)
printArea(circle)
}执行之后的代码输出：
这段代码演示了如何在Go语言中使用接口和结构体来实现多态性。具体来说，它包含了以下几个关键点：
Shape接口：定义了一个Shape接口，该接口包含一个Area()方法，用于计算形状的面积。任何实现了Area()方法的类型都可以被视为Shape接口的实现者。Rectangle结构体：定义了一个Rectangle结构体，包含了Width和Height两个字段，分别表示矩形的宽度和高度。此外，还实现了Area()方法，用于计算矩形的面积。Circle结构体：定义了一个Circle结构体，包含了Radius字段，表示圆的半径。同样，它也实现了Area()方法，用于计算圆的面积。printArea()函数：定义了一个printArea()函数，接受一个Shape类型的参数，并调用其Area()方法来打印形状的面积。main()函数：程序的入口点。在这个函数中，创建了一个Rectangle类型的变量rect和一个Circle类型的变量circle，并分别传递给printArea()函数进行面积打印。由于Rectangle和Circle类型都实现了Shape接口的Area()方法，因此它们都可以作为printArea()函数的参数，展示了多态性的特性。
以上只是五个笔者工作中最经常使用到的 Go 特性分享，祝各位 Java 程序员的 Go 转型之路一切顺利。