第四单元：面向对象编程

掌握Python面向对象编程基础

专为小白设计，从零开始学习面向对象编程

📚 单元介绍

欢迎来到Python面向对象编程单元！在本单元中，你将学习面向对象编程（OOP）的基本概念和实践。

面向对象编程是一种编程范式，它将数据和操作数据的方法封装在一起，形成对象。这种编程方式可以使代码更加模块化、可重用和易于维护。本单元将详细介绍类、对象、继承、多态等面向对象编程的核心概念。

🎯 学习目标

  • 理解面向对象编程的基本概念
  • 掌握类和对象的创建与使用
  • 学习类的属性和方法
  • 理解构造函数的作用
  • 掌握继承和多态的使用
  • 了解封装的概念和实现

📖 知识点讲解

1. 类和对象

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

# 定义类
class Person:
    """人员类"""
    
    # 类属性
    species = "人类"
    
    # 构造函数
    def __init__(self, name, age):
        """初始化方法"""
        # 实例属性
        self.name = name
        self.age = age
    
    # 实例方法
    def greet(self):
        """打招呼"""
        return f"你好，我叫{self.name}，今年{self.age}岁。"
    
    def celebrate_birthday(self):
        """庆祝生日"""
        self.age += 1
        return f"生日快乐！{self.name}现在{self.age}岁了。"

# 创建对象
person1 = Person("小明", 18)
person2 = Person("小红", 17)

# 访问实例属性
print(person1.name)  # 小明
print(person1.age)  # 18

# 访问类属性
print(Person.species)  # 人类
print(person1.species)  # 人类

# 调用实例方法
print(person1.greet())  # 你好，我叫小明，今年18岁。
print(person1.celebrate_birthday())  # 生日快乐！小明现在19岁了。
print(person2.greet())  # 你好，我叫小红，今年17岁。

2. 类的属性和方法

类可以有类属性和实例属性，以及类方法、实例方法和静态方法。

class Student:
    """学生类"""
    
    # 类属性
    school = "北京大学"
    student_count = 0
    
    def __init__(self, name, grade):
        """初始化方法"""
        self.name = name
        self.grade = grade
        Student.student_count += 1
    
    # 实例方法
    def get_grade(self):
        """获取成绩"""
        return self.grade
    
    # 类方法
    @classmethod
    def get_school(cls):
        """获取学校名称"""
        return cls.school
    
    # 静态方法
    @staticmethod
    def is_passing_grade(grade):
        """判断是否及格"""
        return grade >= 60

# 创建学生对象
student1 = Student("小明", 85)
student2 = Student("小红", 75)

# 访问实例属性和方法
print(student1.name)  # 小明
print(student1.get_grade())  # 85

# 访问类属性和方法
print(Student.school)  # 北京大学
print(Student.get_school())  # 北京大学
print(Student.student_count)  # 2

# 使用静态方法
print(Student.is_passing_grade(70))  # True
print(Student.is_passing_grade(50))  # False

3. 继承

继承是面向对象编程的重要特性，它允许一个类继承另一个类的属性和方法。

# 父类
class Animal:
    """动物类"""
    
    def __init__(self, name):
        """初始化方法"""
        self.name = name
    
    def speak(self):
        """发出声音"""
        return "动物发出声音"

# 子类 - 继承自Animal
class Dog(Animal):
    """狗类"""
    
    def speak(self):
        """发出声音"""
        return f"{self.name}汪汪叫"

# 子类 - 继承自Animal
class Cat(Animal):
    """猫类"""
    
    def speak(self):
        """发出声音"""
        return f"{self.name}喵喵叫"

# 创建对象
animal = Animal("动物")
dog = Dog("旺财")
cat = Cat("咪咪")

# 调用方法
print(animal.speak())  # 动物发出声音
print(dog.speak())  # 旺财汪汪叫
print(cat.speak())  # 咪咪喵喵叫

# 检查继承关系
print(isinstance(dog, Animal))  # True
print(isinstance(cat, Animal))  # True
print(isinstance(animal, Dog))  # False

4. 多态

多态是指不同类的对象可以使用相同的方法名，但表现出不同的行为。

class Shape:
    """形状类"""
    
    def area(self):
        """计算面积"""
        pass

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):
        """计算面积"""
        import math
        return math.pi * self.radius ** 2

# 创建对象
shapes = [
    Rectangle(5, 4),
    Circle(3)
]

# 多态：不同对象调用相同方法，表现出不同行为
for shape in shapes:
    print(f"面积: {shape.area()}")

# 输出：
# 面积: 20
# 面积: 28.274333882308138

5. 封装

封装是指将对象的属性和方法封装在一起，隐藏内部实现细节，只提供公共接口。

class BankAccount:
    """银行账户类"""
    
    def __init__(self, account_number, balance=0):
        """初始化方法"""
        self.account_number = account_number  # 公共属性
        self.__balance = balance  # 私有属性（以双下划线开头）
    
    def deposit(self, amount):
        """存款"""
        if amount > 0:
            self.__balance += amount
            return f"存款成功，当前余额: {self.__balance}"
        else:
            return "存款金额必须大于0"
    
    def withdraw(self, amount):
        """取款"""
        if amount > 0 and amount <= self.__balance:
            self.__balance -= amount
            return f"取款成功，当前余额: {self.__balance}"
        else:
            return "取款金额无效"
    
    def get_balance(self):
        """获取余额"""
        return self.__balance

# 创建账户
account = BankAccount("123456789", 1000)

# 访问公共属性
print(account.account_number)  # 123456789

# 调用方法
print(account.deposit(500))  # 存款成功，当前余额: 1500
print(account.withdraw(200))  # 取款成功，当前余额: 1300
print(account.get_balance())  # 1300

# 尝试直接访问私有属性（会失败）
# print(account.__balance)  # 这会报错

# 但可以通过特殊方式访问（不推荐）
print(account._BankAccount__balance)  # 1300

6. 特殊方法

Python中有许多特殊方法，它们以双下划线开头和结尾，用于实现对象的特殊行为。

class Point:
    """点类"""
    
    def __init__(self, x, y):
        """初始化方法"""
        self.x = x
        self.y = y
    
    def __str__(self):
        """字符串表示"""
        return f"Point({self.x}, {self.y})"
    
    def __repr__(self):
        """正式表示"""
        return f"Point({self.x}, {self.y})"
    
    def __add__(self, other):
        """加法运算"""
        return Point(self.x + other.x, self.y + other.y)
    
    def __eq__(self, other):
        """相等比较"""
        return self.x == other.x and self.y == other.y

# 创建点对象
p1 = Point(1, 2)
p2 = Point(3, 4)

# 使用特殊方法
print(p1)  # 调用__str__方法，输出: Point(1, 2)
print(repr(p1))  # 调用__repr__方法，输出: Point(1, 2)

# 加法运算
p3 = p1 + p2  # 调用__add__方法
print(p3)  # Point(4, 6)

# 相等比较
p4 = Point(1, 2)
print(p1 == p4)  # 调用__eq__方法，输出: True
print(p1 == p2)  # 输出: False

💻 实践练习

练习1：类和对象

创建一个Car类，包含品牌、型号、年份等属性，以及启动、加速、刹车等方法。

练习2：继承

创建一个Employee基类，然后创建Manager和Developer子类，每个子类都有自己的特殊方法。

练习3：多态

创建一个Shape基类，然后创建Triangle、Square等子类，每个子类都实现自己的area()方法。

练习4：封装

创建一个Person类，包含私有属性年龄，通过公共方法来访问和修改年龄。

练习5：特殊方法

创建一个Vector类，实现加法、减法、乘法等特殊方法。

📦 学习资源

📖

推荐书籍

《Python编程：从入门到实践》

《Python基础教程》

🌐

在线资源

Python官方文档 - 类

菜鸟教程 - Python面向对象

💻

开发工具

Anaconda

Jupyter Notebook