Go / C / Python / Java 四语言对照学习总览

目录

0 介绍

1.1 源文件与组织

C

Go

Python

Java（传统）

Java 25+ Compact Source（定稿）

01 程序结构与入口

1.2 入口函数规则

1.3 编译与运行流程

1.4 语句与块

1.5 注释

1.6 易混点

02 变量常量作用域

2.1 声明 vs 定义 vs 赋值

2.2 可变性

2.3 作用域规则

2.4 零值 / 默认值

2.5 类型推断对照

2.6 易混点

03 数据类型

3.1 类型系统哲学

3.2 整数类型

3.3 浮点

3.4 布尔

3.5 字符与字符串类型

3.6 复合类型总览

3.7 类型转换规则

3.8 空值表示

3.9 易混点

04 运算符与表达式

4.1 算术运算符

4.2 比较与逻辑

4.3 位运算

4.4 赋值与复合赋值

4.5 地址、解引用、成员访问

4.6 运算符优先级（记忆版）

4.7 类型相关运算符/表达式

4.8 易混点

05 控制流

5.1 条件分支 if

5.2 switch

5.3 循环

5.4 跳转语句

5.5 模式匹配（2026 水平）

5.6 异常与控制流（交叉）

5.7 易混点

06 函数与方法

6.1 函数定义语法

6.2 参数传递语义

6.3 多返回值 / 可选返回

6.4 默认参数 / 重载 / 可变参数

6.5 闭包与高阶函数

6.6 方法与接收者

6.7 递归、内联、尾调用

6.8 易混点

07 字符串与字符

7.1 内部表示

7.2 字面量形式

7.3 常用操作对照

7.4 转义与 Unicode

7.5 C 字符串特别说明

7.6 Go 字符串与 rune

7.7 易混点

08 集合与复合结构

8.1 数组 / 定长序列

8.2 动态序列

8.3 映射（键值对）

8.4 结构体 / 记录

8.5 集合类型扩展

8.6 迭代

8.7 内存布局（C/Go 重点）

8.8 易混点

09 指针引用内存

9.1 有无指针

9.2 指针基础（C / Go）

9.3 内存分配与释放

9.4 栈 vs 堆

9.5 垃圾回收

9.6 常见内存问题

9.7 引用语义对比

9.8 unsafe / 底层操作

9.9 易混点

10 输入输出

10.1 标准流模型

10.2 控制台输出

10.3 控制台输入

10.4 文件 I/O

Python 推荐

Go 推荐

Java 推荐

10.5 二进制 I/O

10.6 缓冲 I/O

10.7 序列化（JSON 等）

10.8 易混点

11 错误与异常

11.1 对照

11.2 C：返回码与 errno

11.3 Go：error 接口

11.4 Python：异常

11.5 Java：受检与非受检

11.6 四语言错误处理对照表

11.7 资源管理与错误

11.8 选型直觉

11.9 易混点

12 面向对象与组合

12.1 范式定位

12.2 类 / 结构体定义

12.3 继承 vs 组合

Go 嵌入（组合）

Python 继承

Java

12.4 接口 / 抽象

12.5 多态

12.6 访问控制

12.7 特殊 OOP 特性

12.8 Java record 与 Python dataclass

12.9 易混点

13 泛型与类型参数

13.1 支持概览

13.2 C：宏与 _Generic

13.3 Go 泛型

13.4 Python 类型参数

13.5 Java 泛型

13.6 约束 / 边界对照

13.7 协变与逆变（进阶）

13.8 易混点

14 并发模型

14.1 总览

14.2 C：POSIX 线程

14.3 Go：goroutine 与 channel

14.4 Python：GIL、asyncio、多进程

threading（I/O 密集）

asyncio（协作式并发）

Python 3.14 自由线程（可选构建）

14.5 Java：平台线程与虚拟线程

传统线程

虚拟线程（Java 21+，生产可用）

Java 25 定稿：Scoped Values

Java 26 预览：Structured Concurrency

14.6 同步原语对照

14.7 并发选型建议

14.8 易混点

15 模块包依赖

15.1 组织单元对照

15.2 C：头文件与链接

15.3 Go：module

15.4 Python：包与 pyproject

15.5 Java：包、模块系统、构建

传统包

Java 9+ 模块（module-info.java）

Java 25：Module Import Declarations（定稿）

15.6 版本与发布

15.7 可见性总结

15.8 易混点

16 标准库速览与学习路径

16.1 标准库哲学

16.2 按领域对照

字符串与文本

容器与算法

I/O 与文件

时间与随机

加密与安全

测试

并发

16.3 C23 新增库要点

16.4 Python 3.14 值得知道的标准库

16.5 Java 25/26 值得知道的标准库

16.6 Go 1.26/1.27 标准库动态

16.7 推荐学习路径（交叉强化）

阶段 1：共性基础（2–3 周）

阶段 2：数据结构（3–4 周）

阶段 3：抽象与工程（4–6 周）

阶段 4：系统能力（按兴趣）

阶段 5：2026 新特性补课

16.8 工具链速查

0 介绍

各语言语法更新

Go 1.26

• new(expr)：可对表达式分配并初始化，返回指针（如 p := new(42) → *int）
• 泛型类型可在自身类型参数列表中自引用（更强约束表达）
• Green Tea GC 默认开启；go fix 现代化重写

Go 1.27（前瞻）

• 泛型方法（method 可声明自己的类型参数）
• encoding/json/v2 等标准库大改

C23

• 关键字：bool / true / false、nullptr、constexpr、typeof / typeof_unqual、alignas / alignof、thread_local、static_assert
• 字面量：二进制 0b、数字分隔符 1'000'000、空初始化 ={}
• 预处理：#embed、#elifdef / #elifndef、#warning
• 类型：_BitInt(N)、可选十进制浮点 _Decimal*
• 属性：[[nodiscard]]、[[deprecated]]、[[fallthrough]] 等
• 新头文件：<stdbit.h>、<stdckdint.h>

Python 3.14

• t-string（PEP 750）：t"…" → Template，用于安全的自定义字符串处理
• 注解延迟求值（PEP 649/749）
• except / except* 可省略括号（PEP 758）
• 禁止从 finally 中 return/break/continue 跳出（PEP 765）
• Free-threaded Python 官方支持（PEP 779，可选构建）
• compression.zstd、多解释器 stdlib 支持

Java 25 LTS（定稿重点）

• Compact Source Files + Instance Main Methods（简化入门）
• Module Import Declarations（import module …）
• Flexible Constructor Bodies
• Scoped Values（定稿）
• 虚线程（Java 21 已定稿，25 继续强化生态）

Java 26（了解）

• 原语类型进入 pattern / instanceof / switch（第 4 次预览）
• Structured Concurrency（第 6 次预览）
• HTTP/3 for HttpClient
• Lazy Constants（第 2 次预览）

1.1 源文件与组织

C

// main.c
#include <stdio.h>
int main(void) { puts("hello"); return 0; }

Go

package main
import "fmt"
func main() { fmt.Println("hello") }

Python

def main():
    print("hello")
if __name__ == "__main__":
    main()

Java（传统）

public class App {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

Java 25+ Compact Source（定稿）

// 无 class 包裹，实例 main
void main() {
    IO.println("hello");
}

01 程序结构与入口

1.2 入口函数规则

差异要点

• 只有 C 和 Java（传统） 把 main 签名写进语言规范。
• Go 的 main 不能带参数，命令行用 os.Args。
• Python 脚本可直接顶层执行，入口是约定而非语法强制。

1.3 编译与运行流程

C:     源码 → 预处理 → 编译(.o) → 链接 → 可执行文件
Go:    源码 → 编译（静态链接）→ 可执行文件
Python:源码 → 字节码(.pyc) → 解释器执行
Java:  源码 → 字节码(.class) → JVM 解释/JIT

1.4 语句与块

Python 独特点：用缩进（通常 4 空格）表达块，这是语法的一部分，不是风格问题。

1.5 注释

1.6 易混点

02 变量常量作用域

2.1 声明 vs 定义 vs 赋值

示例对照

// C23
auto count = 42;           // 类型推断
constexpr int MAX = 100;   // 编译期常量对象
var a int        // 0
b := 3.14        // 短变量声明，类型推断
const Pi = 3.14  // 编译期常量
x = 10           # 动态绑定，类型可随时变
x = "hello"      # 合法
MAX: int = 100   # 类型注解 + 赋值（运行时检查，非强制）
final int MAX = 100;
var list = List.of(1, 2);  // 局部变量类型推断（Java 10+）

2.2 可变性

Go 注意：const 只能是编译期可求值的常量表达式；没有 const 修饰变量引用。

Python 注意：tuple 不可变指的是引用不可重新绑定元素（若元素是可变对象，内容仍可改）。

2.3 作用域规则

Python 的 LEGB 规则

Local → Enclosing → Global → Built-in

x = 1
def f():
    global x   # 修改模块级 x
    x = 2

Go 的短声明陷阱

if x := compute(); x > 0 { }  // x 仅 if 块内

2.4 零值 / 默认值

关键差异：只有 Go 和 Java（字段） 系统性提供零值；C 局部变量 不初始化是经典 bug 源。

2.5 类型推断对照

2.6 易混点

03 数据类型

3.1 类型系统哲学

3.2 整数类型

#include <stdint.h>
int32_t a = 1;
_BitInt(128) big;  // C23
var n int = 42  // int 大小随平台（32或64位）
int x = 1;
long y = 1L;

3.3 浮点

3.4 布尔

3.5 字符与字符串类型

3.6 复合类型总览

3.7 类型转换规则

记忆：C 最“松”，Go/Java 最“严”，Python 不靠编译期转换而靠对象协议。

3.8 空值表示

3.9 易混点

04 运算符与表达式

4.1 算术运算符

7 / 2   # 3.5
7 // 2  # 3
7 / 2   // 3（整数除法）

4.2 比较与逻辑

Go 特殊：== 可用于 struct（字段都可比时）、array；不能比较 slice、map、func。

4.3 位运算

C23 提供 <stdbit.h>：stdc_count_ones、stdc_leading_zeros 等可移植位操作。

4.4 赋值与复合赋值

四语言均支持 +=, -=, *=, /=, %=, 位运算复合赋值。

Go 独有：:= 声明并赋值（非单纯赋值运算符）。

4.5 地址、解引用、成员访问

4.6 运算符优先级（记忆版）

共同规律：一元 > 乘除 > 加减 > 移位 > 比较 > 相等 > 位与 > 位异或 > 位或 > 逻辑与 > 逻辑或 > 赋值

差异：

• Python 逻辑用英文单词，优先级更清晰
• Go 无 ++ 参与表达式（i++ 是语句）
• C 逗号运算符 , 可作为表达式一部分

4.7 类型相关运算符/表达式

4.8 易混点

05 控制流

5.1 条件分支 if

Python 真值测试

空容器、0、None、False 为假；其余多为真。

Go 的 if 初始化语句

if err := do(); err != nil {
    return err
}

5.2 switch

switch n {
case 1, 2:
    fmt.Println("small")
default:
    fmt.Println("other")
}
match command:
    case "quit" | "exit":
        break
    case int(n) if n > 0:
        print(n)
// Java 21+ switch 表达式
String result = switch (day) {
    case MONDAY, FRIDAY -> "work";
    case SATURDAY, SUNDAY -> "rest";
    default -> "unknown";
};

5.3 循环

for i := 0; i < n; i++ { }
for _, v := range slice { }
for i, v in enumerate(items):
    …

5.4 跳转语句

5.5 模式匹配（2026 水平）

// Java 25 预览：原语也可 pattern
if (obj instanceof int i) {
    System.out.println(i);
}

5.6 异常与控制流（交叉）

Python EAFP：Easier to Ask Forgiveness than Permission

try:
    return data[key]
except KeyError:
    return default

5.7 易混点

06 函数与方法

6.1 函数定义语法

int add(int a, int b) { return a + b; }
func divide(a, b int) (q int, err error) {
    if b == 0 { return 0, errors.New("div by zero") }
    return a / b, nil
}
def greet(name: str, *, loud: bool = False) -> str:
    s = f"hello {name}"
    return s.upper() if loud else s
public static int add(int a, int b) { return a + b; }

6.2 参数传递语义

统一记忆：只有 C 有真正的“按值复制整个对象”；其余语言“值传递”常指传递指针/引用的副本。

6.3 多返回值 / 可选返回

6.4 默认参数 / 重载 / 可变参数

func sum(nums …int) int { … }
void log(String fmt, Object… args) { … }

6.5 闭包与高阶函数

func counter() func() int {
    n := 0
    return func() int { n++; return n }
}
def counter():
    n = 0
    def inc():
        nonlocal n
        n += 1
        return n
    return inc

6.6 方法与接收者

Go 指针接收者：需要修改接收者或避免复制大 struct 时用 *T。

6.7 递归、内联、尾调用

6.8 易混点

07 字符串与字符

7.1 内部表示

7.2 字面量形式

Python 3.14 t-string

from string.templatelib import Template
name = "world"
tpl: Template = t"Hello, {name}!"
# 可遍历 tpl.strings / tpl.interpolations 做安全处理

7.3 常用操作对照

7.4 转义与 Unicode

7.5 C 字符串特别说明

char s[] = "hi";     // 可修改数组
char *p = "hi";      // 字符串字面量，常不可写
// C23
const char *q = u8"你好";

经典坑

• char * 与 char[] 不同
• sizeof(s) vs strlen(s)
• 缓冲区溢出 → 用 snprintf、边界检查

7.6 Go 字符串与 rune

s := "你好"
for i, r := range s { // r 是 rune，i 是字节偏移
    _ = i; _ = r
}

len(s) 是字节数，不是字符数；计数用 utf8.RuneCountInString。

7.7 易混点

08 集合与复合结构

8.1 数组 / 定长序列

8.2 动态序列

s := make([]int, 0, 10)  // len=0, cap=10
s = append(s, 1)
lst = [1, 2, 3]
lst.append(4)
var list = new ArrayList<Integer>();
list.add(1);

Go slice 三要素

pointer + len + cap —— 理解 slice 是学 Go 的关键。

8.3 映射（键值对）

v, ok := m["key"]
if !ok { /* 不存在 */ }
v = d.get("key", default)

8.4 结构体 / 记录

record Point(int x, int y) {}
from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

8.5 集合类型扩展

8.6 迭代

8.7 内存布局（C/Go 重点）

C struct 填充（padding） 影响 ABI、网络协议、嵌入式。

struct S { char a; int b; };  // 可能有 3 字节 padding

Go 编译器也会对齐，可用 unsafe 分析但不建议依赖。

Python/Java 对象布局对用户不透明。

8.8 易混点

09 指针引用内存

9.1 有无指针

9.2 指针基础（C / Go）

int x = 10;
int *p = &x;
*p = 20;
x := 10
p := &x
*p = 20

9.3 内存分配与释放

Go 1.26：new(expr)

p := new(42)        // *int，值为 42
age := new(18)      // 用于可选 JSON 字段等

旧写法：v := 42; p := &v

9.4 栈 vs 堆

9.5 垃圾回收

9.6 常见内存问题

C23 memset_explicit：安全擦除敏感内存。

9.7 引用语义对比

Java

StringBuilder sb = new StringBuilder();
foo(sb);  // 可修改对象内容

Python

def foo(lst):
    lst.append(1)  # 修改外部可见

Go — 传 slice 可改底层元素：

func add1(s []int) { s[0]++ }  // 外部 slice 元素会变

9.8 unsafe / 底层操作

9.9 易混点

10 输入输出

10.1 标准流模型

10.2 控制台输出

换行差异

• C printf 不自动换行
• Go Println 自动换行
• Python print 默认换行，end= 可改
• Java println 自动换行

10.3 控制台输入

// C：scanf 有缓冲区溢出风险，优先 fgets + sscanf
char line[128];
if (fgets(line, sizeof line, stdin))
    sscanf(line, "%d", &n);
reader := bufio.NewReader(os.Stdin)
line, _ := reader.ReadString('\\n')
line = input().strip()
n = int(line)
var sc = new Scanner(System.in);
int n = sc.nextInt();

10.4 文件 I/O

Python 推荐

with open("data.txt", encoding="utf-8") as f:
    content = f.read()

Go 推荐

data, err := os.ReadFile("data.txt")

Java 推荐

String s = Files.readString(Path.of("data.txt"));

10.5 二进制 I/O

// C23 嵌入资源
const unsigned char icon[] = {
#embed "icon.png"
};

10.6 缓冲 I/O

教训：C/Go 的 printf 无换行时可能因缓冲延迟显示；调试可加 \\n 或 fflush(stdout)。

10.7 序列化（JSON 等）

10.8 易混点

11 错误与异常

11.1 对照

11.2 C：返回码与 errno

#include <errno.h>
#include <string.h>

FILE *f = fopen("missing.txt", "r");
if (!f) {
    fprintf(stderr, "open failed: %s\\n", strerror(errno));
    return 1;
}

无异常，也无强制检查返回码——C 最大风险源。

11.3 Go：error 接口

func readConfig(path string) ([]byte, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("read config %s: %w", path, err)
    }
    return data, nil
}

Go 没有 try/catch；panic/recover 类似 defer 级异常，不用于业务错误。

11.4 Python：异常

try:
    with open("missing.txt", encoding="utf-8") as f:
        data = f.read()
except FileNotFoundError as e:
    print("not found:", e)
except OSError as e:
    print("io error:", e)
else:
    print("ok", len(data))
finally:
    print("cleanup")

11.5 Java：受检与非受检

try {
    Files.readString(Path.of("missing.txt"));
} catch (IOException e) {
    throw new RuntimeException(e);
}

现代 Java 趋势：新 API 更少受检异常；用 Optional / Result 风格在库层表达。

11.6 四语言错误处理对照表

11.7 资源管理与错误

f, err := os.Open(path)
if err != nil { return err }
defer f.Close()

11.8 选型直觉

• C：每个调用都检查；失败路径与成功路径同样重要。
• Go：错误是返回值的一部分；链式 if err != nil 是文化。
• Python：用异常表达“意外”；不要用异常做普通分支。
• Java：API 设计要想清楚受检异常是否值得。

11.9 易混点

12 面向对象与组合

12.1 范式定位

12.2 类 / 结构体定义

class Dog:
    def __init__(self, name: str):
        self.name = name
    def bark(self) -> str:
        return "woof"
public class Dog {
    private final String name;
    public Dog(String name) { this.name = name; }
    public String bark() { return "woof"; }
}

12.3 继承 vs 组合

Go 嵌入（组合）

type Engine struct { Power int }
type Car struct {
    Engine  // 匿名字段，方法提升
    Brand string
}

Python 继承

class Animal: …
class Dog(Animal): …

Java

class Dog extends Animal implements Pet { }

12.4 接口 / 抽象

type Reader interface {
    Read(p []byte) (n int, err error)
}
// 任何有 Read 方法的类型都满足 Reader
interface Readable {
    int read(byte[] buf);
}
class MyReader implements Readable { … }

12.5 多态

12.6 访问控制

Go 规则：Foo 导出，foo 不导出——极简但有效。

12.7 特殊 OOP 特性