Python小白学习笔记六 （面向对象 练习题）

面向对象 练习题

练习1：

"""
    创建父类：车(品牌，速度)
    创建子类：电动车(电池容量,充电功率)
    创建子类对象并画出内存图。
"""
class Car:
    def __init__(self, bread="", speed=0):
        self.bread = bread
        self.speed = speed

class ElectricCars(Car):
    def __init__(self, bread, speed, battery_capacity, charging_power=100):
        super().__init__(bread, speed)
        self.battery_capacity = battery_capacity
        self.charging_power = charging_power
tsl = ElectricCars("特斯拉", 300, 30000, 1000)
print(tsl.bread)
print(tsl.speed)
print(tsl.battery_capacity)
print(tsl.charging_power)

练习2：

"""
    情景：手雷爆炸，可能伤害敌人(头顶爆字)或者玩家(碎屏)。
    变化：还可能伤害房子、树、鸭子....
    要求：增加新事物，不影响手雷.
    画出架构设计图
    体会：开闭原则
        增加新攻击目标,手雷不改变.
	（个人理解，如有描述不当，欢迎评论指出，小白感谢！）
    封装：Grenade     AttackTarget（父类）
    继承：Enemy(AttackTarget)，Player(AttackTarget)  （子类）
    多态：即子类的各种反应  
"""
# --------------架构师----------------
class Grenade:
    def explode(self,target):
        print("手雷爆炸")
        target.damage()
class AttackTarget:
    def damage(self):
        pass
# --------------程序猿----------------
class Enemy(AttackTarget):
    def damage(self):
        print("头顶爆字")
class Player(AttackTarget):
    def damage(self):
        print("碎屏")
# --------------测试----------------
g = Grenade()
g.explode(    Enemy()   )
g.explode(    Player()   )

练习3：

"""
    创建图形管理器
	1. 记录多种图形（圆形、矩形....）
	2. 提供计算总面积的方法.
    满足：
        开闭原则
    测试：
        创建图形管理器，存储多个图形对象。
        通过图形管理器，调用计算总面积方法.

    三大特征：
        封装：GraphicManager、Rectangle、Cycle
        继承：Graphic隔离了Rectangle、Cycle
        多态：以重写的方式完成具体图形算法
    六大原则：
        开闭原则：增加新图形，不改变图形管理器
        单一职责：
        依赖倒置：GraphicManager用Graphic，不用Rectangle、Cycle
        组合复用：GraphicManager通过实例变量调用图形算法
"""
class GraphicManager:
    def __init__(self):
        self.__list_graphics = []
    def add_graphic(self, graphic):
        self.__list_graphics.append(graphic)
    def calcualte_total_area(self):
        total_area = 0
        for graphic in self.__list_graphics:
            total_area += graphic.get_total_area()
        return total_area
#----------------------------
class Graphic:
    def get_total_area(self):
        pass
# ---------------------------
class Rectangle(Graphic):
    def __init__(self, l, w):
        self.l = l
        self.w = w

    def get_total_area(self):
        super().get_total_area()
        return self.l * self.w

class Circle(Graphic):
    def __init__(self, r):
        self.r = r

    def get_total_area(self):
        return 3.14 * self.r ** 2

manager = GraphicManager()
manager.add_graphic(Rectangle(2, 4))
manager.add_graphic(Circle(5))
print(manager.calcualte_total_area())

练习4：

"""
    小明使用手机打电话
    要求:增加座机,卫星电话时不影响小明.
    写出案例中体现的面向对象三大特征和六大原则.
        封装:创建人类Person,手机类MobilePhone,座机类Landline
        继承:创建通信工具Communication,隔离人类Person与具体通信工具类(手机类MobilePhone,座机类Landline)
        多态:人类调用通信工具,具体通信工具类重写通信工具dialing,创建手机对象,座机对象
             编码时调用父,                                  运行时执行子.
             彰显子类的个性(变化/具体实现方式)
        开闭原则:增加座机,卫星电话时不影响人类
        单一职责:人类负责xxxx,手机类负责xxx,座机类负责xxx
        依赖倒置:人类调用通信工具,不调用具体通信工具(手机类,座机类)
        组合复用:组合关系连接了人类与通信工具的变化
                继承关系统一了手机类,座机类
        里氏替换:人类打电话函数的形参是通信工具,调用时传递各种具体通信工具.
        迪米特:人类 与 具体通信工具低耦合
              各种通信工具之间低耦合
"""
class Person:
    def __init__(self, name=""):
        self.name = name
    def call(self, communication):
        print(self.name, "打电话")
        # 1. 编码时  调用父
        # 运行时  执行子
        communication.dialing()
#-------------------------------------------
class Communication:
    def dialing(self):
        pass
#-------------------------------------------
class MobilePhone(Communication):
    # 2. 体现个性(实现变化)
    def dialing(self):
        print("手机呼叫")

class Landline(Communication):
    def dialing(self):
        print("座机呼叫")

xm = Person("小明")
# 3. 创建子对象
xm.call(MobilePhone())
xm.call(Landline())

练习5：

"""
    小明一次请多个保洁打扫卫生
    效果:调用一次小明通知方法,可以有多个保洁在打扫卫生.
"""
class Client:
    def __init__(self, name=""):
        self.name = name
    # def notify_multiple(self, list_household_service):
    #     print(self.name, "通知")
    #     实参构建容器
    #     for service in list_household_service:
    #         service.cleaning()
    # 形参构建容器
    def notify_multiple(self, *args):
        print(self.name, "通知")
        for service in args:
            service.cleaning()

class Cleaner:
    def cleaning(self):
        print("打扫卫生")

xm = Client("小明")
# 如果形参是列表,实参自行构建列表.
# list_cleaners = [
#     Cleaner(),
#     Cleaner(),
#     Cleaner(),
# ]
# xm.notify_multiple(list_cleaners)

# 如果形参是星号元组形参*args,实参直接传递列表中元素.
xm.notify_multiple(Cleaner(),
                   Cleaner(),
                   Cleaner())