2.1 Java：传统面向对象#

Java 以 Class 为核心组织程序。

主要特征：

• 封装（Encapsulation）
• 继承（Inheritance）
• 多态（Polymorphism）
• 抽象（Abstraction）

示例：

1
class Animal {
2
    public void speak() {
3
        System.out.println("Animal");
4
    }
5
}
6

7
class Dog extends Animal {
8
    @Override
9
    public void speak() {
10
        System.out.println("Dog");
11
    }
12
}

Java 通过类、继承和接口组织代码，适合构建复杂的业务模型。

2.2 Go：组合式设计#

Go 没有传统的 Class 和继承体系，主要使用：

• Struct：定义数据结构
• Method：定义行为
• Interface：定义行为约束
• Composition：通过组合复用功能

1
type Node struct {
2
    key int
3
    val int
4
}

1
func (n *Node) Print() {
2
    fmt.Println(n.key)
3
}

1
type Animal interface {
2
    Speak()
3
}
4

5
type Dog struct{}
6

7
func (d Dog) Speak() {
8
    fmt.Println("Dog")
9
}

1
type Animal struct{}
2

3
func (a Animal) Eat() {
4
    fmt.Println("eating")
5
}
6

7
type Dog struct {
8
    Animal
9
}

2.3 面向对象机制对照#

注意：Struct 并不完全等同于 Class，Go 的方法也可以定义在符合条件的非结构体类型上。

3.1 Java#

Java 运行在 JVM 上，由 JVM 管理对象内存。

主要涉及：

• 堆（Heap）
• 虚拟机栈（JVM Stack）
• 方法区（逻辑概念，具体实现随 JVM 版本变化）
• 垃圾回收器（GC）

对象通常分配在堆上，GC 根据对象的可达性判断是否可以回收。

3.2 Go#

Go 使用自己的 Runtime 管理内存。

主要涉及：

• Goroutine Stack
• Heap
• Garbage Collector
• 内存分配器

Go 的 GC 主要采用并发标记清除机制，并通过 Runtime 管理 Goroutine、调度和内存分配。

3.3 对比#

两者都不意味着完全不需要考虑内存管理，开发者仍然需要关注对象生命周期、内存占用和资源释放。

注意：文件、Socket 等外部资源不能只依赖 GC，应主动关闭。

4.1 Java：Thread + JUC#

Java 主要通过线程实现并发。

常见机制：

• Thread：线程
• Runnable / Callable：任务抽象
• ExecutorService：线程池
• synchronized：内置锁
• ReentrantLock：可重入锁
• BlockingQueue：阻塞队列
• Atomic：原子操作

示例：

1
ExecutorService pool =
2
    Executors.newFixedThreadPool(4);
3

4
pool.submit(() -> {
5
    System.out.println("running");
6
});
7

8
pool.shutdown();

Java 还提供虚拟线程（Virtual Threads，Java 21 正式引入），适合大量阻塞式任务场景。

4.2 Go：Goroutine + Channel#

Go 使用 Goroutine 作为轻量级并发执行单元。

启动 Goroutine：

1
go func() {
2
    fmt.Println("running")
3
}()

只需要一个 go 关键字，就可以启动一个 Goroutine。

Go Runtime 负责调度 Goroutine，使大量 Goroutine 能够复用相对较少的操作系统线程。

4.3 Channel#

Channel 用于 Goroutine 之间传递数据。

1
func main() {
2
    ch := make(chan int)
3

4
    go func() {
5
        ch <- 100
6
    }()
7

8
    value := <-ch
9
    fmt.Println(value)
10
}

通信过程：

1
Goroutine A
2
     |
3
     | 发送数据
4
     v
5
  Channel
6
     |
7
     | 接收数据
8
     v
9
Goroutine B

Go 的并发设计理念：

Do not communicate by sharing memory; instead, share memory by communicating.

不要通过共享内存来通信，而应该通过通信来共享内存。

不过 Go 也支持传统的共享内存同步方式，例如：

• sync.Mutex
• sync.RWMutex
• sync.WaitGroup
• sync.Once
• sync/atomic

4.4 并发模型对比#

注意：Go 并不是所有并发场景都比 Java 快，两者性能需要结合具体任务评估。

5.1 Java：异常机制#

Java 使用 Exception 处理异常。

1
try {
2
    int result = 10 / 0;
3
} catch (ArithmeticException e) {
4
    System.out.println(e.getMessage());
5
}

主要分类：

• Checked Exception：受检异常
• Unchecked Exception：非受检异常
• Error：严重错误

5.2 Go：显式返回 error#

Go 通常将错误作为函数返回值。

1
func divide(a, b int) (int, error) {
2
    if b == 0 {
3
        return 0, errors.New("division by zero")
4
    }
5

6
    return a / b, nil
7
}

调用：

1
result, err := divide(10, 0)
2

3
if err != nil {
4
    fmt.Println(err)
5
    return
6
}
7

8
fmt.Println(result)

Go 还有 panic 和 recover，但它们不是 Java Exception 的直接对应物。

5.3 对比#

Go 更强调错误显式传递，调用者需要明确处理错误。

6.1 Java：字节码 + JVM#

1
Java Source Code
2
       |
3
       v
4
     javac
5
       |
6
       v
7
  Java Bytecode
8
       |
9
       v
10
      JVM
11
       |
12
       v
13
   Operating System

特点：

• 编译成平台无关的字节码。
• 通过 JVM 执行。
• JVM 可以使用 JIT 即时编译优化热点代码。
• 通常需要 JVM 运行环境。

6.2 Go：编译为原生机器码#

1
Go Source Code
2
       |
3
       v
4
    Go Compiler
5
       |
6
       v
7
 Native Machine Code
8
       |
9
       v
10
   Operating System

特点：

• 通常直接编译为目标平台机器码。
• 通常可以独立运行。
• 编译时可以指定目标操作系统和架构。
• 不需要像 Java 那样单独安装 JVM。

示例：

1
go build -o app main.go
2
./app

交叉编译：

1
GOOS=linux GOARCH=amd64 go build

7.1 Java 生态#

Java 具有成熟的企业级生态。

典型场景：

• 电商系统
• 金融系统
• 企业管理系统
• 复杂业务后台
• 大型微服务应用

7.2 Go 生态#

Go 在云原生和基础设施领域应用广泛。

典型场景：

• 云原生基础设施
• 网络服务
• 微服务
• CLI 工具
• DevOps 工具
• 高并发服务

一句话总结#

Java：通过成熟的面向对象体系和 JVM 生态，构建复杂的企业级软件。

Go：通过简洁的语言设计、轻量级并发和独立部署能力，构建高效的服务与基础设施。

两者并不是谁取代谁，而是设计取舍不同，适合不同的工程场景。