Java、Python、Kotlin、TS 语言对比

我们将 Java 17 作为基准坐标，深度拆解 Python 3.10+ 的核心特性，并同步对比 Kotlin 和 TypeScript。这份文档分为基础语法实战 与进阶特性大百科两部分。

---

第一部分：语法基础实战 (快速上手)

这部分旨在让你看完就能模仿写出基础代码。

1. 变量与类型定义

• Java 17 : var list = new ArrayList<String>(); 或 final String s = "Hi";
• Python : names: list[str] = ["A", "B"] (类型注解可选)
• Kotlin : val name: String = "A" (常量), var age: Int = 1 (变量)
• TS : const name: string = "A", let age: number = 1

2. 函数定义

语言	示例代码
Java	public int add(int a, int b) { return a + b; }
Python	def add(a: int, b: int) -> int: return a + b
Kotlin	fun add(a: Int, b: Int): Int = a + b
TS	function add(a: number, b: number): number { return a + b; }

3. 基础类结构

语言	核心写法 (包含构造函数和成员)
Java	class User { private String name; public User(String n) { this.name = n; } }
Python	class User: def __init__(self, name: str): self.name = name
Kotlin	class User(val name: String) (主构造函数极致简洁)
TS	class User { constructor(public name: string) {} }

---

第二部分：进阶特性深度对比 (高级工具箱)

每个模块包含：定义 、Java 背景 、多语言实战示例。

1. 类型注解 (Type Hints)

• 定义：在动态语言里显式标注类型，以便 IDE 检查错误和代码补全。
• Java 17 背景：Java 是强类型，不写类型过不了编译。Python 引入注解是为了解决"动态类型一时爽，重构代码火葬场"的问题。
• 实战示例：

# Python: 复杂类型使用 typing 模块
from typing import List, Optional, Union

def process_data(vals: List[int], flag: Union[int, str]) -> Optional[str]:
    return "Done" if vals else None

# TS: 结构几乎一致
function processData(vals: number[], flag: number | string): string | null {
    return vals.length > 0 ? "Done" : null;
}

2. 异步编程 (async/await)

• 定义：非阻塞 IO。当程序在等待网络返回时，CPU 可以去处理别的任务。
• Java 17 背景 ：对应 CompletableFuture。Java 21 引入了虚拟线程（Virtual Threads）来简化这种开发。
• 实战示例：

# Python
import asyncio
async def fetch():
    await asyncio.sleep(1) # 模拟网络等待
    return "Data"

# TS
async function fetch(): Promise<string> {
    await new Promise(resolve => setTimeout(resolve, 1000));
    return "Data";
}

# Kotlin (使用协程)
suspend fun fetch(): String {
    delay(1000)
    return "Data"
}

3. 装饰器 (Decorators)

• 定义：在函数或类之上添加逻辑的包装器（AOP 思想）。
• Java 17 背景 ：类似于 Spring 的 @Transactional 或 @Cacheable，但 Java 必须配合反射和 AOP 框架实现。Python 是原生语法支持。
• 实战示例：

# Python: 装饰器是一个接收函数并返回新函数的函数
def debug(func):
    def wrapper(*args):
        print(f"调用了 {func.__name__}")
        return func(*args)
    return wrapper

@debug
def my_job(): pass

4. 上下文管理器 (Context Managers)

• 定义：自动管理资源的生命周期（如：自动关闭文件、释放锁）。
• Java 17 背景 ：等同于 try-with-resources。
• 实战示例：

# Python
with open('data.txt', 'r') as f:
    content = f.read() # 离开缩进块后 f 自动关闭

# Java 17
try (var reader = new FileReader("data.txt")) {
    // 自动关闭
}

# Kotlin
File("data.txt").bufferedReader().use { it.readText() }

5. 生成器 (Generators / yield)

• 定义：一种可以暂停和恢复的函数，每次产出一个值，不一次性占用内存。
• Java 17 背景 ：Java 没有 yield。类似功能需要用 Iterator 或 Stream 模拟。
• 实战示例：

# Python
def count_to_three():
    yield 1
    yield 2
    yield 3

for n in count_to_three(): print(n)

# TS
function* countToThree() {
    yield 1; yield 2;
}

6. 异步生成器 (Async Generators)

• 定义：结合了异步等待和惰性产出。常用于流式处理网络数据。
• 实战示例：

# Python
async def async_gen():
    for i in range(3):
        await asyncio.sleep(1) # 每秒产生一个数据
        yield i

# TS
async function* asyncGen() {
    yield await Promise.resolve(1);
}

7. 数据类 (Dataclasses)

• 定义：自动生成构造、equals、toString 等方法的类。
• Java 17 背景 ：完全等同于 record。
• 实战示例：

# Python
from dataclasses import dataclass
@dataclass
class User:
    id: int
    name: str

# Java 17
public record User(int id, String name) {}

# Kotlin
data class User(val id: Int, val name: String)

8. 属性装饰器 (@property)

• 定义 ：将方法伪装成属性。外部通过 obj.age 访问，内部运行 get_age() 逻辑。
• Java 17 背景：标准的 Getter/Setter 模式。
• 实战示例：

# Python
class Bank:
    def __init__(self): self._money = 0
    @property
    def money(self): return self._money
    @money.setter
    def money(self, val): 
        if val < 0: raise ValueError
        self._money = val

9. 静态与类方法 (@staticmethod / @classmethod)

• Java 17 背景 ：Java 只有一种 static。
• Python 细化 ：
  • @staticmethod: 纯工具函数。
  • @classmethod: 第一个参数是 cls，支持多态（子类调用时 cls 是子类）。
• 实战示例：

class Tool:
    @classmethod
    def create(cls): # 工厂模式
        return cls()

    @staticmethod
    def add(a, b): return a + b

10. 元类 (Metaclasses)

• 定义："制造类的工厂"。
• Java 17 背景：对应动态代理或字节码操作（CGLIB/ByteBuddy）。
• 实战场景 ：例如 AutoTransactionDecoratorMeta 可以在类加载时，自动给所有以 save_ 开头的方法加上事务逻辑。

# Python 示例：所有属性变大写
class UpperMeta(type):
    def __new__(cls, name, bases, dct):
        upper_dct = {k.upper(): v for k, v in dct.items()}
        return super().__new__(cls, name, bases, upper_dct)

class MyClass(metaclass=UpperMeta):
    name = "test" # 访问时需用 MyClass.NAME

11. 弱引用 (Weak References)

• 定义：不阻止垃圾回收。
• Java 17 背景 ：WeakReference<T>。
• 实战场景：大对象缓存。

# Python
import weakref
class LargeObject: pass
obj = LargeObject()
r = weakref.ref(obj) # 当 obj = None 时，r() 也会变成 None

# TS
const cache = new WeakMap(); // 键被回收后，值自动清理

12. 枚举类 (Enum)

• Java 17 背景：Java 的 Enum 非常强大（能写方法）。
• 实战示例：

# Python
from enum import Enum
class Color(Enum):
    RED = 1
    BLUE = 2

# TS
enum Color { Red = 1, Blue = 2 }

13. 函数工具 (functools)

• 定义：增强函数操作的工具集。
• 核心工具 ：
  • @wraps: 防止装饰器弄丢原函数的元数据。
  • partial: 偏函数，固定部分参数。
• 实战示例：

from functools import partial

def power(base, exp): return base ** exp
square = partial(power, exp=2) # 固定 exp 为 2
print(square(5)) # 结果 25

14. Protocol Buffers (Protobuf)

• 定义：跨语言的结构化数据序列化协议。
• 实战说明 ：
  • Java : 编译 .proto 文件生成 Java 类，通过 get/set 操作。
  • Python : 生成 _pb2.py，操作像操作普通类属性一样。
  • 对比: Java 是编译期确定的；Python 在运行时更灵活，但也容易写错字段名。

---

总结：Java 17 开发者上手建议

1. 关于 self ：Python 的 self 对应 Java 的 this，但必须显式写在方法的第一个参数里。
2. 关于缩进：不要在 Python 里找大括号，缩进就是你的逻辑边界。
3. 关于异步 ：Python 的 asyncio 是单线程异步，严禁 在 async 函数里写耗时长的同步计算（会卡死整个程序），这与 Java 的多线程模型完全不同。
4. 关于 Record ：只要在 Python 里想用 Java Record，直接用 @dataclass。