func getUser(id int) (*User, error) {
    if user, ok := cache.Load(id); ok {
        return user.(*User), nil
    }
    defer func() { metrics.Record("getUser") }()
    // ...
}

// Java —— 三种写法，都在用
String name = "foo";           // 传统
var name = "foo";              // Java 10+ 类型推断
final String NAME = "foo";     // 常量

// Go —— 只有两种
var name string = "foo"        // 完整写法（较少用）
name := "foo"                  // 短变量声明，类型自动推断

// 常量
const NAME = "foo"             // Go 的 const，不是全大写也行

// 多变量声明
var x, y int = 1, 2
a, b := 3, 4

package main

var globalVar = "包级别用 var"   // ✅

func main() {
    localVar := "函数内用 :="    // ✅
}

// Java —— 五种循环
for (int i = 0; i < 10; i++) { }          // 三段式
for (var item : list) { }                  // for-each
while (condition) { }                      // while
do { } while (condition);                  // do-while
list.stream().forEach(item -> { });        // stream

// Go —— 只有 for，全包了
for i := 0; i < 10; i++ { }               // 三段式（注意没有括号！）
for _, item := range list { }              // range 遍历 = Java for-each
for condition { }                          // while（连关键字都省了）
for { }                                    // 死循环
for i := range 10 { }                      // Go 1.22：遍历 0 ~ 9

// Go 1.22 新特性：range over int
for i := range 5 {
    fmt.Println(i) // 0 1 2 3 4
}
// 等价于 Java 的：
// for (int i = 0; i < 5; i++) { System.out.println(i); }

// Java
int result = compute();
if (result > 0) {
    System.out.println(result);
}

// Go —— if 可以带一个初始化语句
if result := compute(); result > 0 {
    fmt.Println(result)
}
// result 的作用域仅限于 if-else 块

// Java —— 每个 case 必须写 break，不然会穿透
switch (day) {
    case "MONDAY":
    case "TUESDAY":
        System.out.println("工作日");
        break;
    default:
        System.out.println("其他");
}

// Go —— 自动 break，不需要手写
switch day {
case "MONDAY", "TUESDAY":    // 多值匹配
    fmt.Println("工作日")
default:
    fmt.Println("其他")
}

// Go —— 无表达式 switch，等于一串 if-else
switch {
case score >= 90:
    grade = "A"
case score >= 80:
    grade = "B"
default:
    grade = "C"
}

// Go —— 多返回值
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("除数不能为 0")
    }
    return a / b, nil
}

result, err := divide(10, 2)
if err != nil {
    // 处理错误
}

// Java —— 类似效果需要包装类或异常
public class DivisionResult {
    private final int result;
    private final String error;
    // constructor, getters...
}

// 或者直接抛异常
public static int divide(int a, int b) throws ArithmeticException {
    if (b == 0) throw new ArithmeticException("除数不能为 0");
    return a / b;
}

// Go —— 函数赋值给变量
add := func(a, b int) int {
    return a + b
}
result := add(3, 5) // 8

// Go —— 函数作为参数
func apply(nums []int, op func(int) int) []int {
    result := make([]int, len(nums))
    for i, v := range nums {
        result[i] = op(v)
    }
    return result
}

doubled := apply([]int{1, 2, 3}, func(n int) int { return n * 2 })
// doubled = [2, 4, 6]

// Java —— Lambda 表达式（Java 8+）
Function<Integer, Integer> add = (a, b) -> a + b; // 编译错误！Function 只接受一个参数
BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
var result = add.apply(3, 5); // 8

// Java —— try-with-resources
try (var reader = new BufferedReader(new FileReader("file.txt"))) {
    // 读取文件
} // 自动调用 close()

// Java —— 手动 finally
var conn = dataSource.getConnection();
try {
    // 操作数据库
} finally {
    conn.close();
}

// Go —— defer，资源申请和释放写在一起
func readFile(path string) error {
    f, err := os.Open(path)
    if err != nil {
        return err
    }
    defer f.Close() // 函数返回前一定执行

    // 读取文件...
    return nil
}

func processDB() error {
    conn, err := db.Connect()
    if err != nil {
        return err
    }
    defer conn.Close()

    tx, err := conn.Begin()
    if err != nil {
        return err
    }
    defer tx.Rollback() // 如果 commit 了，Rollback 是 no-op

    // 执行 SQL...
    return tx.Commit()
}

// Java —— 面向 try-catch 编程
public User getUser(Long id) {
    try {
        return userRepository.findById(id)
                .orElseThrow(() -> new NotFoundException("用户不存在"));
    } catch (NotFoundException e) {
        log.error("用户未找到: {}", id, e);
        throw e;
    } catch (DataAccessException e) {
        log.error("数据库异常", e);
        throw new ServiceException("查询用户失败", e);
    }
}

// Go —— error 就是返回值
func (s *UserService) GetUser(id int64) (*User, error) {
    user, err := s.repo.FindByID(id)
    if err != nil {
        return nil, fmt.Errorf("查询用户失败: %w", err)
    }
    if user == nil {
        return nil, ErrNotFound
    }
    return user, nil
}

type error interface {
    Error() string
}

// panic 用于真正的不可恢复错误
func mustCompileRegex(pattern string) *regexp.Regexp {
    re, err := regexp.Compile(pattern)
    if err != nil {
        panic(err) // 正则写错了，程序没法继续，直接挂
    }
    return re
}

// recover 只在 defer 里有效
func safeCall() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("恢复自 panic:", r)
        }
    }()
    panic("出大事了") // 不会让程序崩溃
}

// Java —— class
public class User {
    private Long id;
    private String name;
    private int age;

    public User(Long id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public boolean isAdult() {
        return age >= 18;
    }
}

var user = new User(1L, "张三", 25);
System.out.println(user.isAdult());

// Go —— struct
type User struct {
    ID   int64
    Name string
    age  int // 小写开头 = 包内私有
}

// 构造函数惯例：New + 类型名
func NewUser(id int64, name string, age int) *User {
    return &User{ID: id, Name: name, age: age}
}

// 方法绑定在 struct 上（receiver）
func (u *User) IsAdult() bool {
    return u.age >= 18
}

user := NewUser(1, "张三", 25)
fmt.Println(user.IsAdult())

type User struct {
    ID   int64  // 大写 = 其他包可以访问
    Name string // 大写 = 公开
    age  int    // 小写 = 只在 user 包内可访问
}

func NewUser() *User { // 大写 = 公开函数
    return &User{}
}

func (u *User) validate() error { // 小写 = 包内方法
    // ...
}