面向对象案例

题目一：学生成绩管理

创建一个 Student 类，包含以下要求：
属性：name（姓名）、age（年龄）、grades（成绩列表，初始为空）。
方法：add_grade(score)，用于向成绩列表中添加新分数。
方法：get_average()，用于计算并返回平均分。
实例化一个学生对象，添加几个成绩，并打印出该学生的平均分。

class Student():
    def __init__(self,name,age):
        self.name = name  # 对象可以访问的属性
        self.age = age # 创建了一个属性
        self.grades = [] # 创建了一个空列表,对象可以使用的

    # 添加分数
    def add_grade(self,score):
        self.grades.append(score)
        print(f"分数添加成功:{score}")

    # 打印分数
    def get_grade(self):
        return self.grades

    # 算出平均值
    def get_average(self):
        if len(self.grades) == 0:
            print("成绩为空,请添加成绩")
            return 0
        return sum(self.grades)/len(self.grades)

# 创建了一个tom对象
tom = Student("tom",18)

tom.add_grade(90)
tom.add_grade(90)
tom.add_grade(90)

print(tom.get_grade())

print(tom.get_average())

# 创建了一个tim对象，每个对象都是独立的，因此tim对象打印的话，是一个空列表
tim = Student("tim",18)
print(tim.get_grade())

题目2: 封装与属性校验

创建一个 BankAccount（银行账户）类：
属性：__balance（余额，必须为私有属性，外部不能直接修改）。
方法：deposit(amount)（存钱），要求金额必须大于0，否则提示错误。
方法：withdraw(amount)（取钱），要求金额必须大于0且不超过当前余额，否则提示错误。
方法：get_balance()，用于查询当前余额。

class BankAcoount():
    def __init__(self,balance):
        # 定义一个余额
        self.__balance = balance

    # 存钱
    def deposit(self,amount):
        if amount > 0:
            self.__balance += amount
            print("存钱成功")
        else:
            print(f"存钱的金额{amount}必须大于0")
    # 取钱
    def withdraw(self,amount):
        if amount > 0 and amount < self.__balance:
            self.__balance -= amount
            print(f"取钱成功，余额为:{self.__balance}")
        else:
            print(f"取钱需要大于0或者取钱大于余额")
            print("取钱失败")
    # 查询余额
    def get_balance(self):
        print(f"查询的余额为：{self.__balance}")


tom = BankAcoount(1000)

tom.withdraw(500)
tom.get_balance()
tom.deposit(1000)
tom.get_balance()

题目3：继承与方法重写

创建一个 Animal（动物）基类和一个 Dog（狗）子类：
Animal 类包含一个 name 属性，以及一个 speak() 方法（默认输出“动物发出声音”）。
Dog 类继承自 Animal，并重写 speak() 方法，使其输出“汪汪叫”。
实例化 Dog 对象并调用 speak() 方法。

class Animal():
    def __init__(self,name):
        self.name = name  # 创建一个实例属性，对象就能使用了

    def speak(self):
        print("动物发出声音")

class Dog(Animal):
    def speak(self):
        print("汪汪叫")


d1 = Dog("karry")
d1.speak()

题目4：计算工资

定义一个抽象基类 Employee（员工），包含属性 name（姓名），
并强制要求子类必须实现一个抽象方法 calculate_salary()（计算工资）。

创建三个子类，分别代表不同类型的员工，并重写 calculate_salary() 方法：
SalariedEmployee（全职员工）：属性包含 monthly_salary（月薪）。工资 = 固定月薪。
HourlyEmployee（小时工）：属性包含 hourly_rate（时薪）和 hours_worked（工作时长）。工资 = 时薪 × 时长。
SalesEmployee（销售员）：属性包含 base_salary（底薪）和 sales_amount（销售额）。工资 = 底薪 + 销售额 × 5%（提成）。

编写一个统一的发薪函数 pay_salary(employee)，接收任意员工对象，并打印出“XXX 本月工资为：XXX 元”。
实例化不同类型的员工，放入一个列表中，遍历列表调用发薪函数。

from abc import ABC, abstractmethod

# 1. 抽象基类：定义统一的接口规范
class Employee(ABC):
    def __init__(self, name):
        self.name = name

    @abstractmethod
    def calculate_salary(self):
        """抽象方法：计算工资，强制子类必须实现"""
        pass

# 全职员工
class SalariedEmployee(Employee):
    def __init__(self,name,monthly_salary):
        super().__init__(name)
        self.monthly_salary = monthly_salary

    def calculate_salary(self):
        return self.monthly_salary


# 小时工

class HOurlyEmployee(Employee):
    def __init__(self,name,hourly_wage,hours_worked):
        super().__init__(name)
        self.hourly_wage = hourly_wage
        self.hours_worked = hours_worked

    def calculate_salary(self):
        return self.hourly_wage * self.hours_worked

# 销售员
class SalesEmployee(Employee):
    def __init__(self,name,base_salary,sale_amount):
        super().__init__(name)
        self.base_salary = base_salary
        self.sale_amount = sale_amount
    def calculate_salary(self):
        return self.base_salary + self.sale_amount * 0.5



# 接收的是对象，是一个统一的接口，
def payroll(employees):
    print(f"{employees.name}的工资为：{employees.calculate_salary()}")


if __name__ == '__main__':

    t1 = SalariedEmployee("t1",5000)
    t2 = HOurlyEmployee("t2",20,40)
    t3 = SalesEmployee("t3",5000,1000)

    list_salry = [t1,t2,t3]
    print("公司开始发工资啦")
    for i in list_salry:
        payroll(i)

核心思想：

• 定义一个函数，参数为对象，不用管是那一个对象，直接使用对象.方法

• 使用循环这个对象列表，使用这个函数，传入不同的对象参数

• 实现了不同的对象调用呈现不同的方法

  • t1对象使用的全职的方法

  • t2对象使用的是小时工的方法

  • t3对象使用的是销售员的方法

  • 方法名都是相同的