Go语言快速入门指南（Java开发者版）

1. Go语言基础

1.1 变量与常量

变量声明：

// 方式1：使用var关键字
var num int
var result string = "this is result"

// 方式2：使用:=赋值（类型推断）
num := 3  // 等同于 var num int = 3

常量声明：

const laugh string = "go"

零值规则：

• 数值类型：0
• 布尔类型：false
• 字符串：""（空字符串）

1.2 函数定义

基本函数：

func add(a int, b int) int {
    return a+b
}

多返回值：

func add(a, b int) (int, error) {
    if a < 0 || b < 0 {
        return 0, errors.New("只支持非负整数相加")
    }
    return a + b, nil
}

命名返回值：

func add1(a, b int) (z int, err error) {
    if a < 0 || b < 0 {
        err = errors.New("只支持非负整数相加")
        return // 返回0, err
    }
    z = a + b
    return // 返回z, nil
}

变长参数：

func myfunc(numbers ...int) {
    for _, number := range numbers {
        fmt.Println(number)
    }
}

1.3 包与可见性

• 首字母大写的标识符可在包外访问
• 首字母小写的标识符只能在包内访问

package main

import "fmt"

func main() {
    fmt.Println("Hello World!")
}

1.4 指针

func main() {
    i := 0
    fmt.Println(&i) // 打印内存地址
}

func add(a *int, b *int) int {
    x := *a // 解引用
    y := *b
    return x+y
}

2. 控制结构

2.1 条件语句

if condition {
    // do something
} else if condition2 {
    // do something else
} else {
    // default
}

2.2 循环语句

// 普通for循环
for i := 1; i <= 100; i++ {
    sum += i
}

// 无限循环
for {
    sum++
    if sum == 100 {
        break
    }
}

// 带条件的循环
for res := sum+1; sum < 15 {
    sum++
    res++
}

// range循环
for k, v := range a {
    fmt.Println(k, v)
}

2.3 分支语句

switch score {
case 90, 100:
    fmt.Println("Grade: A")
case 80:
    fmt.Println("Grade: B")
default:
    fmt.Println("Grade: F")
}

3. 数据结构

3.1 数组

var nums [3]int
var nums = [3]int{1,2,3} 
nums := [3]int{1,2,3}

3.2 切片（动态数组）

创建切片：

// 从数组创建
var nums = [3]int{1, 2, 3}
slice1 := nums[0:2] // {1,2}

// 直接声明
slice := []int{0, 1, 2}

// 使用make
slice3 := make([]int, 5)      // 长度5，容量5
slice4 := make([]int, 4, 5)   // 长度4，容量5

操作切片：

// 添加元素
slice5 := make([]int, 4, 5)
slice5 = append(slice5, 1)

// 删除元素
slice5 = slice5[1:]

3.3 字典（Map）

// 声明并初始化
maps := map[string]int{
    "java": 1,
    "go": 2,
}

// 使用make创建
maps = make(map[string]int, 100)

// 操作
value, ok := maps["one"] // 取值并检查存在性
delete(maps, "go")       // 删除键值对

4. 面向对象编程

4.1 结构体（类）

type Student struct {
    id    int
    name  string
    score float64
}

// 构造方法
func NewStudent(id int, name string, score float64) *Student {
    return &Student{id, name, score}
}

// 成员方法
func (s *Student) SetName(name string) {
    s.name = name
}

func (s Student) GetName() string {
    return s.name
}

4.2 接口

非侵入式接口：

type IFile interface {
    Read(buf []byte) (n int, err error)
    Write(buf []byte) (n int, err error)
}

type File struct {}

func (f *File) Read(buf []byte) (n int, err error) {
    // 实现
}

func (f *File) Write(buf []byte) (n int, err error) {
    // 实现
}

5. 并发编程

5.1 Goroutine

func say(s string) {
    fmt.Println(s)
}

func main() {
    go say("world") // 新协程
    say("hello")    // 主协程
}

5.2 Channel

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // 发送结果到channel
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}
    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    x, y := <-c, <-c // 从channel接收
    fmt.Println(x, y, x+y)
}

5.3 互斥锁

type SafeCounter struct {
    v   map[string]int
    mux sync.Mutex
}

func (c *SafeCounter) Inc(key string) {
    c.mux.Lock()
    c.v[key]++
    c.mux.Unlock()
}

6. 错误处理

6.1 error接口

type error interface {
    Error() string
}

func Foo(param int) (n int, err error) {
    // ...
    if err != nil {
        return 0, err
    }
    return result, nil
}

6.2 defer语句

func ReadFile(filename string) ([]byte, error) {
    f, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer f.Close() // 确保函数返回前关闭文件
    // ...其他操作
}

6.3 panic和recover

func divide() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Printf("Runtime panic caught: %v\n", err)
        }
    }()
    
    var i = 1
    var j = 0
    k := i / j // 会触发panic
    fmt.Printf("%d / %d = %d\n", i, j, k)
}

7. 总结

本指南涵盖了Go语言的核心特性，特别适合有Java背景的开发者快速上手。Go语言的主要特点包括：

1. 简洁的语法和类型系统
2. 强大的并发模型（Goroutine和Channel）
3. 非侵入式的接口设计
4. 内置的错误处理机制
5. 高效的内存管理（垃圾回收）

要深入掌握Go语言，建议在实际项目中实践这些概念，并进一步学习标准库和Go语言的底层实现原理。