面向对象编程（Object-Oriented Programming，简称OOP）是现代编程语言中广泛采用的一种编程范式。它通过将数据和操作数据的方法封装在一起，形成对象，从而实现代码的模块化和重用。以下是面向对象编程的核心概念，让我们一起全面回顾一下。

1. 类（Class）

类是面向对象编程中的基本构建块，它定义了对象的属性（变量）和方法（函数）。类是创建对象的蓝图，它包含了对象的所有特征和行为。

class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color

    def drive(self):
        print(f"{self.brand} is driving.")

在这个例子中，Car 类有两个属性：brand 和 color，以及一个方法 drive。

2. 对象（Object）

对象是类的实例，它具有类的所有属性和方法。每个对象都是唯一的，它们可以拥有不同的属性值。

my_car = Car("Toyota", "Red")
print(my_car.brand)  # 输出：Toyota
print(my_car.color)  # 输出：Red
my_car.drive()       # 输出：Toyota is driving.

在这个例子中，my_car 是 Car 类的一个实例，它具有 brand 和 color 属性，以及 drive 方法。

3. 继承（Inheritance）

继承是一种允许一个类继承另一个类的属性和方法的技术。子类可以继承父类的所有属性和方法，并在此基础上添加自己的属性和方法。

class ElectricCar(Car):
    def __init__(self, brand, color, battery_size):
        super().__init__(brand, color)
        self.battery_size = battery_size

    def charge(self):
        print(f"{self.brand} is charging.")

my_electric_car = ElectricCar("Tesla", "Black", "75 kWh")
print(my_electric_car.battery_size)  # 输出：75 kWh
my_electric_car.charge()            # 输出：Tesla is charging.

在这个例子中，ElectricCar 类继承自 Car 类，并添加了一个新的属性 battery_size 和一个新方法 charge。

4. 多态（Polymorphism）

多态是指同一个操作或属性在继承的不同类中具有不同的表现。它允许我们使用一个引用变量来调用不同的方法。

class Animal:
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print("Woof!")

class Cat(Animal):
    def make_sound(self):
        print("Meow!")

my_dog = Dog()
my_cat = Cat()

for animal in [my_dog, my_cat]:
    animal.make_sound()

在这个例子中，Dog 和 Cat 类都继承自 Animal 类，并实现了 make_sound 方法。我们使用一个 Animal 类型的引用变量来调用 make_sound 方法，它将根据实际对象的类型执行不同的操作。

5. 封装（Encapsulation）

封装是指将对象的属性隐藏起来，只提供公共接口来访问和修改属性。这有助于保护对象的内部状态，防止外部代码直接修改它。

class BankAccount:
    def __init__(self, balance=0):
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if self.__balance >= amount:
            self.__balance -= amount
        else:
            print("Insufficient funds.")

    def get_balance(self):
        return self.__balance

my_account = BankAccount()
my_account.deposit(100)
print(my_account.get_balance())  # 输出：100
my_account.withdraw(50)
print(my_account.get_balance())  # 输出：50

在这个例子中，BankAccount 类的 balance 属性被封装起来，只能通过 deposit、withdraw 和 get_balance 方法来访问和修改。

通过掌握这些面向对象编程的核心概念，我们可以编写出更加模块化、可重用和易于维护的代码。希望这篇文章能帮助你更好地理解面向对象编程。