python基础之面向对象

面向对象

面向对象（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 方法。尽管调用方式相同，但由于多态性，实际执行的是各自类中定义的方法，体现了“一个接口，多种实现”。