一、类

类（Class）是面向对象编程中的一种蓝图或模板，用于创建具有相似属性和行为的对象

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

    def 方法名(self, 参数):
        # 方法逻辑

类的特点
封装：将属性和方法封装在一个类中。
继承：通过继承复用父类的代码。
多态：不同的类可以实现相同的方法，表现不同的行为

类的优点

1. 提高代码复用性。
2. 数据和功能封装在一起，便于维护。
3. 易于扩展和实现复杂功能

# 定义一个类
class Student:
    def __init__(self, name, student_id):
        self.name = name
        self.student_id = student_id

    def greet(self):
        print(f"您好，我叫 {self.name}，我的学号是 {self.student_id}")

# 创建对象
student1 = Student("小陈", "114514")
student2 = Student("小曾", "1919810")

# 调用对象的方法
student1.greet()
student2.greet()

输出以下

您好，我叫 小陈，我的学号是 114514
您好，我叫 小曾，我的学号是 1919810

二、父类与子类

父类是一个类的基础模板，提供了子类可以继承的属性和方法。通过继承，子类能够复用父类的代码，并在其基础上扩展功能。父类的特点如下：

1.包含公共属性和方法，这些内容通常会被多个子类复用。
2.子类通过继承，可以直接使用父类的方法，也可以重写这些方法以实现自己的逻辑。

子类（Child Class）
子类是从父类派生出来的，它继承了父类的属性和方法，但可以添加自己的属性和方法。子类的特点如下：

1.继承父类的所有非私有属性和方法。
2.子类可以添加新的属性和方法，扩展父类的功能。
3.子类可以通过重写（override）父类的方法实现多态。

# 定义父类
class ShoppingList:
    def __init__(self, shopping_list):
        self.shoppinglist = shopping_list

    def get_item(self):
        print("获取到如下商品目录：")
        for item in self.shoppinglist.keys():
            print(item)

    def get_cost(self):
        print("获取到如下价格：")
        for cost in self.shoppinglist.values():
            print(cost)

    def all_cost(self):
        sum = 0
        for cost in self.shoppinglist.values():
            sum += cost
        print(f"这次的花费为{sum}")

# 定义子类
class Shop(ShoppingList):
    def __init__(self, shopping_list, shop_name, location):
        super().__init__(shopping_list)
        self.shop_name = shop_name
        self.location = location

    def print_info(self):
        print(f"店铺名字：{self.shop_name}")
        print(f"店铺地址：{self.location}")

# 使用父类
my_shopping_list = ShoppingList({"鼠标": 0, "键盘": 50, "硬盘": 5000})

# 使用子类
my_shopping_list2 = Shop({"鼠标": 0, "键盘": 50, "电源": 100}, "百货之家", "人民路向北一百米")

# 调用子类和父类的方法
my_shopping_list2.print_info()
my_shopping_list.all_cost()
my_shopping_list.get_cost()
my_shopping_list.get_item()

输出如下：

店铺名字：百货之家
店铺地址：人民路向北一百米
这次的花费为5050
获取到如下价格：
0
50
5000
获取到如下商品目录：
鼠标
键盘
硬盘

关于 子类可以通过重写（override）父类的方法实现多态。有下例

假设我们有一个Employee类，代表员工，其中有一个work()方法。然后，我们定义了两个子类：Manager和Engineer，它们都继承自Employee。Manager重写了work()方法，而Engineer使用父类的work()方法。

# 定义父类
class Employee:
    def __init__(self, name):
        self.name = name

    def work(self):
        print(f"{self.name} 正在工作！")

# 定义子类 Manager（经理）
class Manager(Employee):
    def __init__(self, name, department):
        super().__init__(name)  # 调用父类的初始化方法
        self.department = department

    # 重写父类的 work 方法
    def work(self):
        print(f"{self.name} 作为经理，正在管理 {self.department} 部门！")

# 定义子类 Engineer（工程师）
class Engineer(Employee):
    def __init__(self, name, specialty):
        super().__init__(name)
        self.specialty = specialty

    # 使用父类的方法
    def work(self):
        # 调用父类的工作方法，附加特定的工程师行为
        super().work()  # 使用父类的 work 方法
        print(f"{self.name} 作为工程师，专注于 {self.specialty} 的开发！")

# 创建员工对象
manager = Manager("张经理", "人力资源")
engineer = Engineer("李工程师", "软件")

# 调用方法
manager.work()  # 经理重写了 work 方法
engineer.work()  # 工程师调用了父类的 work 方法并做了扩展

输出以下

张经理 作为经理，正在管理 人力资源 部门！
李工程师 正在工作！
李工程师 作为工程师，专注于 软件 的开发！

解释：

1. 父类Employee：
   • Employee类中有一个work()方法，表示员工正在工作。
2. 子类Manager：
   • Manager类继承自Employee，并重写了work()方法。重写的方法改变了工作逻辑，打印了经理在管理部门的消息。
3. 子类Engineer：
   • Engineer类也继承自Employee，并在work()方法中调用了父类的work()方法（通过super().work()），同时增加了额外的行为，表示工程师在专注于某项开发工作。

总结：

• 继承父类方法：子类可以直接使用父类的方法（如Engineer类中的super().work()）。
• 重写父类方法：子类也可以根据自己的需求重写父类的方法（如Manager类中的work()方法）。

通过继承和重写，子类能够灵活地扩展父类的功能，同时又能保留父类的一些通用行为，从而实现代码复用和功能扩展。