Java 转 Go 基础对照手册
AI 摘要salmon-ai
本文详细解析了 Java 转 Go 的基础对照关系,围绕设计哲学、基本语法、类型系统、字符串、struct 与方法、集合、接口与组合、错误处理、并发
适合人群:有 1~5 年 Java 开发经验,准备系统性转向 Go 的工程师
目标:不是“会写 Go”,而是“用 Go 写出 Java 等级的工程代码”
一、整体认知差异(先别急着写代码)
1.1 设计哲学对比
| 维度 | Java | Go |
|---|---|---|
| 设计目标 | 面向大型企业系统 | 面向工程效率 + 并发 |
| 编程范式 | 面向对象为主 | 组合优于继承 |
| 并发模型 | 线程 + 锁 | Goroutine + Channel |
| 心智负担 | 高(框架、抽象多) | 低(语言层面解决并发) |
| 常见风格 | “设计在前” | “先跑起来再优化” |
一句话总结:Java 在“结构”,Go 在“流动”。
二、基础语法与类型系统对照
2.1 基本数据类型
| Java | Go |
|---|---|
| byte / short / int / long | int8 / int16 / int / int64 |
| float / double | float32 / float64 |
| boolean | bool |
| char | rune (int32) |
java
int a = 10;
go
var a int = 10
// or
a := 10
⚠️ 注意点:
- Go 没有隐式类型转换
- int 在 Go 中是 平台相关(32/64)
2.2 字符串
java
String s = "hello";
s += " world";
s := "hello"
s = s + " world"
Java String vs Go string
- Java:String 是对象(不可变)
- Go:string 是值类型(底层是只读字节切片)
go
// 遍历字符(注意 rune)
for _, r := range s {
fmt.Println(r)
}
三、对象、结构体与“面向对象”
3.1 Java 类 vs Go struct
java
class User {
private Long id;
private String name;
}
go
type User struct {
ID int64
Name string
}
👉 Go 没有 class,只有 struct + method
3.2 构造方法
java
public User(Long id, String name) {
this.id = id;
this.name = name;
}
go
func NewUser(id int64, name string) *User {
return &User{ID: id, Name: name}
}
3.3 Getter / Setter
Java:
java
public String getName() { return name; }
Go:不需要(通过首字母大小写控制可见性)
go
user.Name
Go 的哲学:数据结构应当简单透明
四、集合体系对照(Java 集合 → Go 内置类型)
4.1 List vs Slice
java
List<String> list = new ArrayList<>();
list.add("a");
go
list := []string{}
list = append(list, "a")
| Java List | Go Slice |
|---|---|
| 动态数组 | 动态数组 |
| 接口统一 | 原生类型 |
| 容量不可见 | cap 可见 |
4.2 Map
java
Map<String, Integer> map = new HashMap<>();
map.put("a", 1);
go
m := make(map[string]int)
m["a"] = 1
判空差异
java
if (map.containsKey("a")) {}
go
v, ok := m["a"]
if ok {}
五、接口、继承与组合
5.1 Java 接口
java
interface Service {
void do();
}
5.2 Go 接口(核心思想)
go
type Service interface {
Do()
}
type UserService struct {}
func (u UserService) Do() {}
✅ Go:实现接口是“隐式的”
5.3 继承 vs 组合
Java:
java
class B extends A {}
Go:
go
type B struct {
A
}
Go 鼓励:has-a,而不是 is-a
六、异常处理模型
6.1 Java Exception
java
try {
risky();
} catch (Exception e) {
}
6.2 Go error(重要转变)
go
if err := risky(); err != nil {
return err
}
panic vs recover ≈ JVM 崩溃
go
defer func() {
if r := recover(); r != nil {}
}()
⚠️ 业务代码禁止滥用 panic
七、并发模型:Java 线程 → Go 协程
7.1 创建线程 vs Goroutine
java
new Thread(() -> work()).start();
go
go work()
👉 Goroutine 不是线程,由 Go Runtime 调度
7.2 锁机制对照
| Java | Go |
|---|---|
| synchronized | sync.Mutex |
| ReentrantLock | sync.Mutex / RWMutex |
go
var mu sync.Mutex
mu.Lock()
mu.Unlock()
7.3 Channel(Java 没有的核心能力)
go
ch := make(chan int)
go func() {
ch <- 1
}()
v := <-ch
Go 并发核心口诀:不要通过共享内存通信,而要通过通信共享内存
八、线程池 vs Goroutine Pool
8.1 Java 线程池
java
ExecutorService pool = Executors.newFixedThreadPool(10);
8.2 Go 的哲学
- 通常不需要线程池
- Goroutine 足够轻量
如需控制并发:
go
sem := make(chan struct{}, 10)
sem <- struct{}{}
go func() {
defer func(){ <-sem }()
work()
}()
九、IO 模型对照
9.1 文件 IO
Java:
java
Files.readAllBytes(path);
Go:
go
data, _ := os.ReadFile(path)
9.2 NIO vs Go net/http
Java:Netty / NIO
Go:
go
http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("hello"))
})
http.ListenAndServe(":8080", nil)
👉 Go 标准库即生产级别
十、工程结构(非常关键)
Java 常见结构
bash
controller
service
dao
entity
Go 推荐结构(DDD / Clean)
bash
cmd/
internal/
biz/
service/
repo/
transport/
pkg/
十一、从 Java 思维到 Go 思维的 5 个转变
- 少设计模式,多写直觉代码
- 接口用于解耦,不用于抽象层级
- 错误是流程的一部分
- 并发是常态,不是高级功能
- 代码可读性 > 一切
十二、总结
Java 教会你如何构建“复杂系统”
Go 教会你如何构建“高效系统”
如果你是:
- Java 1~5 年工程师
- 厌倦过度抽象、配置地狱
- 想写 更贴近业务、更稳定的系统
👉 Go 非常值得你认真学一次
评论
0 条—
还没有评论,来说第一句