Python学习（8）理解面向对象编程的基本概念

面向对象编程（OOP）是一种编程范式，它使用“对象”来设计软件。在OOP中，对象是类的实例，而类定义了对象的属性和行为。OOP的核心概念包括类、对象、继承、封装和多态。下面我将通过示例来介绍这些概念。

1. 类和对象

类（Class）：类是对象的蓝图或模板，定义了对象的属性和方法。

对象（Object）：对象是类的实例，具有类定义的属性和方法。

class Dog:
    # 类属性
    species = "Canis familiaris"

    # 初始化方法（构造函数）
    def __init__(self, name, age):
        # 实例属性
        self.name = name
        self.age = age

    # 方法
    def bark(self):
        return f"{self.name} says Woof!"

# 创建对象
my_dog = Dog("Buddy", 3)

print(my_dog.name)  # 输出: Buddy
print(my_dog.age)   # 输出: 3
print(my_dog.bark())  # 输出: Buddy says Woof!
print(Dog.species)  # 输出: Canis familiaris

解释：

• Dog是一个类，具有类属性species。
• __init__方法是构造函数，用于初始化对象的实例属性。
• bark是Dog类的一个方法，定义了对象的行为。
• my_dog是Dog类的一个实例（对象）。

2. 继承

继承（Inheritance）：允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码复用。

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.speak())  # 输出: Buddy says Woof!
print(cat.speak())  # 输出: Whiskers says Meow!

解释：

• Animal是一个基类，定义了一个抽象方法speak。
• Dog和Cat是Animal的子类，它们实现了speak方法。
• 子类继承了父类的属性和方法，并可以重写父类的方法。

3. 封装

封装（Encapsulation）：将对象的属性和方法组合在一起，并隐藏对象的内部实现细节，只对外提供公共的访问方式。

class Person:
    def __init__(self, name, age):
        self.__name = name  # 私有属性
        self.__age = age    # 私有属性

    def get_name(self):
        return self.__name

    def set_age(self, age):
        if age > 0:
            self.__age = age
        else:
            print("Age must be positive!")

    def display(self):
        print(f"Name: {self.__name}, Age: {self.__age}")

person = Person("Alice", 30)
print(person.get_name())  # 输出: Alice
person.set_age(25)
person.display()          # 输出: Name: Alice, Age: 25
person.set_age(-5)        # 输出: Age must be positive!

解释：

• __name和__age是私有属性，不能直接从类外部访问。
• get_name和set_age方法提供了对私有属性的受控访问。

4. 多态

多态（Polymorphism）：允许不同类的对象对同一消息做出响应，并根据对象类型执行不同的操作。

class Shape:
    def area(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

shapes = [Rectangle(3, 4), Circle(5)]

for shape in shapes:
    print(f"Area: {shape.area()}")

解释：

• Shape是一个基类，定义了一个抽象方法area。
• Rectangle和Circle是Shape的子类，它们实现了area方法。
• 多态性允许我们使用Shape类型的列表来存储不同的形状对象，并调用它们的area方法。

总结

• 类和对象：类是对象的蓝图，对象是类的实例。
• 继承：子类继承父类的属性和方法，实现代码复用。
• 封装：隐藏对象的内部实现细节，提供公共访问方式。
• 多态：允许不同类的对象对同一消息做出响应，执行不同的操作。