09-面向对象编程（OOP）

第9节 面向对象编程（OOP）

在这一节中，我们将深入探讨 Python 中的面向对象编程（Object-Oriented Programming, OOP）。面向对象编程是一种编程范式，它使用“对象”来设计软件。对象是类的实例，而类则是对象的蓝图。我们将学习如何定义类、创建对象、继承、多态等面向对象编程的核心概念。

9.1 类和对象

类是对象的蓝图，定义了对象的属性和方法。对象是类的实例，具有类定义的属性和方法。

定义类：

class ClassName:
    def __init__(self, param1, param2):
        self.param1 = param1
        self.param2 = param2
    
    def method1(self):
        # 方法体
        pass
    
    def method2(self, arg1):
        # 方法体
        pass

创建对象：

obj = ClassName(value1, value2)

示例：

1. 定义一个简单的类 Person：

   class Person:
       def __init__(self, name, age):
           self.name = name
           self.age = age
   
       def greet(self):
           print(f"Hello, my name is {self.name} and I am {self.age} years old.")

2. 创建 Person 对象并调用方法：

   person1 = Person("Alice", 25)
   person1.greet()  # 输出: Hello, my name is Alice and I am 25 years old.

9.2 类属性和实例属性

• 类属性：在类中定义但在方法之外，属于类本身，所有实例共享。
• 实例属性：在 __init__ 方法中定义，属于每个实例，每个实例都有自己的副本。

示例：

1. 定义类属性和实例属性：

   class Person:
       species = "Homo sapiens"  # 类属性
   
       def __init__(self, name, age):
           self.name = name  # 实例属性
           self.age = age  # 实例属性
   
       def greet(self):
           print(f"Hello, my name is {self.name} and I am {self.age} years old.")
   
       @classmethod
       def get_species(cls):
           return cls.species
   
       @staticmethod
       def is_adult(age):
           return age >= 18

2. 访问类属性和实例属性：

   person1 = Person("Alice", 25)
   person2 = Person("Bob", 30)
   
   print(person1.species)  # 输出: Homo sapiens
   print(person2.species)  # 输出: Homo sapiens
   
   print(Person.get_species())  # 输出: Homo sapiens
   
   print(Person.is_adult(25))  # 输出: True
   print(Person.is_adult(15))  # 输出: False

9.3 继承

继承允许我们定义一个类（子类）继承另一个类（父类）的属性和方法。子类可以重写或扩展父类的方法。

基本语法：

class SubClass(BaseClass):
    def __init__(self, param1, param2):
        super().__init__(param1)
        self.param2 = param2

    def new_method(self):
        # 新方法
        pass

    def overridden_method(self):
        # 重写父类方法
        pass

示例：

1. 定义父类 Animal 和子类 Dog：

   class Animal:
       def __init__(self, name):
           self.name = name
   
       def speak(self):
           raise NotImplementedError("Subclass must implement this method")
   
   class Dog(Animal):
       def __init__(self, name, breed):
           super().__init__(name)
           self.breed = breed
   
       def speak(self):
           return f"{self.name} says Woof!"

2. 创建 Dog 对象并调用方法：

   dog1 = Dog("Buddy", "Golden Retriever")
   print(dog1.speak())  # 输出: Buddy says Woof!

9.4 多态

多态是指不同类的对象对同一消息作出不同的响应。在 Python 中，多态主要通过方法重写和鸭子类型（Duck Typing）实现。

示例：

1. 定义多个类并实现相同的方法：

   class Cat:
       def speak(self):
           return f"Meow!"
   
   class Duck:
       def speak(self):
           return f"Quack!"

2. 使用多态：

   def make_animal_speak(animal):
       print(animal.speak())
   
   cat1 = Cat()
   duck1 = Duck()
   
   make_animal_speak(cat1)  # 输出: Meow!
   make_animal_speak(duck1)  # 输出: Quack!

9.5 特殊方法

特殊方法（也称为魔术方法或双下划线方法）是在类中定义的一些特殊方法，它们有特定的用途，如 __init__、__str__、__repr__ 等。

常见特殊方法：

• __init__(self, ...): 构造函数，用于初始化对象。
• __str__(self): 返回对象的字符串表示，用于 print 和 str。
• __repr__(self): 返回对象的“官方”字符串表示，用于 repr。
• __len__(self): 返回对象的长度。
• __getitem__(self, key): 获取对象的某个元素。
• __setitem__(self, key, value): 设置对象的某个元素。
• __delitem__(self, key): 删除对象的某个元素。

示例：

1. 定义一个类并实现特殊方法：

   class MyList:
       def __init__(self, initial_data):
           self.data = initial_data
   
       def __str__(self):
           return str(self.data)
   
       def __repr__(self):
           return f"MyList({self.data})"
   
       def __len__(self):
           return len(self.data)
   
       def __getitem__(self, index):
           return self.data[index]
   
       def __setitem__(self, index, value):
           self.data[index] = value
   
       def __delitem__(self, index):
           del self.data[index]

2. 使用特殊方法：

   my_list = MyList([1, 2, 3, 4])
   
   print(my_list)  # 输出: [1, 2, 3, 4]
   print(repr(my_list))  # 输出: MyList([1, 2, 3, 4])
   
   print(len(my_list))  # 输出: 4
   
   print(my_list[1])  # 输出: 2
   my_list[1] = 10
   print(my_list)  # 输出: [1, 10, 3, 4]
   
   del my_list[1]
   print(my_list)  # 输出: [1, 3, 4]

小结

通过本节的学习，你应该已经掌握了 Python 中面向对象编程的基本概念和用法，包括类和对象、类属性和实例属性、继承、多态以及特殊方法。面向对象编程是一种强大的编程范式，能够帮助你编写更模块化、更易维护的程序。下一节我们将继续学习 Python 中的高级主题。

本文由mdnice多平台发布