Java转Go的同学看过来&核心语法&并发实战（极简版）："我一般爱看看boss的招聘要求，要求啥我学啥"

package main // 程序入口包（固定）
import "fmt"  // 类比java.lang.System
func main() { // 入口函数（无参数、无返回值）
    fmt.Println("Hello Go") // 类比System.out.println
}

func main() {
    i := 10          // 简洁声明（推荐）
    j := 20
    str := "hello go"   // 自动推导string类型
    const d = 60     // 常量
    fmt.Println(i+j, str)
}

type User struct {
    ID   int    // 包外公有（类似public）
    Name string // 包外公有
    age  int    // 包内私有（类似private）
}
// 指针接收者：修改原对象+避免拷贝（类比Java this）
func (u *User) SetAge(newAge int) {
    u.age = newAge
}
// 指针接收者：统一行为，避免冗余
func (u *User) GetName() string {
    return u.Name
}
// 类比Java重写toString()，自定义打印格式
func (u *User) String() string {
    return fmt.Sprintf("User{ID:%d, Name:%q, Age:%d}", u.ID, u.Name, u.age)
}
// 类比Java构造方法
func NewUser(id int, name string, age int) *User {
    return &User{ID: id, Name: name, age: age}
}

func main() {
    // 切片（ArrayList）：动态扩容，append返回新切片
    s := []int{1,2,3}
    s = append(s, 4,5) // 类比list.add()
    for idx, val := range s { // 遍历：索引+值
        fmt.Println("idx:", idx, "val:", val)
    }
    // 字典（HashMap）：无序，安全取值（ok判断是否存在）
    m := make(map[string]int)
    m["a"] = 1
    v, ok := m["a"] // 类比map.get()，避免空指针
    fmt.Println(v, ok) // 1 true
    delete(m, "a") // 类比map.remove()
}

// 定义接口（仅声明方法）
type SayHello interface {
    Hello() string
}
// User无需声明implements，有Hello方法即实现接口
func (u *User) Hello() string {
    return "Hello " + u.Name
}
// 接收接口参数（多态，类比Java接口入参）
func Greet(s SayHello) {
    fmt.Println(s.Hello())
}
// 调用
func main() {
    u := NewUser(1, "张三", 30)
    Greet(u) // 输出：Hello 张三
}

// 启动协程：仅需go关键字（类比new Thread().start()）
go printNum(10)

func main() {
    var wg sync.WaitGroup // 局部变量（类比CountDownLatch）
    wg.Add(2) // 计数2

    // 传指针：避免值拷贝，协程内操作原对象
    go printNum(10, &wg)
    go printNum(20, &wg)

    wg.Wait() // 等待计数为0（类比latch.await()）
}
func printNum(n int, wg *sync.WaitGroup) {
    defer wg.Done() // 类比countDown()，确保执行
    for i := 0; i < n; i++ {
        fmt.Print(n, "-", i, " ")
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    // 带缓冲通道（类比ArrayBlockingQueue）
    ch := make(chan string, 3)
    ch <- "a"
    ch <- "b"
    ch <- "c"
    close(ch) // 发送端关闭！否则for range死锁

    // 遍历通道：接收所有数据直到关闭
    for msg := range ch {
        fmt.Println("接收：", msg)
    }
}

type Counter struct {
    mu    sync.Mutex // 互斥锁（类比ReentrantLock）
    count int        // 私有字段，避免包外直接修改
}
// 并发安全自增
func (c *Counter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock() // 确保解锁，避免死锁
    c.count++
}
// 暴露读取方法（类比getter）
func (c *Counter) GetCount() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}
// 调用
func main() {
    counter := &Counter{}
    var wg sync.WaitGroup
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Inc()
        }()
    }
    wg.Wait()
    fmt.Println("最终计数：", counter.GetCount()) // 3
}

public static void main(String[] args) {
    try {
        int a = 1 / 0; // 触发ArithmeticException
    } catch (ArithmeticException e) {
        e.printStackTrace(); // 捕获异常
    } finally {
        System.out.println("无论是否异常都执行");
    }
}

func divide(a, b int) {
    defer func() {
        // 捕获panic（必须在defer中）
        if err := recover(); err != nil {
            fmt.Println("捕获异常：", err)
        }
    }()

    if b == 0 {
        panic("除数不能为0") // 触发异常
    }
    fmt.Println("结果：", a/b)
}
func main() {
    divide(1, 0)
    fmt.Println("程序继续运行") // 异常被捕获，不会崩溃
}

常见疑惑：panic和 Java 的异常有什么区别？

mkdir gin-demo && cd gin-demo
go mod init github.com/yourname/gin-demo  // yourname可以改为项目名，譬如gin-demo

go get github.com/gin-gonic/gin@v1.9.1

package main
import "github.com/gin-gonic/gin"
func main() {
    r := gin.Default() // 初始化Gin引擎

    // 定义接口（类似Spring的@RequestMapping）
    r.GET("/hello", func(c *gin.Context) {
        name := c.Query("name") // 获取请求参数
        c.JSON(200, gin.H{      // 返回JSON
            "message": "Hello " + name,
        })
    })

    r.Run(":8080") // 启动服务（类似Spring的run方法）
}

go run main.go
curl http://localhost:8080/hello?name=Go // 输出{"message":"Hello Go"}

package main
import (
"fmt"
"sync"
"time"
)
// 1. 结构体（对应Java的类）
type User struct {
	ID   int
	Name string
	age  int // 小写包内私有，类比Java的private
}
// SetAge 设置年龄（指针接收者修改原对象，类比Java的this）
func (u *User) SetAge(newAge int) {
	u.age = newAge
}
// GetName 获取姓名（统一指针接收者，保持行为一致）
func (u *User) GetName() string {
return u.Name
}
// String 实现fmt.Stringer接口，类比Java重写toString()
func (u *User) String() string {
return fmt.Sprintf("User{ID:%d, Name:%q, Age:%d}", u.ID, u.Name, u.age)
}
// NewUser 构造函数，类比Java的构造方法
func NewUser(id int, name string, age int) *User {
return &User{
		ID:   id,
		Name: name,
		age:  age,
	}
}
// 2. 接口（鸭子类型，无需显式implements）
type SayHello interface {
	Hello() string
}
// Hello 隐式实现SayHello接口
func (u *User) Hello() string {
return "Hello " + u.Name
}
// Greet 接收接口参数，实现多态，类比Java接口入参
func Greet(s SayHello) {
	fmt.Println(s.Hello())
}
// 3. 并发安全计数器（类比Java线程安全类）
type Counter struct {
	mu    sync.Mutex // 互斥锁，类比ReentrantLock
	count int        // 私有字段，避免包外直接修改
}
// Inc 并发安全自增
func (c *Counter) Inc() {
	c.mu.Lock()
defer c.mu.Unlock() // 延迟解锁，类比Java的finally
	c.count++
}
// GetCount 安全获取计数（暴露getter方法）
func (c *Counter) GetCount() int {
	c.mu.Lock()
defer c.mu.Unlock()
return c.count
}
// 4. 协程函数（类比Java线程任务）
func printNum(n int, wg *sync.WaitGroup) {
defer wg.Done() // 确保协程结束标记，类比CountDownLatch.countDown()
for i := 0; i < n; i++ {
		fmt.Print(n, "-", i, " ")
		time.Sleep(100 * time.Millisecond)
	}
}
func main() {
// 变量声明：优先用:=，自动推导类型
	i := 10
	fmt.Println("变量：", i)
// 结构体使用
	u := NewUser(1, "张三", 30)
	u.SetAge(35)
	fmt.Println("User：", u)
	Greet(u)
// 切片（类比Java ArrayList）和字典（类比Java HashMap）
	s := []int{1, 2, 3}
	s = append(s, 4) // 动态扩容
	m := map[string]int{"a": 1}
delete(m, "a") // 删除元素（不存在不报错）
	fmt.Println("切片：", s, "字典：", m)
// 协程+WaitGroup（类比Java线程+CountDownLatch）
var wg sync.WaitGroup
	wg.Add(2)
go printNum(10, &wg)
go printNum(20, &wg)
	wg.Wait() // 等待所有协程完成
// Channel（类比Java BlockingQueue）
	ch := make(chan string, 3)
	ch <- "a"
	ch <- "b"
close(ch) // 发送端关闭，避免接收端死锁
for msg := range ch {
		fmt.Println("Channel：", msg)
	}
// 并发计数器使用
	counter := &Counter{}
	wg.Add(3)
for i := 0; i < 3; i++ {
go func() {
defer wg.Done()
			counter.Inc()
		}()
	}
	wg.Wait()
	fmt.Println("最终计数：", counter.GetCount())
}