Java 开发者的 Python 快速上手指南 | 极客日志

Pythonjava算法

Java 开发者的 Python 快速上手指南

面向 Java 开发者，对比了 Java 与 Python 在核心差异、语法结构、面向对象编程及常用功能上的不同。重点阐述了动态类型、缩进规则、函数定义、集合操作等关键变化，并提供了文件操作、异常处理、JSON 及 HTTP 请求的代码对照。最后引导读者转变思维，从“万物皆类”转向简洁优雅，利用列表推导式、内置函数等 Python 特性提升效率，并推荐了官方文档及相关学习资源。

魔法巫师发布于 2026/3/26更新于 2026/4/163 浏览

Java 开发者的 Python 快速上手指南

🔄 核心差异对比

一句话总结

特性	Java	Python
设计哲学	'明确优于隐式'

// Java 思维：我需要声明类型，编译器会检查
// Python 思维：变量就是标签，可以指向任何对象
// Java 思维：一切皆对象（几乎）
// Python 思维：一切真的皆对象（包括函数、类）
// Java 思维：接口定义契约
// Python 思维：鸭子类型：看起来像鸭子就是鸭子
// Java 思维：显式导入每个类
// Python 思维：导入模块或包

// 必须声明类型
int age = 25;
String name = "张三";
List<String> items = new ArrayList<>();
// 类型推断（Java 10+）
var count = 10;

# 无需声明类型，直接赋值
age = 25
name = "张三"
items = []
# 类型提示（可选，用于 IDE 和类型检查工具）
age: int = 25
name: str = "张三"
items: list[str] = []

if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

if score >= 90:
    print("优秀")
elif score >= 60:
    print("及格")
else:
    print("不及格")

// for 循环
for (int i = 0; i < 5; i++) {
    System.out.println(i);
}
// foreach
for (String item : items) {
    System.out.println(item);
}
// while
while (condition) {
    // ...
}

# for 循环（基于迭代器）
for i in range(5):  # 0, 1, 2, 3, 4
    print(i)
# 遍历列表
for item in items:
    print(item)
# 带索引遍历
for index, item in enumerate(items):
    print(f"{index}: {item}")
# while
while condition:
    # ...

// 实例方法
public String greet(String name) {
    return "Hello, " + name;
}
// 静态方法
public static int add(int a, int b) {
    return a + b;
}
// 方法重载
public void print(String msg) {}
public void print(int num) {}

# 函数定义
def greet(name):
    return f"Hello, {name}"

# 带类型提示
def add(a: int, b: int) -> int:
    return a + b 

# 默认参数
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}"

# 可变参数
def sum_all(*numbers):
    # 类似 Java 的 int... numbers
    return sum(numbers)

# 关键字参数
def create_user(name, age, **kwargs):
    print(kwargs)  # 其他参数字典
    # create_user("张三", 25, city="北京", job="工程师")

String name = "Python";
String msg = "Hello, " + name;  // 拼接
String formatted = String.format("Hello, %s", name);
// Java 15+ 文本块
String json = """ { "name": "张三" } """;

name = "Python"
msg = "Hello, " + name  # 拼接（不推荐）
# f-string（推荐，Python 3.6+）
msg = f"Hello, {name}"
msg = f"1 + 1 = {1+1}"  # 可以包含表达式
# 格式化
msg = "Hello, {}".format(name)
msg = "Hello, {name}".format(name="Python")
# 多行字符串
text = """ 这是多行
文本 """
# 字符串方法
"hello".upper()  # "HELLO"
"HELLO".lower()  # "hello"
" hi ".strip()  # "hi"
"a,b,c".split(",")  # ['a', 'b', 'c']

// List
List<String> list = new ArrayList<>();
list.add("a");
list.get(0);
list.size();
// Set
Set<Integer> set = new HashSet<>();
set.add(1);
// Map
Map<String, Integer> map = new HashMap<>();
map.put("age", 25);
map.get("age");

# 列表（List）- 类似 ArrayList
list_obj = ["a", "b", "c"]
list_obj.append("d")  # 添加
list_obj[0]  # 访问
len(list_obj)  # 长度
list_obj.remove("a")  # 删除

# 元组（Tuple）- 不可变列表
tuple_obj = ("a", "b", "c")
tuple_obj[0]  # ✅ 可以访问
# tuple_obj[0] = "x"  # ❌ 不可修改

# 集合（Set）
set_obj = {1, 2, 3}
set_obj.add(4)
set_obj.remove(1)

# 字典（Dict）- 类似 HashMap
dict_obj = {"name": "张三", "age": 25}
dict_obj["age"]  # 访问
dict_obj["city"] = "北京"  # 添加
dict_obj.get("age", 0)  # 带默认值

# 列表推导式（超强大！）
squares = [x**2 for x in range(10)]  # [0, 1, 4, 9, 16, ...]
evens = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]

# 字典推导式
squares_dict = {x: x**2 for x in range(5)}  # {0:0, 1:1, 2:4, 3:9, 4:16}

# 切片操作
nums = [0, 1, 2, 3, 4, 5]
nums[1:4]  # [1, 2, 3] - 索引 1 到 3
nums[:3]  # [0, 1, 2] - 前 3 个
nums[3:]  # [3, 4, 5] - 从索引 3 到末尾
nums[-1]  # 5 - 最后一个
nums[::-1]  # [5, 4, 3, 2, 1, 0] - 反转

public class Person {
    private String name;
    private int age;
    
    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // Getter/Setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    
    // 方法
    public void greet() {
        System.out.println("Hello, I'm " + name);
    }
    
    // 静态方法
    public static void staticMethod() {
        // ...
    }
}
// 使用
Person p = new Person("张三", 25);
p.greet();

class Person:
    # 类变量（所有实例共享）
    species = "Human"
    
    # 构造函数
    def __init__(self, name, age):
        self.name = name  # 实例变量
        self.age = age    # 实例变量
    
    # 实例方法（第一个参数必须是 self）
    def greet(self):
        print(f"Hello, I'm {self.name}")
    
    # 私有方法（约定：单下划线开头）
    def _private_method(self):
        pass
    
    # 类方法
    @classmethod
    def from_birth_year(cls, name, birth_year):
        age = 2025 - birth_year
        return cls(name, age)
    
    # 静态方法
    @staticmethod
    def is_adult(age):
        return age >= 18
    
    # 属性装饰器（代替 getter/setter）
    @property
    def display_name(self):
        return f"Mr./Ms. {self.name}"
    
    @display_name.setter
    def display_name(self, value):
        self.name = value.replace("Mr./Ms. ", "")

# 使用
p = Person("张三", 25)
p.greet()

# 类方法调用
p2 = Person.from_birth_year("李四", 1990)

# 属性访问
print(p.display_name)  # 自动调用 getter
p.display_name = "Mr./Ms. 王五"  # 自动调用 setter

特性	Java	Python
访问修饰符	`public`, `private`, `protected`	无，用命名约定（`_private`, `__really_private`）
构造函数	与类同名	`__init__(self)`
this	`this`	`self`（必须显式声明）
getter/setter	显式方法	`@property` 装饰器
静态方法	`static` 关键字	`@staticmethod` 装饰器

// 父类
public class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void makeSound() {
        System.out.println("Some sound");
    }
}

// 子类
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

// 接口
public interface Flyable {
    void fly();
}

public class Bird extends Animal implements Flyable {
    @Override
    public void fly() {
        System.out.println("Flying...");
    }
}

# 父类
class Animal:
    def __init__(self, name):
        self.name = name
    def make_sound(self):
        print("Some sound")

# 子类
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)  # 调用父类构造函数
        self.breed = breed
    def make_sound(self):
        # 重写方法
        print("Woof!")

# 多重继承（Java 不支持）
class Flyable:
    def fly(self):
        print("Flying...")

class Bird(Animal, Flyable):
    # 多重继承
    def make_sound(self):
        print("Chirp!")

# 使用
bird = Bird("Sparrow")
bird.make_sound()  # Chirp!
bird.fly()  # Flying...

// 抽象类
public abstract class Shape {
    abstract double area();
}

// 接口
public interface Drawable {
    void draw();
}

from abc import ABC, abstractmethod 

# 抽象类
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

# 接口（本质上也是抽象类）
class Drawable(ABC):
    @abstractmethod
    def draw(self):
        pass

# 实现
class Circle(Shape, Drawable):
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return 3.14 * self.radius ** 2
    def draw(self):
        print("Drawing circle")

// 读文件
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 写文件
try (BufferedWriter bw = new BufferedWriter(new FileWriter("file.txt"))) {
    bw.write("Hello, World!");
} catch (IOException e) {
    e.printStackTrace();
}

# 读文件（自动关闭）
with open("file.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())

# 一次性读取所有行
with open("file.txt", "r") as f:
    lines = f.readlines()  # 返回列表

# 写文件
with open("file.txt", "w", encoding="utf-8") as f:
    f.write("Hello, World!")

# 追加
with open("file.txt", "a") as f:
    f.write("\nNew line")

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.err.println("除零错误：" + e.getMessage());
} catch (Exception e) {
    System.err.println("其他错误");
} finally {
    System.out.println("总是执行");
}

// 抛出异常
public void doSomething() throws IOException {
    throw new IOException("错误");
}

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"除零错误：{e}")
except Exception as e:
    print(f"其他错误：{e}")
else:
    print("没有异常时执行")
finally:
    print("总是执行")

# 抛出异常
def do_something():
    raise ValueError("错误信息")

# 自定义异常
class MyException(Exception):
    pass
raise MyException("自定义错误")

// 使用 Gson 或 Jackson
import com.google.gson.Gson;

class User {
    String name;
    int age;
}

Gson gson = new Gson();

// 对象 → JSON
User user = new User();
user.name = "张三";
user.age = 25;
String json = gson.toJson(user);

// JSON → 对象
User user2 = gson.fromJson(json, User.class);

import json 

# 字典 → JSON
user = {"name": "张三", "age": 25}
json_str = json.dumps(user, ensure_ascii=False)  # {"name": "张三", "age": 25}

# JSON → 字典
user2 = json.loads(json_str)

# 读写文件
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(user, f, ensure_ascii=False, indent=2)
with open("data.json", "r", encoding="utf-8") as f:
    user3 = json.load(f)

RestTemplate restTemplate = new RestTemplate();
String url = "https://api.example.com/users";

// GET 请求
User user = restTemplate.getForObject(url + "/1", User.class);

// POST 请求
User newUser = new User();
User created = restTemplate.postForObject(url, newUser, User.class);

import requests 
url = "https://api.example.com/users"

# GET 请求
response = requests.get(f"{url}/1")
user = response.json()  # 自动解析 JSON

# POST 请求
new_user = {"name": "张三", "age": 25}
response = requests.post(url, json=new_user)
created = response.json()

# 带参数和头部
response = requests.get(
    url,
    params={"page": 1, "size": 10},
    headers={"Authorization": "Bearer token"}
)

# 不推荐：Python 不需要所有东西都放在类里
class MathUtils:
    @staticmethod
    def add(a, b):
        return a + b 
    @staticmethod
    def multiply(a, b):
        return a * b 
result = MathUtils.add(1, 2)

# 推荐：直接用函数
def add(a, b):
    return a + b 
def multiply(a, b):
    return a * b 
result = add(1, 2)

# 过度类型检查
def process_data(data):
    if not isinstance(data, list):
        raise TypeError("data must be a list")
    # ...

# 相信传入的对象有正确的方法
def process_data(data):
    for item in data:  # 只要能迭代就行
        print(item)
    # 可以传入 list, tuple, set, 自定义迭代器...

# 用传统方式
result = []
for i in range(10):
    if i % 2 == 0:
        result.append(i * i)

# 列表推导式（一行搞定）
result = [i * i for i in range(10) if i % 2 == 0]

# Java 开发者容易忽略的强大内置函数
# map - 对每个元素应用函数
nums = [1, 2, 3]
squares = list(map(lambda x: x**2, nums))  # [1, 4, 9]

# filter - 过滤元素
evens = list(filter(lambda x: x % 2 == 0, range(10)))  # [0, 2, 4, 6, 8]

# zip - 并行迭代
names = ["张三", "李四"]
ages = [25, 30]
for name, age in zip(names, ages):
    print(f"{name}: {age}")

# any/all - 判断
has_even = any(x % 2 == 0 for x in [1, 3, 5, 6])  # True
all_positive = all(x > 0 for x in [1, 2, 3])  # True

# enumerate - 带索引遍历
for i, item in enumerate(["a", "b", "c"]):
    print(f"{i}: {item}")

功能	Java	Python
打印	`System.out.println()`	`print()`
长度	`str.length()`	`len(str)`
字符串拼接	`"a" + "b"`	`f"{a}{b}"` 或 `"a" + "b"`
数组/列表	`int[] arr = new int[5]`	`arr = [1, 2, 3]`
字典/Map	`Map<K,V> map = new HashMap<>()`	`dict = {"key": "value"}`
空值	`null`	`None`
布尔值	`true/false`	`True/False`
逻辑运算	`&&,
类型判断	`instanceof`	`isinstance()`
相等比较	`.equals()`	`==` （对象用 `is`）
三元运算	`x ? a : b`	`a if x else b`
匿名函数	`(a, b) -> a + b`	`lambda a, b: a + b`
常量	`final`	无（约定用大写 `MAX_SIZE`）
包	`package/import`	`import`

Java 开发者的 Python 快速上手指南

Java 开发者的 Python 快速上手指南

🔄 核心差异对比

一句话总结

关键思维转变

⚡ 语法快速对照

1. 变量声明与类型

Java

Python

2. 基本语法结构

条件语句

循环

3. 函数/方法定义

Java

Python

4. 字符串处理

Java

Python

5. 集合类型对比

Java

Python

🎯 面向对象编程对比

类定义

Java

Python

继承

Java

Python

抽象类与接口

Java

Python

💼 常用功能实现对比

1. 文件操作

Java

Python

2. 异常处理

Java

Python

3. JSON 处理

Java

Python

4. HTTP 请求

Java (Spring RestTemplate)

Python (requests 库)

🧠 Java 思维 → Python 思维

1. 不要过度使用类

❌ Java 思维（万物皆类）

✅ Python 思维（函数式）

2. 拥抱动态类型

❌ Java 思维

✅ Python 思维（鸭子类型）

3. 使用 Python 特色功能

❌ Java 思维

✅ Python 思维

4. 善用内置函数

📚 推荐学习资源

在线资源

书籍推荐

练习平台

🔥 速查表：Java vs Python

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具