面向对象OOP

编程题1：学生信息类
题目要求
定义一个 Student 学生类，要求如下：

1. 使用 init 方法初始化学生的姓名、年龄、专业。
2. 定义 show_info() 方法，输出学生的基本信息。
3. 创建两个学生对象，并分别调用 show_info() 方法。

class Student:
    def __init__(self,name,age,major):
        self.name=name
        self.age=age
        self.major=major
    def show_info(self):
        print(f"姓名：{self.name},年龄：{self.age},专业：{self.major}")
stu1=Student("张三" , 18,"软件技术")
stu2=Student("李四",19,"大数据技术")

stu1.show_info()
stu2.show_info()

编程题2：人物运动类
题目要求
定义一个 Person 类。
人物具有以下属性：

1. 姓名
2. 年龄
3. 身高
   要求实现以下方法：
4. run() ：输出"某某正在跑步"。
5. eat(food) ：输出"某某正在吃某食物"。
6. show_info() ：输出人物的基本信息。
   创建两个对象：
7. 小明，18岁，身高1.75，每天跑步并吃早餐。
8. 小美，17岁，身高1.65，不跑步，喜欢吃东西。
   参考运行效果
   小明今年18岁，身高1.75米
   小明正在跑步
   小明正在吃早餐
   小美今年17岁，身高1.65米
   小美正在吃蛋糕

class Person:
    def __init__(self,name,age,height):
        self.name = name
        self.age = age
        self.height = height
    def run(self):
        print(f"{self.name}正在跑步")
    def eat(self,food):
        print(f"{self.name}正在吃{food}")
    def show_info(self):
        print(f"{self.name}今年{self.age}岁，身高{self.height}米")

stu1=Person("小明",18,1.75)
stu2=Person("小美",17,1.65)

stu1.show_info()
stu1.run()
stu1.eat("早餐")

stu2.show_info()
stu2.eat("蛋糕")

编程题3：小狗行为模拟
题目要求
定义一个 Dog 类，表示一只小狗。
要求：

1. 小狗具有姓名、颜色两个属性。
2. 定义 bark() 方法，输出"某某正在汪汪叫"。
3. 定义 wag_tail() 方法，输出"某某正在摇尾巴"。
4. 创建一只名叫"大黄"、颜色为"黄色"的小狗对象，并调用两个方法。
   姓名：张三，年龄：18，专业：软件技术
   姓名：李四，年龄：19，专业：大数据技术
   参考运行效果
   大黄是一只黄色的小狗
   大黄正在汪汪叫
   大黄正在摇尾巴

class Dog:
    def __init__(self, name,color):
        self.name=name
        self.color=color
    def bark(self):
        print(f"{self.name}正在汪汪叫")
    def wag_tail(self):
        print(f"{self.name}正在摇尾巴")

dog1=Dog("大黄","黄色")
print(f"{dog1.name}是一只{dog1.color}的小狗")
dog1.bark()
dog1.wag_tail()

编程题4：手机类设计
题目要求
定义一个 Phone 手机类，要求如下：

1. 手机具有品牌、颜色、电量三个属性。
2. 定义 call() 方法，表示手机正在打电话。
3. 定义 play_music() 方法，表示手机正在播放音乐，手机电量减少20。
4. 定义 charge() 方法，每调用一次，手机电量增加 20。
5. 创建一个手机对象，调用相关方法，并输出手机当前电量。
   参考运行效果
   华为手机正在打电话
   华为手机正在播放音乐
   充电成功，当前电量为：80%
   提示
   可以在 charge() 方法中使用：
   self.power += 20

class Phone:
    def __init__(self,brand,color,power):
        self.brand = brand
        self.color = color
        self.power = max(0,min(power,100))
    def call(self):
        print(f"{self.brand}手机正在打电话")
    def play_music(self):
        print(f"{self.brand}手机正在播放音乐")
        self.power = max(0, self.power-20)
    def charge(self):
        self.power=min(100,self.power+20)
        print(f"充电成功，当前电量为：{self.power}%")
phone1=Phone("华为","未知",60)
phone1.call()
phone1.play_music()
phone1.charge()

编程题5：猫吃鱼喝水
题目要求
参考课堂中的小猫案例，定义一个 Cat 类。
要求：

1. 使用 init 方法初始化猫的名字。
2. 定义 eat() 方法，输出"某某爱吃鱼"。
3. 定义 drink() 方法，输出"某某要喝水"。
4. 创建两只猫对象，分别调用两个方法。
   参考运行效果
   Tom爱吃鱼
   Tom要喝水
   大懒猫爱吃鱼
   大懒猫要喝水
   拓展要求
   再定义一个 sleep() 方法，输出"某某正在睡觉"。

class Cat:
    def __init__(self,name):
        self.name = name
    def eat(self):
        print(f"{self.name}爱吃鱼")
    def drink(self):
        print(f"{self.name}要喝水")
cat1 = Cat("Tom")
cat2 = Cat("大懒猫")

cat1.eat()
cat1.drink()
cat2.eat()
cat2.drink()

编程题6：银行账户类
题目要求
定义一个 BankAccount 银行账户类。
账户具有以下属性：

1. 户主姓名 name
2. 余额 balance
   要求实现以下方法：
3. deposit(money) ：存款，余额增加。
4. withdraw(money) ：取款，如果余额充足则扣款，否则提示余额不足。
5. show_balance() ：查看当前余额。
   参考运行效果
   张三存款成功，当前余额：1500元
   张三取款成功，当前余额：1000元
   余额不足，取款失败

class BankAccount:
    def __init__(self, name, balance):
        self.name = name
        self.balance = balance
    def deposit(self, money):
        if money > 0:
            self.balance += money
            print(f"{self.name}存款成功,当前余额：{self.balance}元")
        else:
            print("存款金额必须大于0！")
    def withdraw(self, money):
        if self.balance<money :
            print(f"余额不足，取款失败")
        elif money<=0:
            print("取款金额必须大于0！")
        else:
            self.balance -= money
            print(f"{self.name}取款成功,当前余额：{self.balance}元")
    def show_balance(self):
        print(f"{self.name},当前余额：{self.balance}元")

msg=BankAccount("张三",0)
msg.deposit(1500)
# msg.show_balance()
msg.withdraw(500)
# msg.show_balance()
msg.withdraw(1200)

编程题7：汽车类设计
题目要求
定义一个 Car 类。
汽车具有以下属性：

1. 品牌
2. 颜色
3. 当前速度，初始值为 0
   要求实现以下方法：
4. start() ：启动汽车。
5. speed_up() ：每调用一次，速度增加 10。
6. brake() ：每调用一次，速度减少 10，最低不能低于 0。
7. show_speed() ：显示当前速度。
   参考运行效果
   宝马汽车启动了
   当前速度：10 km/h
   当前速度：20 km/h
   刹车后速度：10 km/h

class Car:
    def __init__(self,brand,color):
        self.brand = brand
        self.color = color
        self.speed = 0
    def start(self):
        print(f'{self.brand}汽车启动了')
    def speed_up(self):
        self.speed += 10
        print(f"当前速度：{self.speed} km/h")
    def brake(self):
        if self.speed >= 10:
            self.speed-=10
            print(f"刹车后速度：{self.speed} km/h")
        else:
            self.speed=0
            print(f"刹车后速度：{self.speed} km/h")
    def show_speed(self):
        print(f"当前速度：{self.speed} km/h")

car1=Car("宝马","未知")
car1.start()
car1.speed_up()
# car1.show_speed()
car1.speed_up()
# car1.show_speed()
car1.brake()

参考运行效果
编程题8：模拟烤地瓜程序
题目要求
定义一个 SweetPotato 地瓜类，实现模拟烤地瓜功能。
地瓜具有以下属性：

1. cook_time ：烤制时间，初始值为 0。
2. state ：地瓜状态，初始值为"生的"。
3. condiments ：调料列表，初始为空列表。
   要求实现以下方法：
   **1.**cook(time)
   表示烤地瓜，每调用一次增加指定的烤制时间，并根据总时间改变地瓜状态：
   烤制时间 地瓜状态
   0-3 分钟 生的
   3-5 分钟 半生不熟
   5-8 分钟 熟的
   超过 8 分钟 烤糊了
   **2.**add_condiment(condiment)
   添加调料，例如"番茄酱""辣椒面""孜然"。
   **3.**show_info()
   输出地瓜当前的烤制时间、状态和调料。
   地瓜已经烤了3分钟，当前状态：生的，添加的调料：无
   地瓜已经烤了6分钟，当前状态：熟的，添加的调料：孜然
   地瓜已经烤了9分钟，当前状态：烤糊了，添加的调料：孜然、辣椒面

class SweetPotato:
    def __init__(self):
        self.cook_time = 0
        self.state = "生的"
        self.condiments = []

    def cook(self,time):
        self.cook_time += time
        if 0<=self.cook_time<3 :
            self.state="生的"
        elif 3<=self.cook_time<5 :
            self.state="半生不熟"
        elif 5<=self.cook_time<8 :
            self.state="熟的"
        else:
            self.state="烤糊了"

    def add_condiment(self,condiment):
        self.condiments.append(condiment)

    def show_info(self):
        if self.condiments:
            cond = "、".join(self.condiments)
        else:
            cond="无"
        print(f"地瓜已经烤了{self.cook_time}分钟，当前状态：{self.state}，添加的调料：{cond}")
sp=SweetPotato()
sp.cook(3)
sp.show_info()

sp.cook(3)
sp.add_condiment("孜然")
sp.show_info()
# 第三次再烤3分钟（总时间9分钟），加辣椒面
sp.cook(3)
sp.add_condiment("辣椒面")
sp.show_info()

题目9**：房子与家具管理系统**
请使用 Python 设计一个简单的"房子与家具管理系统"。该系统包含两个类： HouseItem （家具类）和
House （房子类），并实现以下要求。
基本要求
一、家具类HouseItem
属性
name ：家具名称，如 "bed" 、 "chest" 、 "table"
area ：家具占地面积，单位为平方米
方法
init(self, name, area) ：构造方法，用于初始化家具名称和占地面积
str(self) ：返回家具信息的字符串表示形式
二、房子类House
属性
house_type ：户型，如 "两室一厅"
area ：房子总面积，单位为平方米
free_area ：房子剩余面积，初始值等于总面积
item_list ：家具列表，用于存储 HouseItem 对象，假设一间房子最多存放 10 个家具
方法
init(self, house_type, area) ：构造方法，用于初始化户型和总面积
info(self) ：打印房子的户型、总面积、剩余面积以及家具名称列表
add_item(self, item) :添加家具对象到房子中，并更新剩余面积，如果剩余面积不足，则不允
许添加家具，并输出友好提示
三、示例输出
在主程序中，首先创建三个家具对象，分别是床、衣柜和桌子，并设置它们各自的占地面积。然后创建
一个户型为"两室一厅"、总面积为 50 平米的房子对象。接着依次将三个家具添加到房子中，最后调用
info() 方法输出房子的基本信息，包括户型、总面积、剩余面积以及已添加的家具名称列表。
题目2：图书馆管理系统
户型：两室一厅
总面积：50.0平米
剩余面积：42.5平米
家具名称列表：bed,chest,table

class HouseItem:
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return f"家具名称：{self.name},家具占地面积：{self.area}平方米"

class House:
    def __init__(self, house_type, area):
        self.house_type = house_type
        self.area = area
        self.free_area = area
        self.item_list = []
        
    def add_item(self, item):
        # 错误1：数量判断写反了，应该 >=10
        if len(self.item_list) >= 10:
            print("家具数量已达上限，无法添加更多家具！")
            return
        if self.free_area < item.area:
            print(f"剩余面积不足，无法添加【{item.name}】！")
            return
        self.item_list.append(item)
        self.free_area -= item.area

    def info(self):
        # 错误2 + 3：取出对象的 name 组成列表，再 join
        name_list = [item.name for item in self.item_list]
        
        print(
f"""
户型：{self.house_type}
总面积：{self.area}平米
剩余面积：{self.free_area}平米
家具名称列表：{','.join(name_list)}  
        """)

# 创建家具对象
bed1 = HouseItem("bed", 4)
chest1 = HouseItem("chest", 2)
table1 = HouseItem("table", 1.5)

# 创建房子
house1 = House("两室一厅", 50.0)

# 错误4：必须传对象，不是字符串！
house1.add_item(bed1)
house1.add_item(chest1)
house1.add_item(table1)

house1.info()

class HouseItem:
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return f"家具名称：{self.name},家具占地面积：{self.area}平方米"

class House:
    def __init__(self, house_type, area):
        self.house_type = house_type
        self.area = area
        self.free_area = area
        self.item_list= []
    def add_item(self,item):
        if len(self.item_list)>=10:
            print("家具数量已达上限，无法添加更多家具！")
            return
        if self.free_area<item.area:
            print(f"剩余面积不足，无法添加【{item.name}】！")
            return
        self.item_list.append(item)
        self.free_area -= item.area

    def info(self):
        name_list = []
        for item in self.item_list:
            name_list.append(item.name)
        str_name=",".join(name_list)
        print(
f"""
户型：{self.house_type}
总面积：{self.area}平米
剩余面积：{self.free_area}平米
家具名称列表：{str_name}  
        """)

bed1=HouseItem("bed",4)
chest1=HouseItem("chest",2)
table1=HouseItem("table",1.5)
house1=House("两室一厅",50.0)
house1.add_item(bed1)
house1.add_item(chest1)
house1.add_item(table1)
house1.info()

题目2：图书馆管理系统
题目要求
设计一个简单的图书馆管理系统，包含 Book 图书类和 Library 图书馆类。
图书类Book
属性
title ：书名
author ：作者
is_borrowed ：是否被借出，默认值为 False
方法
borrow() ：借书
return_book() ：还书
show_info() ：显示图书信息
图书馆类Library
属性
name ：图书馆名称
books ：图书列表，用于保存多个 Book 对象
方法
add_book(book) ：添加图书
show_books() ：显示所有图书
borrow_book(title) ：根据书名借书
return_book(title) ：根据书名还书
示例代码
book1 = Book("Harry Potter", "J.K. Rowling")
book2 = Book("The Hobbit", "J.R.R. Tolkien")
library = Library("City Library")
library.add_book(book1)
library.add_book(book2)
library.show_books()
library.borrow_book("Harry Potter")
library.show_books()
预期输出
书名：Harry Potter，作者：J.K. Rowling，状态：未借出
书名：The Hobbit，作者：J.R.R. Tolkien，状态：未借出
《Harry Potter》借阅成功
书名：Harry Potter，作者：J.K. Rowling，状态：已借出
书名：The Hobbit，作者：J.R.R. Tolkien，状态：未借出

# 先定义 Book 类
class Book:
    def __init__(self, title, author):
        self.title = title      # 书名
        self.author = author    # 作者
        self.is_borrowed = False  # 状态：默认未借出

    def __str__(self):
        # 返回书籍信息的字符串形式
        status = "已借出" if self.is_borrowed else "未借出"
        return f"书名：{self.title}，作者：{self.author}，状态：{status}"


# 再定义 Library 类
class Library:
    def __init__(self, name):
        self.name = name      # 图书馆名称
        self.books = []       # 保存 Book 对象的列表

    def add_book(self, book):
        """添加书籍到图书馆"""
        self.books.append(book)

    def show_books(self):
        """显示所有书籍信息"""
        for book in self.books:
            print(book)

    def borrow_book(self, title):
        """根据书名借书"""
        for book in self.books:
            if book.title == title:
                if not book.is_borrowed:
                    book.is_borrowed = True
                    print(f"《{title}》借阅成功")
                else:
                    print(f"《{title}》已被借出，无法借阅")
                return
        print(f"《{title}》不存在，无法借阅")

    def return_book(self, title):
        """根据书名还书"""
        for book in self.books:
            if book.title == title:
                if book.is_borrowed:
                    book.is_borrowed = False
                    print(f"《{title}》归还成功")
                else:
                    print(f"《{title}》未被借出，无需归还")
                return
        print(f"《{title}》不存在，无法归还")


# 示例代码
if __name__ == "__main__":
    # 创建书籍对象
    book1 = Book("Harry Potter", "J.K. Rowling")
    book2 = Book("The Hobbit", "J.R.R. Tolkien")

    # 创建图书馆对象
    library = Library("City Library")
    library.add_book(book1)
    library.add_book(book2)

    # 显示所有书籍
    library.show_books()

    # 借书
    library.borrow_book("Harry Potter")

    # 再次显示所有书籍
    library.show_books()

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
        self.is_borrowed = False
    def borrow(self):
        self.is_borrowed = True
        print(f"《{self.title}》借阅成功")
    def return_book(self):
        self.is_borrowed = False
        print(f"《{self.title}》归还成功")
    def show_info(self):
        if self.is_borrowed:
            status="已借出"
        else:
            status="未借出"
        print(f"书名：{self.title}，作者：{self.author}，状态：{status}")

class Library:
    def __init__(self, name):
        self.name = name
        self.book_list = []
    def add_book(self, book):
        self.book_list.append(book)
    def show_books(self):
        for book in self.book_list:
            book.show_info()

    def borrow_book(self, title):
        for book in self.book_list:
            if book.title == title:
                book.borrow()

book1 = Book("Harry Potter", "J.K. Rowling")
book2 = Book("The Hobbit", "J.R.R. Tolkien")

library = Library("City Library")
library.add_book(book1)
library.add_book(book2)

library.show_books()
library.borrow_book("Harry Potter")
library.show_books()

题目3：银行账户类
题目要求
设计一个 BankAccount 银行卡账户类，实现账户的存款、取款和余额查询功能。
类名
属性要求
实例属性
username ：账户用户名
__balance ：账户余额，要求使用私有属性进行封装
类属性
bank_name ：银行名称，默认值为 "中国银行"
count : 银行开户人数，默认值为0
方法要求
实例方法
deposit(money) ：存款
widthdraw(money) : 取款
如果余额不足，提示"余额不足"
如果余额充足，则完成取款
show_balance() ：查看当前余额
类方法
get_count() ：查看银行开户人数
静态方法
check_money(money) ：判断金额是否合法
金额必须大于 0
否则返回 False