Skip to main content

面向对象

1. 面向对象编程的基本概念（掌握）

面向对象编程（OOP）是一种编程范式，它将数据和操作数据的方法封装在一起，称之为对象。Python 是一门面向对象语言，OOP 中的关键概念有以下几个：

  • 类（Class）：类是创建对象的模板或蓝图，它定义了对象的属性和方法。
  • 对象（Object）：对象是类的实例，通过类来创建。
  • 属性（Attribute）：属性是对象的特征或数据，通常是类中定义的变量。
  • 方法（Method）：方法是对象的行为或操作，通常是类中定义的函数。

示例：定义一个简单的类

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

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

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

# 创建对象
my_dog = Dog("Buddy", 3)
print(my_dog.name)  # 输出: Buddy
my_dog.bark()       # 输出: Buddy says Woof!

2. 类的定义和实例化（掌握）

在 Python 中，使用 class 关键字定义类，类名通常遵循首字母大写的命名约定。定义完类后，通过调用类名并传入必要的参数来创建类的实例（即对象）。

  • 定义类：

    class ClassName:
    # 类的内容（属性和方法）

  • 实例化对象：

    object_name = ClassName(parameters)

示例

class Car:
    def __init__(self, make, model):
        self.make = make  # 实例属性
        self.model = model

my_car = Car("Toyota", "Corolla")
print(my_car.make)  # 输出: Toyota
print(my_car.model) # 输出: Corolla

3. __init__ 方法（构造函数）（掌握）

__init__ 方法是类的构造函数，在创建对象时自动调用，用于初始化对象的属性。它通常接收参数来为属性赋初始值。

  • 定义 __init__ 方法：

    def __init__(self, 参数1, 参数2):
    self.属性1 = 参数1
    self.属性2 = 参数2

示例

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

my_book = Book("1984", "George Orwell")
print(my_book.title)  # 输出: 1984
print(my_book.author) # 输出: George Orwell

4. 实例属性和类属性（掌握）

  • 实例属性：每个对象独立拥有的属性，由 self 关键字定义。实例属性在不同的对象中可以拥有不同的值。
  • 类属性：类本身的属性，不属于任何一个特定的对象，由类名直接访问。类属性在所有对象中共享。

示例

class Animal:
    species = "Mammal"  # 类属性

    def __init__(self, name):
        self.name = name  # 实例属性

a1 = Animal("Lion")
a2 = Animal("Tiger")

print(a1.species)  # 输出: Mammal
print(a2.species)  # 输出: Mammal
print(a1.name)     # 输出: Lion
print(a2.name)     # 输出: Tiger

5. 实例方法和类方法（掌握）

  • 实例方法：实例方法是作用于对象的方法，第一个参数为 self，表示该方法属于对象，可以访问对象的属性。
  • 类方法：类方法由 @classmethod 装饰器定义，第一个参数为 cls，表示该方法属于类，可以访问类属性。类方法通常用于创建或操作类级别的数据。

示例

class Circle:
    pi = 3.14  # 类属性

    def __init__(self, radius):
        self.radius = radius  # 实例属性

    def area(self):  # 实例方法
        return Circle.pi * (self.radius ** 2)

    @classmethod
    def set_pi(cls, new_pi):  # 类方法
        cls.pi = new_pi

c1 = Circle(5)
print(c1.area())  # 输出: 78.5

Circle.set_pi(3.1416)
print(c1.area())  # 输出: 78.54（使用新值 3.1416）

6. 静态方法（掌握）

静态方法不需要传入 self 或 cls 参数，通常不与类或对象的属性进行交互，常用于工具方法。使用 @staticmethod 装饰器定义静态方法。

示例

class Math:
    @staticmethod
    def add(x, y):
        return x + y

result = Math.add(5, 3)
print(result)  # 输出: 8

7. 封装与私有属性（掌握）

封装是 OOP 的核心思想之一，通过将对象的内部数据隐藏起来，只允许通过特定方法访问。Python 使用双下划线前缀 __ 将属性定义为私有属性，限制外部直接访问。

示例

class Account:
    def __init__(self, owner, balance):
        self.owner = owner
        self.__balance = balance  # 私有属性

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

    def get_balance(self):
        return self.__balance

account = Account("Alice", 1000)
account.deposit(500)
print(account.get_balance())  # 输出: 1500
# print(account.__balance)  # 访问报错，私有属性

8. 继承（掌握）

继承允许我们创建一个新的类，并从现有类中继承属性和方法。继承使代码重用更高效，新类称为子类，继承的类称为父类或超类。

示例

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):  # Dog 类继承 Animal 类
    def bark(self):
        print("Dog barks")

dog = Dog()
dog.speak()  # 调用父类方法，输出: Animal speaks
dog.bark()   # 调用子类方法，输出: Dog barks

9. 方法重写（掌握）

方法重写（Override）允许子类重写父类的方法。子类重写的方法可以覆盖父类的方法，实现不同的功能。

示例

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):  # 重写父类方法
        print("Dog barks")

dog = Dog()
dog.speak()  # 输出: Dog barks

10. 多态（掌握）

多态是指对象在不同的场景中表现出不同的行为。Python 的多态性允许使用相同的方法名调用不同类的实例，而不关心实例的具体类型。

示例

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Dog barks")

class Cat(Animal):
    def speak(self):
        print("Cat meows")

animals = [Dog(), Cat()]

for animal in animals:
    animal.speak()  # 输出 Dog barks 和 Cat meows

11. 面向对象的优势（了解）

  1. 封装：将数据和行为封装在一起，提高代码安全性。
  2. 继承：实现代码重用，减少重复代码。
  3. 多态：同一方法在不同对象中表现出不同的行为，提高代码的灵活性。
  4. 抽象：隐藏复杂实现，暴露简单接口，提高代码的可维护性。
No Comments
Back to top