Python的秘密基地--[章节4] 面向对象编程（OOP）-优快云博客

本文链接：https://blog.youkuaiyun.com/Hellc007/article/details/144291948

第4章：面向对象编程（OOP）

面向对象编程是一种通过“对象”来组织代码的编程范式。在Python中，几乎所有的东西都是对象。理解OOP可以帮助我们更好地设计模块化和可复用的代码。

4.1 什么是面向对象编程

面向对象编程基于以下核心概念：

类（Class）：定义对象的模板或蓝图。
对象（Object）：类的实例，具有特定的属性和行为。
封装（Encapsulation）：通过类把属性和方法绑定在一起。
继承（Inheritance）：子类继承父类的属性和方法。
多态（Polymorphism）：同一个接口实现不同的功能。

4.2 定义类和创建对象

4.2.1 定义类

使用 class 关键字定义类。

# 定义一个简单的类
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        return f"Hello, my name is {self.name} and I am {self.age} years old."

4.2.2 创建对象

通过调用类来创建对象。

# 创建类的实例
person = Person("Alice", 30)
print(person.greet())  # 输出: Hello, my name is Alice and I am 30 years old.

4.3 类的属性和方法

4.3.1 实例属性

实例属性是与对象绑定的变量，每个对象都有自己独立的属性值。

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

car1 = Car("Toyota", "Corolla")
car2 = Car("Honda", "Civic")
print(car1.brand)  # 输出: Toyota
print(car2.model)  # 输出: Civic

4.3.2 类属性

类属性是与类绑定的变量，所有实例共享同一个值。

class Car:
    wheels = 4  # 类属性

    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

car1 = Car("Toyota", "Corolla")
car2 = Car("Honda", "Civic")
print(car1.wheels)  # 输出: 4
print(car2.wheels)  # 输出: 4

4.3.3 方法

方法是定义在类中的函数。分为以下几种：

类型	特点	示例
实例方法	通过对象调用，至少包含 `self` 参数	`def greet(self):`
类方法	通过类调用，至少包含 `cls` 参数	`@classmethod def from_string(cls):`
静态方法	无需默认参数，既可以通过类调用也可以通过对象调用	`@staticmethod def utility():`

class Example:
    class_var = "I am a class variable"

    def instance_method(self):
        return "I am an instance method"

    @classmethod
    def class_method(cls):
        return f"Accessing {cls.class_var} from a class method"

    @staticmethod
    def static_method():
        return "I am a static method"

obj = Example()
print(obj.instance_method())   # 输出: I am an instance method
print(Example.class_method())  # 输出: Accessing I am a class variable from a class method
print(Example.static_method()) # 输出: I am a static method

4.4 继承

4.4.1 基本继承

继承是指一个类（子类）继承另一个类（父类）的属性和方法。

class Animal:
    def speak(self):
        return "I am an animal"

class Dog(Animal):
    def speak(self):
        return "Woof! Woof!"

dog = Dog()
print(dog.speak())  # 输出: Woof! Woof!

4.4.2 使用 `super()`

super() 用于调用父类的方法。

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

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

dog = Dog("Buddy", "Golden Retriever")
print(dog.name)  # 输出: Buddy
print(dog.breed) # 输出: Golden Retriever

4.5 多态

多态允许不同类的对象以相同的方式调用方法。

class Cat:
    def speak(self):
        return "Meow"

class Dog:
    def speak(self):
        return "Woof"

def animal_sound(animal):
    print(animal.speak())

cat = Cat()
dog = Dog()
animal_sound(cat)  # 输出: Meow
animal_sound(dog)  # 输出: Woof

4.6 封装

通过在属性名前加_或__，可以实现对属性的保护和隐藏。

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

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

    def get_balance(self):
        return self.__balance

acc = Account("Alice", 1000)
acc.deposit(500)
print(acc.get_balance())  # 输出: 1500
# print(acc.__balance)  # 报错: AttributeError

4.7 特殊方法

4.7.1 `init`

初始化对象时自动调用。

4.7.2 `str` 和 `repr`

__str__：定义对象的用户友好显示。
__repr__：定义对象的开发者友好显示。

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

    def __str__(self):
        return f"{self.name}, {self.age} years old"

person = Person("Alice", 30)
print(person)  # 输出: Alice, 30 years old

4.7.3 运算符重载

通过特殊方法实现对运算符的自定义行为。

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

    def __str__(self):
        return f"({self.x}, {self.y})"

p1 = Point(1, 2)
p2 = Point(3, 4)
print(p1 + p2)  # 输出: (4, 6)