day12

 1 1. 三合一
 2 2. 当天练习独立完成
 3 3. 指出案例中蕴含的理论：
 4    （1）手雷爆炸
 5         封装：手雷,玩家类,敌人类
 6         继承：受害者 隔离 玩家类,敌人类与手雷
 7         多态：玩家类,敌人类 重写 受害者的受伤方法
 8         开闭原则：增加新的受害者,不影响手雷类
 9         依赖倒置：手雷类调用受害者,而不调用玩家,敌人
10 
11    （2）图形管理器
12         封装：图形管理器类,圆形类,矩形类
13         继承：图形类 隔离 圆形类,矩形类与图形管理器
14         多态：圆形类 矩形类 不影响图形管理类
15         开闭原则：添加新的图形,不影响图形管理器 
16         依赖倒置：图形管理器调用图形类,不调用圆形类,矩形类
17 
18  1. 老张开车去东北
19     封装：人类，汽车类，飞机类
20     继承：交通工具 隔离 汽车类，飞机类与人类。
21     多态：汽车类、飞机类 重写 交通工具的运输方法.
22     开闭原则：增加新的交通工具，不影响人类.
23     依赖倒置：人类调用交通工具，而不调用汽车、飞机.
24 
25 4. （扩展）根据信息管理系统(MVC),完成购物车(MVC)。
26 5. 穷尽一切手段，在互联网上搜索面向对象三大特征相关资料.
27    结合课堂所讲，总结心得体会下来。

 

# demo01"""
    继承 -- 语法
        财产：钱不用孩子挣，但是可以花.
        皇位：江山不用孩子打，但是可以坐.
        代码：子类不用写，但是可以用.
    练习:exercise01.py
"""


# 多个类具有相同成员，且都属于一种更大（宽泛）的概念 --> 继承
# 设计角度讲：先有子，再有父亲.
# 编码角度讲：先有父亲，再有子.

class Person:
    def say(self):
        print("说话")


class Student(Person):
    # def say(self):
    #     print("说话")

    def study(self):
        print("学习")


class Teacher(Person):
    # def say(self):
    #     print("说话")

    def teach(self):
        print("教学")


# 测试：
s01 = Student()
s01.say()
s01.study()

p01 = Person()
p01.say()

t01 = Teacher()
t01.say()
t01.teach()

# 内置函数

# 对象 -->  类型
# 学生对象 是 一个学生类型 True
print(isinstance(s01,Student))
# 学生对象 是 一个人类型 True
print(isinstance(s01,Person))
# 学生对象 是 一个老师类型False
print(isinstance(s01,Teacher))

# 类型 -->  类型
# 学生类型 是 一个人类型 True
print(issubclass(Student,Person))
# 学生类型 是 一个老师类型 False
print(issubclass(Student,Teacher))

# 人对象 是 一个学生类型 False
print(isinstance(p01,Student))
# 人类型 是 一个学生类型 False
print(issubclass(Person,Student))

# 10:25 上课

# demo02

"""
    继承 -- 数据
    练习:exercise02.py
"""


class Person:
    def __init__(self, name=""):
        self.name = name

class Student(Person):
    def __init__(self, name="", score=0):
        # 结论：创建子类对象，必须手动调用父类构造函数。
        # 调用父类构造函数 -->  创建父类的数据
        super().__init__(name)
        self.score = score

s01 = Student("张无忌", 100)
print(s01.score)
print(s01.name)

# demo03

"""
    继承 -- 设计角度
"""


# 面向对象设计原则：
#   开闭原则：开放       关闭
#        允许增加新功能  不改变(增加/删除/修改)"以前"的代码

# 老张开车去东北
# 需求变化：火车、飞机、坦克...
class Person:
    def __init__(self, name=""):
        self.name = name

    def go_to(self, vehicle):
        print("去东北")
        # 如果参数是汽车
        if type(vehicle) == Car:
            vehicle.run()
        # 否则如果是飞机
        elif type(vehicle) == Airplane:
            vehicle.fly()


class Car:
    def run(self):
        print("汽车行驶")


class Airplane:
    def fly(self):
        print("飞机天上飞")


c01 = Car()
lz = Person()

a01 = Airplane()
lz.go_to(a01)

# demo04

"""
    继承 -- 设计角度
    15:20
"""


# 面向对象设计原则：
#   开闭原则：开放       关闭
#        允许增加新功能  不改变(增加/删除/修改)"以前"的代码

# 老张开车去东北
# 需求变化：火车、飞机、坦克...
class Person:
    def __init__(self, name=""):
        self.name = name

    def go_to(self, vehicle):
        print("去东北")
        # 调用抽象的交通工具，而不调用更具体的汽车、飞机.
        vehicle.transport()

class Vehicle:
    """
        抽象的 交通工具
    """
    def transport(self):
        pass

# -----------------------------------------------------

class Car(Vehicle):
    def transport(self):
        print("汽车行驶")


class Airplane(Vehicle):

    # ctrl + o
    # 重写(覆盖)
    def transport(self):
        print("飞机天上飞")


c01 = Car()
lz = Person()

a01 = Airplane()
lz.go_to(c01)

# demo06

"""
    继承时，子类可以super()调用方法.
"""


class Granade:
    def __init__(self, atk=0):
        self.atk = atk

    def explode(self, sufferer):
        print("手雷爆炸啦")
        sufferer.damage(self.atk)

class Sufferer:
    """
        抽象的受害者：隔离手雷与具体受害者的变化
    """

    def __init__(self, hp=0):
        self.hp = hp

    def damage(self, value):
        self.hp -= value

# ---------------------------
class Player(Sufferer):

    def damage(self, value):
        print("玩家受伤")  # 个性
        super().damage(value)  # 共性

class Enemy(Sufferer):

    def damage(self, value):
        print("敌人受伤啦")  # 个性
        super().damage(value)  # 共性

# 测试
g01 = Granade(50)
p01 = Player(500)
e01 = Enemy(100)

g01.explode(e01)
print(e01.hp)

# demo06

 1 """
 2     总结
 3         封装：分
 4         继承：隔
 5         多态：干
 6         开闭原则：运行增加新功能，不修改以前代码.
 7         依赖倒置：调用父类，不调用子。
 8 
 9         1. 老张开车去东北
10         封装：人类，汽车类，飞机类
11         继承：交通工具 隔离 汽车类，飞机类与人类。
12         多态：汽车类、飞机类 重写 交通工具的运输方法.
13         开闭原则：增加新的交通工具，不影响人类.
14         依赖倒置：人类调用交通工具，而不调用汽车、飞机.
15 
16         2. 手雷爆炸
17         封装：
18         继承：
19         多态：
20         开闭原则：
21         依赖倒置：
22 
23         3. 图形管理器
24         封装：
25         继承：
26         多态：
27         开闭原则：
28         依赖倒置：
29 """

 1 # exercise01
 2 """
 3     练习:
 4         创建三个类:
 5             狗类(跑)
 6             鸟类(飞)
 7             动物(吃)
 8         创建父类与子类对象，调用相关方法.体会 子类复用父类方法.
 9         体会isinstance 与 issubclass 的异同.
10 """
11 
12 
13 class Animal:
14     def eat(self):
15         print("吃")
16 
17 
18 class Dog(Animal):
19     def run(self):
20         print("跑")
21 
22 
23 class Bird:
24     def fly(self):
25         print("飞")
26 
27 
28 d01 = Dog()
29 d01.run()
30 d01.eat()
31 
32 a01 = Animal()
33 a01.eat()
34 
35 # 狗对象 是 是一种 动物类型
36 print(isinstance(d01, Animal))
37 # 狗类型 是一种 动物类型
38 print(issubclass(Dog, Animal))
39 # 狗对象 是 是一种 狗类型
40 print(isinstance(d01, Dog))
41 
42 # 狗对象 是 狗类型 True
43 print(type(d01) == Dog)
44 # 狗对象 是 动物类型  False
45 print(type(d01) == Animal)

# exercise02
"""
    练习:
        创建父类车(品牌，速度)
            子类电动车(电池容量,充电功率)
        创建父类对象，画出内存图。
        创建子类对象，画出内存图.
"""


class Car:
    def __init__(self, brand="", speed=0.0):
        self.brand = brand
        self.speed = speed


class Electrocar(Car):
    def __init__(self, brand="", speed=0.0, battery_capacity=0, charging_power=0):
        super().__init__(brand, speed)
        self.battery_capacity = battery_capacity
        self.charging_power = charging_power


c01 = Car("宝马", 200)
e01 = Electrocar("比亚迪", 200, 15000, 220)

# exercise03
"""
        场景：手雷爆炸了，可能伤害敌人、玩家生命.
        需求变化：还可能伤害房子、树、鸭子....
        要求：增加新事物，不影响手雷.
        体会：开闭原则
        画出架构设计图
"""

# 面向对象设计原则：
# 依赖倒置：调用抽象

class Granade:
    def __init__(self, atk=0):
        self.atk = atk

    def explode(self,sufferer):
        print("手雷爆炸啦")
        sufferer.damage(self.atk)

class Sufferer:
    """
        抽象的受害者：隔离手雷与具体受害者的变化
    """
    def damage(self,value):
        pass

# ---------------------------
class Player(Sufferer):

    def __init__(self, hp=0):
        self.hp = hp

    def damage(self, value):
        print("玩家受伤")
        self.hp -= value

class Enemy(Sufferer):

    def __init__(self, hp=0):
        self.hp = hp

    def damage(self, value):
        print("敌人受伤啦")
        self.hp -= value

# 测试
g01 = Granade(50)
p01 = Player(500)
e01 = Enemy(100)

g01.explode(e01)

# exercise04

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


# 17:15
class GraphicManager:
    def __init__(self):
        self.__list_graphic = []

    def add_graphic(self, target):
        self.__list_graphic.append(target)

    def calculate_total_area(self):
        sum_value = 0
        for item in self.__list_graphic:
            # 多态：
            # 调用的是图形计算面积方法
            # 执行的是圆形、矩形计算面积方法.
            sum_value += item.calculate_area()
        return sum_value

class Graphic:
    def calculate_area(self):
        """
            计算面积
        :return: 当天图形的面积
        """
        pass

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

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

class Rectanle(Graphic):
    def __init__(self, length=0, width=0):
        self.lenght = length
        self.width = width

    def calculate_area(self):
        return self.lenght * self.width

manager = GraphicManager()
manager.add_graphic(Circle(5))
manager.add_graphic(Rectanle(5, 6))
print(manager.calculate_total_area())

 1 # review
 2 
 3 """
 4 
 5 """
 6 
 7 
 8 class XXXController:
 9 
10     def add_student(self):
11         pass
12 
13 
14 class XXXView:
15     def __init__(self):
16         self.manager = XXXController()
17 
18     def input_student(self):
19         self.manager.add_student()
20 
21     def fun_xxx(self):
22         # self.manager.成员
23         pass
24 
25 
26 view = XXXView()
27 view.input_student()

 1 # 测试代码
 2 
 3 """
 4         场景：手雷爆炸了，可能伤害敌人、玩家生命.
 5         需求变化：还可能伤害房子、树、鸭子....
 6         要求：增加新事物，不影响手雷.
 7         体会：开闭原则
 8         画出架构设计图
 9 """
10 
11 # 面向对象设计原则：
12 # 依赖倒置：调用抽象
13 
14 class Granade:
15     def __init__(self, atk=0):
16         self.atk = atk
17 
18     def explode(self,sufferer):
19         print("手雷爆炸啦")
20         sufferer.damage(self.atk,sufferer.number)  
21         # 在这个地方付给sufferer.number ==self.number = number
22         # 如果子类中没__init__ 直接调用 父类的__init__
23         # 子类中有__init__ 间接调用 父类的super().__init__()
24         # 
25 
26 class Sufferer:
27     def __init__(self, hp=0, number=0):
28         self.hp = hp
29         self.number = number
30 
31     def damage(self, value,value1):
32         print("玩家受伤")
33         self.hp -= value
34         self.number += value1
35 
36 
37 
38     """
39         抽象的受害者：隔离手雷与具体受害者的变化
40     """
41 
42 
43 # ---------------------------
44 class Player(Sufferer):
45 
46     def damage(self, value,value1):
47         super().damage(value,value1)
48 
49 
50 #   def __init__(self, hp=0):
51   #      self.hp = hp
52 
53 
54 
55 
56 
57 
58 # 测试
59 g01 = Granade(50)
60 p01 = Player(500,6)
61 
62 
63 g01.explode(p01)
64 print(p01.number)

 

来源：https://www.cnblogs.com/xiaoliangliu86/p/11529638.html