在上篇中我们学会了如何定义类和创建对象将现实世界的事物用代码表示。今天我们将深入面向对象编程的三大核心特性继承、封装和多态。这些特性将让你的代码更加灵活、可扩展和易维护。一、继承代码复用的“家族传承”1. 什么是继承想象一下家族传承你继承了父母的姓氏、血型等特征你学会了父母的某些技能但也发展了自己的特长你和父母是“一家人”但有各自的特点在编程中继承允许我们创建一个新类它基于现有的类。新类自动获得现有类的所有属性和方法并可以添加或修改这些功能。继承的好处代码复用避免重复编写相同的代码扩展性可以在不修改父类的情况下扩展功能层次结构更好地组织代码结构2. 继承的基本语法class 父类: # 父类的属性和方法 pass class 子类(父类): # 在括号中指定父类 # 子类可以添加新的属性和方法 # 也可以重写父类的方法 pass3. 简单的继承示例让我们从交通工具的例子开始# 父类交通工具 class Vehicle: def __init__(self, brand, model, year): self.brand brand self.model model self.year year self.speed 0 def start(self): print(f{self.brand} {self.model} 启动了) def stop(self): self.speed 0 print(f{self.brand} {self.model} 停止了) def accelerate(self, increment): self.speed increment print(f{self.brand} {self.model} 加速到 {self.speed} km/h) # 子类汽车继承自交通工具 class Car(Vehicle): def __init__(self, brand, model, year, doors): # 调用父类的__init__方法 super().__init__(brand, model, year) # 添加子类特有的属性 self.doors doors self.fuel_level 100 # 子类特有的方法 def honk(self): print(嘟嘟) # 重写父类的方法 def start(self): super().start() # 先调用父类的start方法 print(检查安全带...) def refuel(self, amount): self.fuel_level min(100, self.fuel_level amount) print(f加油{amount}%当前油量{self.fuel_level}%) # 子类电动车继承自汽车 class ElectricCar(Car): def __init__(self, brand, model, year, doors, battery_capacity): super().__init__(brand, model, year, doors) self.battery_capacity battery_capacity self.battery_level 100 # 重写父类的方法 def start(self): print(电动车静音启动...) self.speed 0 # 电动车特有的方法 def charge(self, amount): self.battery_level min(100, self.battery_level amount) print(f充电{amount}%当前电量{self.battery_level}%) def refuel(self, amount): # 电动车不能加油 print(电动车不能加油请充电) # 使用继承 print( 普通汽车 ) my_car Car(Toyota, Camry, 2023, 4) my_car.start() my_car.accelerate(50) my_car.honk() my_car.refuel(20) my_car.stop() print(\n 电动车 ) my_electric ElectricCar(Tesla, Model 3, 2024, 4, 75) my_electric.start() my_electric.accelerate(60) my_electric.honk() # 继承了Car的honk方法 my_electric.charge(30) my_electric.refuel(20) # 会显示电动车不能加油请充电随堂练习1# 创建一个Animal动物类有name和age属性 # 有eat()和sleep()方法 # 创建Dog狗类和Cat猫类继承Animal # 添加各自特有的方法Dog有bark()Cat有meow() # 重写eat()方法狗吃骨头猫吃鱼 class Animal: def __init__(self, name, age): self.name name self.age age def eat(self): print(f{self.name}在吃东西) def sleep(self): print(f{self.name}在睡觉) class Dog(Animal): def bark(self): print(f{self.name}汪汪叫) def eat(self): print(f{self.name}在啃骨头) class Cat(Animal): def meow(self): print(f{self.name}喵喵叫) def eat(self): print(f{self.name}在吃鱼) # 测试 dog Dog(旺财, 3) cat Cat(咪咪, 2) dog.eat() # 旺财在啃骨头 dog.bark() # 旺财汪汪叫 cat.eat() # 咪咪在吃鱼 cat.meow() # 咪咪喵喵叫二、封装保护你的“隐私”1. 什么是封装封装就像你的手机你只需要知道如何操作打电话、发短信不需要知道内部电路如何工作重要的内部元件被保护起来防止意外损坏在编程中封装有两个主要目的捆绑数据和方法将相关的数据和方法组织在一起隐藏内部细节只暴露必要的接口保护数据安全2. 访问控制公有、保护和私有Python通过命名约定来实现访问控制class BankAccount: def __init__(self, owner, initial_balance): self.owner owner # 公有属性可以直接访问 self._account_number 123456 # 保护属性一个下划线开头 self.__balance initial_balance # 私有属性两个下划线开头 self.__pin 0000 # 私有属性 # 公有方法外部可以调用 def deposit(self, amount): if amount 0: self.__balance amount print(f存款成功余额{self.__balance}) else: print(存款金额必须大于0) def withdraw(self, amount, pin): if self.__verify_pin(pin): if 0 amount self.__balance: self.__balance - amount print(f取款成功余额{self.__balance}) else: print(金额无效或余额不足) else: print(PIN码错误) def get_balance(self): return self.__balance # 私有方法只能在类内部使用 def __verify_pin(self, pin): return self.__pin pin # 保护方法 def _generate_statement(self): return f账户{self._account_number}的账单 # 使用 account BankAccount(张三, 1000) # 可以访问公有属性 print(account.owner) # 张三 # 可以访问保护属性但不推荐 print(account._account_number) # 123456 # 不能直接访问私有属性 # print(account.__balance) # 报错AttributeError # 通过公有方法访问 account.deposit(500) # 存款成功余额1500 account.withdraw(200, 0000) # 取款成功余额1300 account.withdraw(200, 1111) # PIN码错误 # 通过公有方法获取余额 print(f当前余额{account.get_balance()}) # 当前余额1300重要说明公有成员可以直接访问保护成员一个下划线约定上不应该在类外部访问但技术上可以私有成员两个下划线Python会进行名称改写实际变成_类名__属性名# 实际上可以通过特殊方式访问私有属性但不推荐 print(account._BankAccount__balance) # 1300随堂练习2# 创建一个User类有username公有和__password私有属性 # 提供login()方法验证密码 # 提供change_password()方法修改密码 # 密码必须至少8位 class User: def __init__(self, username, password): self.username username self.__password password def login(self, password): if self.__password password: print(f{self.username}登录成功) return True else: print(密码错误) return False def change_password(self, old_password, new_password): if self.__password ! old_password: print(原密码错误) return False if len(new_password) 8: print(新密码必须至少8位) return False self.__password new_password print(密码修改成功) return True # 测试 user User(张三, 12345678) user.login(12345678) # 张三登录成功 user.login(11111111) # 密码错误 user.change_password(12345678, 87654321) # 密码修改成功 user.login(87654321) # 张三登录成功 user.change_password(11111111, 123) # 原密码错误三、多态同一接口多种形态1. 什么是多态多态就像同一个操作在不同对象上有不同表现按下播放按钮音乐播放器播放音乐视频播放器播放视频支付操作支付宝、微信、银行卡的支付方式不同绘图指令圆形、矩形、三角形的绘制方法不同在编程中多态允许我们使用统一的接口处理不同类型的对象。2. 多态的实现方式Python实现多态主要有两种方式方式1继承 方法重写class Shape: def area(self): 计算面积子类必须实现 pass def perimeter(self): 计算周长子类必须实现 pass class Rectangle(Shape): def __init__(self, width, height): self.width width self.height height def area(self): return self.width * self.height def perimeter(self): return 2 * (self.width self.height) def __str__(self): return f矩形(宽{self.width}, 高{self.height}) class Circle(Shape): def __init__(self, radius): self.radius radius def area(self): return 3.14159 * self.radius * self.radius def perimeter(self): return 2 * 3.14159 * self.radius def __str__(self): return f圆形(半径{self.radius}) class Triangle(Shape): def __init__(self, a, b, c): self.a a self.b b self.c c def area(self): # 使用海伦公式计算三角形面积 s (self.a self.b self.c) / 2 return (s * (s - self.a) * (s - self.b) * (s - self.c)) ** 0.5 def perimeter(self): return self.a self.b self.c def __str__(self): return f三角形(边长{self.a}, {self.b}, {self.c}) # 多态函数不关心具体形状类型 def print_shape_info(shape): print(f{shape}) print(f 面积: {shape.area():.2f}) print(f 周长: {shape.perimeter():.2f}) print() # 创建不同形状的对象 shapes [ Rectangle(4, 5), Circle(3), Triangle(3, 4, 5) ] # 统一处理所有形状 for shape in shapes: print_shape_info(shape)方式2鸭子类型Python的特色如果它走起路来像鸭子叫起来也像鸭子那么它就是鸭子class Dog: def speak(self): return 汪汪汪 def walk(self): return 用四条腿走路 class Cat: def speak(self): return 喵喵喵 def walk(self): return 优雅地走路 class Duck: def speak(self): return 嘎嘎嘎 def walk(self): return 摇摇摆摆地走路 class Robot: def speak(self): return 哔哔哔 def walk(self): return 机械地移动 # 多态函数不关心对象类型只关心是否有speak和walk方法 def introduce(entity): print(f{entity.speak()}) print(f{entity.walk()}) print() # 所有对象都可以用同一方式处理 animals [Dog(), Cat(), Duck(), Robot()] for animal in animals: introduce(animal)随堂练习3# 创建一个支付系统支持多种支付方式 # 支付宝、微信支付、银行卡 # 所有支付方式都有pay(amount)方法 # 创建购物车可以添加商品然后用任意支付方式支付 class PaymentMethod: def pay(self, amount): pass class Alipay(PaymentMethod): def __init__(self, account): self.account account def pay(self, amount): print(f支付宝支付从账户{self.account}支付{amount}元) return True class WechatPay(PaymentMethod): def __init__(self, openid): self.openid openid def pay(self, amount): print(f微信支付从账户{self.openid}支付{amount}元) return True class BankCard(PaymentMethod): def __init__(self, card_number): self.card_number card_number def pay(self, amount): print(f银行卡支付从卡号{self.card_number[-4:]}支付{amount}元) return True class ShoppingCart: def __init__(self): self.items [] self.total 0 def add_item(self, item, price): self.items.append((item, price)) self.total price print(f添加商品{item}价格{price}元) def checkout(self, payment_method): print(f\n购物车总价{self.total}元) print(商品列表) for item, price in self.items: print(f {item}: {price}元) # 多态不关心具体支付方式 if payment_method.pay(self.total): print(支付成功) self.items [] self.total 0 else: print(支付失败) # 测试 cart ShoppingCart() cart.add_item(手机, 2999) cart.add_item(耳机, 399) alipay Alipay(zhangsanalipay.com) wechat WechatPay(wxid_zhangsan) card BankCard(6217********1234) print(\n使用支付宝支付) cart.checkout(alipay) print(\n重新添加商品使用微信支付) cart.add_item(书籍, 89) cart.checkout(wechat) print(\n重新添加商品使用银行卡支付) cart.add_item(衣服, 299) cart.checkout(card)四、类方法和静态方法1. 类方法类方法是属于类的方法而不是实例。它可以访问和修改类属性。class Student: # 类属性 school 北京大学 total_students 0 def __init__(self, name, age): self.name name self.age age Student.total_students 1 # 实例方法 def introduce(self): print(f我叫{self.name}今年{self.age}岁就读于{self.school}) # 类方法 classmethod def get_total_students(cls): return cls.total_students classmethod def change_school(cls, new_school): cls.school new_school print(f学校已改为{new_school}) classmethod def create_from_string(cls, student_str): 从字符串创建学生对象格式姓名,年龄 name, age student_str.split(,) return cls(name, int(age)) # 使用 student1 Student(张三, 20) student2 Student(李四, 21) # 调用实例方法 student1.introduce() # 我叫张三今年20岁就读于北京大学 # 调用类方法 print(f学生总数{Student.get_total_students()}) # 学生总数2 # 修改类属性 Student.change_school(清华大学) student1.introduce() # 我叫张三今年20岁就读于清华大学 # 使用类方法创建对象 student3 Student.create_from_string(王五,19) student3.introduce() # 我叫王五今年19岁就读于清华大学2. 静态方法静态方法与类和实例都没有直接关系就像普通函数但逻辑上属于这个类。class MathUtils: # 静态方法 staticmethod def add(a, b): return a b staticmethod def multiply(a, b): return a * b staticmethod def is_prime(n): 判断是否为质数 if n 2: return False for i in range(2, int(n**0.5) 1): if n % i 0: return False return True staticmethod def factorial(n): 计算阶乘 result 1 for i in range(1, n 1): result * i return result # 使用静态方法 print(f3 5 {MathUtils.add(3, 5)}) # 3 5 8 print(f4 × 6 {MathUtils.multiply(4, 6)}) # 4 × 6 24 print(f7是质数吗{MathUtils.is_prime(7)}) # 7是质数吗True print(f5! {MathUtils.factorial(5)}) # 5! 120 # 也可以通过实例调用 utils MathUtils() print(utils.add(2, 3)) # 5五、综合案例员工管理系统让我们用一个完整的员工管理系统来综合运用所有概念class Employee: 员工基类 # 类属性 total_employees 0 company ABC科技有限公司 def __init__(self, name, employee_id, salary): self.name name self.employee_id employee_id self.__salary salary # 私有属性 self.__performance 良好 # 私有属性 Employee.total_employees 1 def work(self): print(f{self.name}正在工作) def get_salary(self): return self.__salary def set_salary(self, new_salary): if new_salary 0: self.__salary new_salary print(f{self.name}的工资已调整为{new_salary}) else: print(工资必须大于0) def get_performance(self): return self.__performance def set_performance(self, performance): if performance in [优秀, 良好, 一般, 差]: self.__performance performance else: print(绩效评价必须是优秀、良好、一般、差) def calculate_bonus(self): 计算奖金子类可以重写 if self.__performance 优秀: return self.__salary * 0.3 elif self.__performance 良好: return self.__salary * 0.2 elif self.__performance 一般: return self.__salary * 0.1 else: return 0 def introduce(self): print(f我叫{self.name}工号{self.employee_id}) classmethod def get_company_info(cls): return f{cls.company}员工总数{cls.total_employees} class Developer(Employee): 开发人员 def __init__(self, name, employee_id, salary, programming_language): super().__init__(name, employee_id, salary) self.programming_language programming_language self.__lines_of_code 0 # 私有属性 def work(self): print(f{self.name}正在用{self.programming_language}编写代码) def write_code(self, lines): self.__lines_of_code lines print(f{self.name}写了{lines}行代码总计{self.__lines_of_code}行) def debug(self): print(f{self.name}正在调试{self.programming_language}代码) def get_lines_of_code(self): return self.__lines_of_code def introduce(self): super().introduce() print(f我是一名{self.programming_language}开发工程师) class Manager(Employee): 经理 def __init__(self, name, employee_id, salary, department): super().__init__(name, employee_id, salary) self.department department self.team [] def work(self): print(f{self.name}正在管理{self.department}部门) def add_team_member(self, employee): self.team.append(employee) print(f{employee.name}已加入{self.department}团队) def conduct_meeting(self): print(f{self.name}正在召开{self.department}部门会议) print(f参会人员{, .join([e.name for e in self.team])}) def evaluate_team(self): print(f{self.name}正在评估团队绩效) for employee in self.team: print(f {employee.name}{employee.get_performance()}) def calculate_bonus(self): 经理的奖金包括团队绩效 base_bonus super().calculate_bonus() team_bonus len(self.team) * 1000 return base_bonus team_bonus def introduce(self): super().introduce() print(f我是{department}部门经理管理{len(self.team)}名员工) class Salesperson(Employee): 销售人员 def __init__(self, name, employee_id, salary, sales_target): super().__init__(name, employee_id, salary) self.sales_target sales_target self.__sales_amount 0 # 私有属性 def work(self): print(f{self.name}正在拜访客户销售目标{self.sales_target}) def make_sale(self, amount): self.__sales_amount amount print(f{self.name}完成一笔销售金额{amount}累计{self.__sales_amount}) def get_sales_amount(self): return self.__sales_amount def calculate_bonus(self): 销售人员的奖金基于销售额 base_bonus super().calculate_bonus() if self.__sales_amount self.sales_target: sales_bonus self.__sales_amount * 0.1 else: sales_bonus self.__sales_amount * 0.05 return base_bonus sales_bonus def introduce(self): super().introduce() print(f我是一名销售人员销售目标{self.sales_target}) # 测试员工管理系统 def test_employee_system(): print( 员工管理系统测试 \n) # 创建员工 dev1 Developer(张三, DEV001, 15000, Python) dev2 Developer(李四, DEV002, 14000, Java) manager Manager(王经理, MGR001, 25000, 技术部) sales Salesperson(赵销售, SALES001, 12000, 100000) # 设置绩效 dev1.set_performance(优秀) dev2.set_performance(良好) manager.set_performance(优秀) sales.set_performance(良好) # 经理组建团队 manager.add_team_member(dev1) manager.add_team_member(dev2) # 销售人员完成销售 sales.make_sale(30000) sales.make_sale(50000) sales.make_sale(30000) # 总计110000超过目标 # 开发人员工作 dev1.write_code(200) dev1.write_code(150) dev2.write_code(180) dev2.debug() # 经理工作 manager.conduct_meeting() manager.evaluate_team() # 多态统一处理所有员工 print(\n 员工信息 ) employees [dev1, dev2, manager, sales] for emp in employees: print(f\n{emp.name}:) emp.work() emp.introduce() print(f工资: {emp.get_salary()}) print(f绩效: {emp.get_performance()}) print(f奖金: {emp.calculate_bonus():.2f}) # 调用特定类型的方法 if isinstance(emp, Developer): print(f代码行数: {emp.get_lines_of_code()}) elif isinstance(emp, Manager): print(f团队人数: {len(emp.team)}) elif isinstance(emp, Salesperson): print(f销售额: {emp.get_sales_amount()}) # 类方法 print(f\n 公司信息 ) print(Employee.get_company_info()) # 运行测试 if __name__ __main__: test_employee_system()六、面向对象设计原则1. 单一职责原则一个类应该只有一个引起变化的原因。换句话说一个类应该只负责一项职责。2. 开放封闭原则软件实体应该对扩展开放对修改关闭。可以通过继承和组合来扩展功能而不是修改原有代码。3. 里氏替换原则子类必须能够替换它们的父类而不影响程序的正确性。4. 依赖倒置原则高层模块不应该依赖低层模块二者都应该依赖抽象。抽象不应该依赖细节细节应该依赖抽象。5. 接口隔离原则客户端不应该被迫依赖它不使用的方法。一个类对另一个类的依赖应该建立在最小的接口上。七、总结在面向对象编程下篇中我们深入学习了三大核心特性1. 继承子类继承父类的属性和方法使用super()调用父类方法子类可以添加新的属性和方法也可以重写父类方法支持多级继承2. 封装将数据和方法捆绑在一起通过访问控制隐藏内部细节公有成员、保护成员、私有成员的区别提供公有方法访问私有属性3. 多态同一接口不同实现通过继承和方法重写实现Python的鸭子类型特性提高代码的灵活性和可扩展性4. 类方法和静态方法类方法属于类可以访问和修改类属性静态方法与类和实例都无关就像普通函数使用classmethod和staticmethod装饰器5. 面向对象设计原则单一职责、开放封闭、里氏替换、依赖倒置、接口隔离学习建议从简单的类开始逐渐添加功能优先使用组合而不是继承合理使用封装保护重要数据利用多态提高代码灵活性遵循设计原则但不要过度设计实践是最好的老师尝试用面向对象的方式重构你以前写过的程序或者设计新的项目。随着实践的增加你会越来越熟练地运用这些概念。扩展练习设计一个简单的图书馆管理系统包含图书、借阅者、管理员等类运用继承、封装和多态。现在你已经掌握了面向对象编程的核心概念。继续练习将这些概念应用到实际项目中你会成为更优秀的程序员