勇士枪战少年
92.41M · 2026-04-12
作为Java开发者，我们早已深耕面向对象编程（OOP），熟练运用类、对象、封装、继承、多态等核心特性构建稳健的应用。而Python作为一门支持多范式的语言，其面向对象编程思想与Java高度一致，但在语法实现、细节特性上存在诸多差异——没有严格的访问修饰符、构造函数更灵活、方法分类更简洁，这些差异往往成为Java开发者上手Python的“小卡点”。
本文将以Java面向对象知识为锚点，逐一对标Python面向对象的核心知识点，用全新编写的代码示例拆解两者的异同，帮你快速完成知识迁移，避开常见坑点，轻松掌握Python面向对象编程的精髓。
无论Java还是Python，面向对象的核心思想完全一致，这也是我们快速上手的基础：
简单来说，Java中“类是图纸，对象是房子”，这句话在Python中同样适用。我们的学习重点，就是搞清楚“同一套思想，两种不同的实现方式”。
Java中定义类必须遵循严格的语法规范，而Python则更简洁，无需声明访问修饰符、无需指定变量/方法类型，上手门槛更低。
Java中定义类必须指定访问修饰符（public、private等），类名遵循帕斯卡命名法，且一个文件通常对应一个公共类；Python无需任何修饰符，类名同样遵循帕斯卡命名法，一个文件可定义多个类。
// Java中必须指定访问修饰符，属性需声明类型
public class User {
// 私有属性，需通过getter/setter访问
private String username;
private int age;
// 无参构造函数
public User() {}
// 有参构造函数
public User(String username, int age) {
this.username = username;
this.age = age;
}
// 公共方法，用于访问私有属性
public void showInfo() {
System.out.println("用户名：" + username + "，年龄：" + age);
}
}
# Python无需访问修饰符，属性无需声明类型
class User:
# __init__ 对应Java的构造函数，self对应Java的this
def __init__(self, username, age):
self.username = username # 实例属性，默认公有
self.age = age
# 实例方法，第一个参数必须是self（对应Java的this）
def show_info(self):
print(f"用户名：{self.username}，年龄：{self.age}")
Java创建对象必须使用new关键字，调用对应的构造函数；Python创建对象直接使用类名加括号，无需new，括号内传入参数即可调用__init__方法（构造函数）。
// Java必须用new关键字，调用有参/无参构造
User user1 = new User(); // 调用无参构造
User user2 = new User("Java程序员", 28); // 调用有参构造
user2.showInfo(); // 输出：用户名：Java程序员，年龄：28
# Python无需new，直接类名()创建对象
user1 = User("Python学习者", 25) # 调用__init__构造
user1.show_info() # 输出：用户名：Python学习者，年龄：25
# 若未定义__init__，Python会提供默认构造，可直接创建空对象
user2 = User() # 报错！因为我们定义了有参__init__，未定义无参
| 特性 | Java | Python |
|---|---|---|
| 类修饰符 | 必须指定（public、private等） | 无需修饰符，默认公有 |
| 构造函数 | 与类名同名，可重载（多个构造函数） | 固定为__init__，不可重载（可通过默认参数实现类似效果） |
| 创建对象 | 必须使用new关键字 | 直接类名()，无需new |
| 对象引用 | 用this表示当前对象 | 用self表示当前对象，且必须作为实例方法第一个参数 |
Java有严格的访问修饰符（public、private、protected），通过getter/setter方法控制属性访问，实现封装；Python没有真正的访问修饰符，而是通过“命名约定”实现伪封装，更灵活但需自觉遵循规范。
Java中属性分为成员变量（实例属性）和静态变量（类属性），Python同样如此，但定义位置和访问方式略有差异。
public class Teacher {
// 类属性（静态变量），所有对象共享，用static修饰
public static String school = "XX大学";
// 实例属性（成员变量），每个对象独有
private String name;
public Teacher(String name) {
this.name = name;
}
public void show() {
// 访问类属性：类名.属性名
System.out.println("学校：" + Teacher.school);
// 访问实例属性：this.属性名
System.out.println("姓名：" + this.name);
}
}
// 测试
Teacher t1 = new Teacher("张老师");
Teacher t2 = new Teacher("李老师");
t1.show();
// 修改类属性，所有对象都会受影响
Teacher.school = "XX师范大学";
t2.show();
class Teacher:
# 类属性，所有对象共享，定义在类体中（不在__init__里）
school = "XX大学"
def __init__(self, name):
# 实例属性，每个对象独有，定义在__init__里，用self绑定
self.name = name
def show(self):
# 访问类属性：类名.属性名 或 self.类名.属性名
print(f"学校：{Teacher.school}")
# 访问实例属性：self.属性名
print(f"姓名：{self.name}")
# 测试
t1 = Teacher("张老师")
t2 = Teacher("李老师")
t1.show()
# 修改类属性，所有对象受影响
Teacher.school = "XX师范大学"
t2.show()
# 给实例绑定同名属性，会“遮蔽”类属性（仅影响当前实例）
t1.school = "XX职业学院"
t1.show() # 学校：XX职业学院
t2.show() # 学校：XX师范大学
Java用private修饰私有属性，外部无法直接访问，必须通过getter/setter方法；Python没有private关键字，通过“命名前缀”约定属性的访问权限。
public class Student {
// 私有属性，外部无法直接访问
private String studentId;
private int score;
// 有参构造
public Student(String studentId, int score) {
this.studentId = studentId;
this.score = score;
}
// getter方法：获取私有属性
public String getStudentId() {
return studentId;
}
// setter方法：修改私有属性，可添加校验逻辑
public void setScore(int score) {
if (score >= 0 && score <= 100) {
this.score = score;
} else {
System.out.println("分数必须在0-100之间");
}
}
public void showScore() {
System.out.println("学号：" + studentId + "，分数：" + score);
}
}
// 测试
Student stu = new Student("2025001", 85);
// System.out.println(stu.score); // 报错，private属性不可直接访问
stu.setScore(95); // 通过setter修改，符合校验
stu.showScore();
class Student:
def __init__(self, student_id, score):
# 伪私有属性：双下划线开头，Python会自动“名称改写”，外部无法直接访问
self.__student_id = student_id
self.__score = score
# @property 装饰器：将方法伪装成属性，实现类似Java getter的效果
@property
def student_id(self):
return self.__student_id
# @属性名.setter：实现类似Java setter的效果，可添加校验
@student_id.setter
def student_id(self, new_id):
# 简单校验：学号必须是6位数字
if len(new_id) == 6 and new_id.isdigit():
self.__student_id = new_id
else:
print("学号必须是6位数字")
@property
def score(self):
return self.__score
@score.setter
def score(self, new_score):
if 0 <= new_score <= 100:
self.__score = new_score
else:
print("分数必须在0-100之间")
def show_score(self):
print(f"学号：{self.__student_id}，分数：{self.__score}")
# 测试
stu = Student("2025001", 85)
# print(stu.__student_id) # 报错，无法直接访问伪私有属性
print(stu.student_id) # 通过@property访问，类似Java getter
stu.score = 95 # 通过setter修改，符合校验
stu.student_id = "2025002" # 符合校验，修改成功
stu.show_score()
Java中的方法有多种修饰符（static、public、private等），用于区分实例方法、静态方法、私有方法；Python中没有这些修饰符，通过“第一个参数”和“装饰器”区分方法类型，更简洁。
Java的实例方法必须有this关键字（隐式传入），用于访问实例属性；Python的实例方法必须有self关键字（显式传入），作用与this完全一致。
Java用static修饰类方法，无法访问实例属性，只能访问类属性；Python用@classmethod装饰器定义类方法，第一个参数是cls（代表类本身），同样只能访问类属性。
public class Book {
// 类属性
private static int count = 0;
// 实例属性
private String title;
// 构造函数，创建对象时计数+1
public Book(String title) {
this.title = title;
count++;
}
// 类方法：用static修饰，访问类属性count
public static int getBookCount() {
// 无法访问this.title（实例属性）
return count;
}
}
// 测试
new Book("Java编程思想");
new Book("Python面向对象实战");
System.out.println("书籍总数：" + Book.getBookCount()); // 输出：2
class Book:
# 类属性
count = 0
def __init__(self, title):
self.title = title
Book.count += 1
# 类方法：@classmethod装饰器，第一个参数是cls
@classmethod
def get_book_count(cls):
# 用cls访问类属性，等价于Book.count
return cls.count
# 测试
Book("Java编程思想")
Book("Python面向对象实战")
print(f"书籍总数：{Book.get_book_count()}") # 输出：2
Java和Python的静态方法作用完全一致：与类和实例都无关，是独立的工具方法，无法访问类属性和实例属性。Java用static修饰，Python用@staticmethod装饰器，且无需传入self或cls参数。
public class MathUtil {
// 静态方法：工具方法，与类无关
public static int add(int a, int b) {
return a + b;
}
public static int multiply(int a, int b) {
return a * b;
}
}
// 测试：直接通过类名调用，无需创建对象
System.out.println(MathUtil.add(3, 5)); // 8
System.out.println(MathUtil.multiply(2, 6)); // 12
class MathUtil:
# 静态方法：@staticmethod装饰器，无默认参数
@staticmethod
def add(a, b):
return a + b
@staticmethod
def multiply(a, b):
return a * b
# 测试：直接通过类名调用，无需创建对象
print(MathUtil.add(3, 5)) # 8
print(MathUtil.multiply(2, 6)) # 12
Java和Python都有构造函数（初始化对象）和析构函数（清理资源），但定义方式和调用时机有明显差异。
Java的构造函数与类名同名，支持重载（多个构造函数，参数不同）；Python的构造函数固定为__init__，不支持重载，但可通过默认参数实现类似重载的效果。
public class Phone {
private String brand;
private String color;
// 无参构造
public Phone() {
this.brand = "未知品牌";
this.color = "黑色";
}
// 单参构造
public Phone(String brand) {
this.brand = brand;
this.color = "黑色";
}
// 双参构造（重载）
public Phone(String brand, String color) {
this.brand = brand;
this.color = color;
}
public void show() {
System.out.println("品牌：" + brand + "，颜色：" + color);
}
}
// 测试不同构造函数
new Phone().show(); // 品牌：未知品牌，颜色：黑色
new Phone("华为").show(); // 品牌：华为，颜色：黑色
new Phone("苹果", "白色").show(); // 品牌：苹果，颜色：白色
class Phone:
# __init__ 用默认参数，模拟Java的构造函数重载
def __init__(self, brand="未知品牌", color="黑色"):
self.brand = brand
self.color = color
def show(self):
print(f"品牌：{self.brand}，颜色：{self.color}")
# 测试不同参数传入方式
Phone().show() # 品牌：未知品牌，颜色：黑色
Phone("华为").show() # 品牌：华为，颜色：黑色
Phone("苹果", "白色").show() # 品牌：苹果，颜色：白色
两者都用于对象销毁前的资源清理（如关闭文件、释放连接），但调用时机都不确定，不建议用于核心逻辑。
结合前面的对比，总结几个高频坑点，帮你快速避坑：
结合前面的知识点，用Python实现一个简单的银行账户类，对应Java的实现逻辑，帮你巩固所学。
public class BankAccount {
private String username;
private double balance;
// 类属性：利率
private static double interestRate = 0.02;
// 构造函数
public BankAccount(String username, double balance) {
this.username = username;
this.balance = balance;
}
// 存款
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
System.out.println("存款成功，当前余额：" + balance);
} else {
System.out.println("存款金额必须大于0");
}
}
// 取款
public void withdraw(double amount) {
if (amount > 0 && amount<= balance) {
balance -= amount;
System.out.println("取款成功，当前余额：" + balance);
} else {
System.out.println("取款金额无效或余额不足");
}
}
// 查看余额（getter）
public double getBalance() {
return balance;
}
// 类方法：修改利率
public static void setInterestRate(double rate) {
if (rate >= 0) {
interestRate = rate;
} else {
System.out.println("利率不能为负数");
}
}
// 静态方法：计算利息
public static double calculateInterest(double balance) {
return balance * interestRate;
}
}
// 测试
BankAccount account = new BankAccount("Java开发者", 10000);
account.deposit(5000);
account.withdraw(3000);
System.out.println("当前余额：" + account.getBalance());
BankAccount.setInterestRate(0.03);
System.out.println("年利息：" + BankAccount.calculateInterest(account.getBalance()));
class BankAccount:
# 类属性：利率
interest_rate = 0.02
def __init__(self, username, balance):
# 伪私有属性，封装用户名和余额
self.__username = username
self.__balance = balance
# 存款方法
def deposit(self, amount):
if amount > 0:
self.__balance += amount
print(f"存款成功，当前余额：{self.__balance}")
else:
print("存款金额必须大于0")
# 取款方法
def withdraw(self, amount):
if 0 < amount <= self.__balance:
self.__balance -= amount
print(f"取款成功，当前余额：{self.__balance}")
else:
print("取款金额无效或余额不足")
# @property 实现余额的getter
@property
def balance(self):
return self.__balance
# 类方法：修改利率
@classmethod
def set_interest_rate(cls, rate):
if rate >= 0:
cls.interest_rate = rate
else:
print("利率不能为负数")
# 静态方法：计算利息
@staticmethod
def calculate_interest(balance):
return balance * BankAccount.interest_rate
# 测试
account = BankAccount("Python学习者", 10000)
account.deposit(5000)
account.withdraw(3000)
print(f"当前余额：{account.balance}")
BankAccount.set_interest_rate(0.03)
print(f"年利息：{BankAccount.calculate_interest(account.balance)}")
Python的面向对象编程，本质上是“简化版的Java面向对象”——保留了核心思想，去掉了繁琐的修饰符和语法约束，更注重简洁和灵活。作为Java开发者，你不需要重新学习面向对象的思想，只需重点掌握“语法差异”和“Pythonic的实现方式”：
只要抓住这些核心差异，结合你已有的Java面向对象基础，就能快速上手Python面向对象编程，用更简洁的代码实现同样稳健的功能。多写、多练，把Java的编程思维迁移到Python中，你会发现Python的面向对象编程更高效、更灵活。
