Python面向对象编程Class的应用场景

发布时间：2023-05-12

面向对象编程（Object-Oriented Programming, OOP）

是一种编程范式，它使用基于对象的方式来组织代码。Python 的面向对象编程可以使用 Class 来实现。Class 是 Python 中面向对象编程的核心，它可以实现面向对象编程中的封装、继承和多态等特性。

一、创建 Class

要定义一个 Class，可以使用 class 关键字。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

以上代码定义了一个名为 Person 的 Class，该 Class 有两个属性：name 和 age。__init__ 方法是 Class 的构造函数，当创建 Class 对象时会自动调用该方法，self 参数代表对象本身。可以通过如下代码创建一个 Person 对象：

person = Person("Jack", 30)
print(person.name)  # 输出 Jack
print(person.age)  # 输出 30

该代码会创建一个名为 person 的对象，同时输出 person 对象的 name 和 age 属性。

二、继承与多态

继承是指新的 Class 可以基于现有 Class 创建。Python 支持单继承和多重继承。 在继承时，新的 Class 被称为子类（Subclass），已有 Class 被称为父类（Superclass）。子类会自动继承父类的属性和方法，并且可以重写、添加或删除这些属性和方法。

class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade
    def study(self):
        print(self.name, "is studying in grade", self.grade)
student = Student("Tom", 18, 12)
print(student.name)  # 输出 Tom
print(student.age)  # 输出 18
print(student.grade)  # 输出 12
student.study()  # 输出 Tom is studying in grade 12

以上代码定义了一个名为 Student 的子类，该子类继承了 Person 父类的 name 和 age 属性，并添加了一个 grade 属性和 study 方法。可以通过如下代码创建一个 Student 对象： 该代码会创建一个名为 student 的对象，输出 student 对象的 name、age 和 grade 属性，同时调用 student 对象的 study 方法。 多态是指在继承关系中，子类可以使用父类定义的方法，但是可以自己定义该方法的实现，也可以使用父类已定义的方法实现。这样，在不同的情况下，子类可以使用自己的方法实现，父类方法的实现也可以被使用。

三、封装

封装是指把代码和数据包装在一起，以便于隐藏内部实现细节。Python 中，可以使用公开、私有和受保护的访问修饰符来实现封装。 公开访问修饰符用于定义公共属性和方法，可以通过 Class 的对象来访问它们。

class Car:
    def __init__(self, color):
        self.color = color
    def start(self):
        print("The car is starting...")
car = Car("red")
print(car.color)  # 输出 red
car.start()  # 输出 The car is starting...

以上代码定义了一个名为 Car 的 Class，该 Class 有一个公共属性 color 和一个公共方法 start。可以通过如下代码创建一个 Car 对象： 该代码会创建一个名为 car 的对象，输出 car 对象的 color 属性，并调用 car 对象的 start 方法。 私有访问修饰符用于定义私有属性和方法，可以在 Class 内部访问它们，但是无法在 Class 的外部访问它们。

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance
    def deposit(self, amount):
        self.__balance += amount
    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Not enough balance")
account = BankAccount(1000)
account.deposit(500)
account.withdraw(2000)  # 不足 2000 的余额，将输出 Not enough balance

以上代码定义了一个名为 BankAccount 的 Class，该 Class 有一个私有属性 balance，以及两个公共方法 deposit 和 withdraw。私有属性 balance 可以通过双下划线加变量名的方式定义。 可以通过如下代码创建一个 BankAccount 对象，并分别调用它的 deposit 和 withdraw 方法。由于 balance 属性是私有的，无法在 Class 的外部直接访问该属性。 受保护访问修饰符用于定义受保护的属性和方法，可以在 Class 及其子类中访问它们，但是无法在 Class 的外部访问它们。

class Animal:
    def __init__(self, name, species):
        self._name = name
        self._species = species
    def _eat(self):
        print(self._name, "is eating...")
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name, "Dog")
        self._breed = breed
    def bark(self):
        print(self._name, "is barking...")
dog = Dog("Charlie", "Golden Retriever")
dog.bark()  # 输出 Charlie is barking...
dog._eat()  # 输出 Charlie is eating...

以上代码定义了一个名为 Animal 的 Class 和一个名为 Dog 的子类。Animal Class 有两个受保护的属性 _name 和 _species，以及一个受保护的方法 _eat。Dog Class 继承了 Animal Class，并添加了一个受保护的属性 _breed 和一个公共方法 bark。在子类中可以通过 self._name 访问父类的受保护属性 _name，输出 dog 对象的 name 属性，同时调用 dog 对象的 bark 和 _eat 方法。

推荐文章