面向对象
面向对象（Object-Oriented Programming，简称OOP）是一种程序设计范式，它以“对象”为核心，将现实世界中的实体抽象为软件系统中的对象，通过对象之间的相互协作来实现复杂的功能。
特性:
对象（Object）与类：
对象（Object）：
对象是面向对象编程的基本单元，是对现实世界中实体的抽象。
类（Class）：
类是对象的模板或蓝图，它定义了一组共享相同属性和方法的对象的共同特征。通过创建类的实例（即对象），可以生成具有相同结构和行为的多个对象。类还可以通过继承机制实现代码复用。
class Car:
def __init__(self, make, model, color):
self.make = make
self.model = model
self.color = color
self.speed = 0
def accelerate(self, increment):
self.speed += increment
print(f"{self.make} {self.model} is now going at {self.speed} km/h.")
def brake(self, decrement):
self.speed -= decrement
if self.speed < 0:
self.speed = 0
print(f"{self.make} {self.model} slowed down to {self.speed} km/h.")
# 创建一个Car对象实例
my_car = Car("Toyota", "Corolla", "Silver")
# 调用对象的方法
my_car.accelerate(50)
my_car.brake(30)
`Car` 是一个类，它定义了汽车对象共有的属性（`make`、`model`、`color`、`speed`）和方法（`accelerate`、`brake`）。
`__init__` 是一个特殊方法（构造函数），当创建类的实例时自动调用，用于初始化对象的属性。
`my_car` 是 `Car` 类的一个实例（对象），具有指定的制造商、型号、颜色和初始速度为0
封装（Encapsulation）：
封装是指将对象的属性和方法封装在类内部，对外提供有限的接口（通常是方法）供其他对象访问。这样可以隐藏对象内部的复杂细节，保护数据安全，同时降低不同部分之间的耦合度。通过访问修饰符（如Python中的public、private等）控制属性和方法的可见性。
class Account:
def __init__(self, balance=0):
self.__balance = balance # 使用双下划线（__）标记为私有属性
def deposit(self, amount):
self.__balance += amount
print(f"存入金额: {amount}. 现金额: {self.__balance}")
def withdraw(self, amount):
if amount <= self.__balance:
self.__balance -= amount
print(f"取出金额: {amount}. 现金额: {self.__balance}")
else:
print("Insufficient funds.")
# 创建一个Account对象实例
my_account = Account(1000)
# 公开方法可以访问私有属性
my_account.deposit(int(input("请输入存入金额:")))
my_account.withdraw(int(input("请输入取出金额:")))
# 直接访问私有属性会引发错误
# my_account.__balance = 900 # AttributeError: 'Account' object has no attribute '__balance'
__balance 是一个私有属性，使用双下划线前缀使其在外部无法直接访问，实现了封装。
公开方法 deposit 和 withdraw 提供了对私有属性的受控访问，确保了账户余额操作的安全性。
继承（Inheritance）：
继承允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。子类可以扩展或覆盖父类的行为，从而形成一个类的层次结构。继承有助于代码复用，减少冗余，并能体现类与类之间的“is-a”关系。例如，可以定义一个Vehicle基类，然后让Car、Truck等子类继承自Vehicle。
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
raise NotImplementedError("子类必须实现'speak()'方法。")
class Dog(Animal):
def speak(self):
return f"{self.name} 狗叫."
class Cat(Animal):
def speak(self):
return f"{self.name} 猫叫."
# 创建子类对象并调用继承的方法
my_dog = Dog("Buddy")
print(my_dog.speak()) # Buddy barks.
my_cat = Cat("Whiskers")
print(my_cat.speak()) # Whiskers meows.
Animal 是一个基类，定义了一个通用的 speak 方法，但并未给出具体实现，而是抛出 NotImplementedError 强制子类去实现。
Dog 和 Cat 分别继承自 Animal 类，实现了各自的 speak 方法，体现了动物叫声的差异。
创建 Dog 和 Cat 的实例后，可以直接调用从基类继承来的 speak 方法
多态（Polymorphism）：
多态是指同一消息（即方法调用）作用于不同对象时产生不同的行为。有两种常见的多态形式：静态多态（通过函数重载或运算符重载实现）和动态多态（通过虚函数、接口或鸭子类型实现）。动态多态是面向对象的重要特性，它允许程序在运行时根据对象的实际类型确定应执行的方法，增强了代码的灵活性和可扩展性
class Shape:
def area(self):
raise NotImplementedError("子类必须实现'area()'方法。")
class Square(Shape):
def __init__(self, side):
self.side = side
def area(self):
return self.side ** 2
class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
import math
return math.pi * (self.radius ** 2)
shapes = [Square(5), Circle(4)]
for shape in shapes:
print(f"{shape.__class__.__name__.lower()}的面积为:{shape.area()}.")
Shape 是一个抽象基类，定义了 area 方法但未给出具体实现，要求子类提供。
Square 和 Circle 分别继承自 Shape，各自实现了 area 方法，计算矩形和圆形的面积。
将 Square 和 Circle 实例放入一个列表中，通过循环调用它们的 area 方法。尽管调用方式相同，但由于多态性，实际执行的是各自类中定义的方法，体现了“一个接口，多种实现”。
