python_day12(笔记及练习)

封装
数据角度讲
1. 定义：
将一些基本数据类型复合成一个自定义类型。
2. 优势：
将数据与对数据的操作相关联。
代码可读性更高（类是对象的模板）。
行为角度讲
1. 定义：
类外提供必要的功能，隐藏实现的细节。
2. 优势：
简化编程，使用者不必了解具体的实现细节，只需要调用对外提供的功能。
3. 私有成员：
(1) 作用：无需向类外提供的成员，可以通过私有化进行屏蔽。
(2) 做法：命名使用双下划线开头。
(3) 本质：障眼法，实际也可以访问。
私有成员的名称被修改为：_类名__成员名，可以通过_dict_属性或dir函数查看。
4. 属性@property：
公开的实例变量，缺少逻辑验证。私有的实例变量与两个公开的方法相结合，又使调用者的操作略显复杂。而属性可以将两个方法的使用方式像操作变量一样方便。
(1) 定义：
@property
def 属性名(self):
return self.__属性名
@属性名.setter
def 属性名(self, value):
self.__属性名= value
(2) 调用：
对象.属性名 = 数据
变量 = 对象.属性名
(3) 说明：
通常两个公开的属性，保护一个私有的变量。
@property 负责读取，@属性名.setter 负责写入
只写：属性名= property(None, 写入方法名)
设计角度讲
1. 定义：
(1) 分而治之
将一个大的需求分解为许多类，每个类处理一个独立的功能。
(2) 变则疏之
变化的地方独立封装，避免影响其他类。
(3) 高 内 聚
类中各个方法都在完成一项任务(单一职责的类)。
(4) 低 耦 合
类与类的关联性与依赖度要低(每个类独立)，让一个类的改变，尽少影响其他类。
2. 优势：
便于分工，便于复用，可扩展性强。

继承
语法角度讲
继承方法
1. 代码:
class 父类:
def 父类方法(self):
方法体

class 子类(父类)：
def 子类方法(self):
方法体

儿子 = 子类()
儿子.子类方法()
儿子.父类方法()

2. 说明：

子类直接拥有父类的方法.
内置函数
isinstance(对象, 类型)
返回指定对象是否是某个类的对象。
issubclass(类型，类型)
返回指定类型是否属于某个类型。
继承数据
1. 代码
class 子类(父类):
def init(self,参数列表):
super().init(参数列表)
self.自身实例变量 = 参数
2. 说明
子类如果没有构造函数，将自动执行父类的，但如果有构造函数将覆盖父类的。此时必须通过super()函数调用父类的构造函数，以确保父类实例变量被正常创建。
定义
重用现有类的功能，并在此基础上进行扩展。
说明：子类直接具有父类的成员（共性），还可以扩展新功能。
优点
一种代码复用的方式。
缺点
耦合度高：父类的变化，直接影响子类。
设计角度讲
定义
将相关类的共性进行抽象，统一概念，隔离变化。
适用性
多个类在概念上是一致的，且需要进行统一的处理。
相关概念
父类（基类、超类）、子类（派生类）。
父类相对于子类更抽象，范围更宽泛；子类相对于父类更具体，范围更狭小。
单继承：父类只有一个（例如 Java，C#）。
多继承：父类有多个（例如C++，Python）。
Object类：任何类都直接或间接继承自 object 类。
多继承
一个子类继承两个或两个以上的基类，父类中的属性和方法同时被子类继承下来。
同名方法的解析顺序（MRO， Method Resolution Order）:
类自身 --> 父类继承列表（由左至右）–> 再上层父类
A
/
/
B C
\ /
\ /
D
多态
设计角度讲
定义
父类的同一种动作或者行为，在不同的子类上有不同的实现。
作用
1. 在继承的基础上，体现类型的个性化（一个行为有不同的实现）。
2. 增强程序扩展性，体现开闭原则。
语法角度讲
重写
子类实现了父类中相同的方法（方法名、参数）。
在调用该方法时，实际执行的是子类的方法。
快捷键
Ctrl + O
内置可重写函数
Python中，以双下划线开头、双下划线结尾的是系统定义的成员。我们可以在自定义类中进行重写，从而改变其行为。
转换字符串
__str__函数：将对象转换为字符串(对人友好的)
__repr__函数：将对象转换为字符串(解释器可识别的)
运算符重载
定义：让自定义的类生成的对象(实例)能够使用运算符进行操作。

"""
    复习
        封装
            数据：多  -->  一
            行为：隐藏 --> 对外提供必要
            思想：
                分而治之：将需求分为多个类
                变则疏之：单独定义行为变化
                高内聚：类中各个方法都在完成一件事情
                       有且只有一个改变的原因
                低耦合：互不影响
"""


# 需求：存储新学生
#  界面逻辑         核心逻辑
#  input           append


# 写法1
# class A:
#     def func01(self):
#         b = B()
#         b.func02()
#
# class B:
#     def func02(self):
#         pass

# 写法2
# class A:
#     def __init__(self):
#         self.b = B()
#
#     def func01(self):
#         self.b.func02()
#
# class B:
#     def func02(self):
#         pass

# 写法3
class A:
    def func01(self, b):
        b.func02()

class B:
    def func02(self):
        pass

a = A()
b = B()
a.func01(b)

"""
    继承语法 -- 方法
       财产：钱不用孩子挣,但是可以花.
       皇位：江山不用孩子打,但是可以坐.
       代码：代码不用子类写,但是可以用.
"""


# 设计角度：现有子，再有父.
# 编码角度：现有父，再有子.

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


class Student(Person):
    def study(self):
        print("学习")


class Teacher(Person):
    def teach(self):
        print("教学")


# 创建父类对象
p01 = Person()
# 只能访问父类成员
p01.say()

# 创建子类对象
s01 = Student()
# 既能访问父类成员，也能访问子类成员
s01.say()
s01.study()

t01 = Teacher()
# 不能访问兄弟类成员
# t01.study()

# 内置函数
# ?对象 是一种?类型
# 人对象是一种人类型
print(isinstance(p01, Person))  # True
# 学生对象是一种人类型
print(isinstance(s01, Person))  # True
# 人对象是一种学生类型
print(isinstance(p01, Student))  # False
# 学生对象是一种老师类型
print(isinstance(s01, Teacher))  # False

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

# ?类型是?类型
# 人(对象的)类型是人类型
print(type(p01) == Person)  # True
# 学生类型是人类型
print(type(s01) == Person)  # False

"""
    继承语法 -- 数据 
"""
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.name)

# 需求：老张开车去东北
# 变化点：飞机、火车、轮船...
# 违反面向对象设计原则
#   开闭原则：允许增加新功能,但是不允许改变之前的代码.
#            对扩展开放，对修改关闭
#   依赖倒置：使用

class Person:
    def go_to(self, vehicle, postion):
        print("去", postion)
        if type(vehicle) == Car:
            vehicle.run()
        elif type(vehicle) == Airplane:
            vehicle.fly()


class Car:
    def run(self):
        print("嘟嘟嘟...")


class Airplane:
    def fly(self):
        print("嗖嗖嗖...")


p01 = Person()
c01 = Car()
a01 = Airplane()
p01.go_to(c01, "东北")
p01.go_to(a01, "东北")

"""
    继承设计思想
"""


# 需求：老张开车去东北
# 变化点：飞机、火车、轮船...
# 违反面向对象设计原则
#   开闭原则：允许增加新功能,但是不允许改变之前的代码.
#            对扩展开放，对修改关闭
#   依赖倒置：使用
# 多态
#     调用父一个方法,在不同的子类上有不同的实现。
#

class Person:
    def go_to(self, vehicle, postion):
        print("去", postion)
        # 用交通工具的运输功能
        vehicle.transport()

class Vehicle:
    """
        交通工具
    """
    def transport(self):
        pass
# ---------------------------------------

class Car(Vehicle):

    def transport(self):
        print("嘟嘟嘟...")

class Airplane(Vehicle):

    def transport(self):
        print("嗖嗖嗖...")


p01 = Person()
c01 = Car()
a01 = Airplane()
p01.go_to(c01, "东北")
p01.go_to(a01, "东北")

"""
    手雷爆炸,伤害玩家、敌人生命.
    变化点：还可能伤害房子,鸭子....
    要求：增加新事物,不影响手雷类.
    体会：开闭原则、依赖倒置、继承(设计思想)、多态(设计思想)
                 强调调用谁             强调执行/实现子类不同逻辑
"""

class Granade:
    """
        手雷
    """

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

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

class Target:
    def damage(self, value):
        pass


# ------------------------------------------
class Player(Target):
    def __init__(self, hp=0):
        self.hp = hp

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

class Enemy(Target):
    def __init__(self, hp=0):
        self.hp = hp

    def damage(self, value):
        print("敌人受伤,掉下装备")
        self.hp -= value

g01 = Granade()
g01.explode(Player())
g01.explode(Enemy())

"""
    创建图形管理器
        记录所有图形
        提供计算所有图形总面积的功能
    圆形：pi * r ** 2
    矩形:l * w
    ...
    要求：增加新图形,管理器不变.
    写出体现：
        三大特征
            封装：根据需求分为图形管理器、圆形、矩形.
            继承：创建图形类,隔离图形管理器与具体图形的变化
            多态：图形管理器计算面积时，调用图形,执行圆形、矩形计算方法。
                  通过重写做计算面积方法
        设计原则
            开闭原则：增加新图形,图形管理器不变.
            依赖倒置：调用图形,不调用圆形、矩形.

"""
class GraphicManager:
    def __init__(self):
        self.__list_graphics = []

    def add_graphics(self, graphic):
        self.__list_graphics.append(graphic)

    def get_total_area(self):
        total_area = 0
        for item in self.__list_graphics:
            total_area += item.calculate_area()
        return total_area

class Graphic:
    def calculate_area(self):
        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, l = 0,w = 0):
        self.l = l
        self.w = w

    def calculate_area(self):
        return self.l * self.w

manager = GraphicManager()
manager.add_graphics(Circle(5))
manager.add_graphics(Rectanle(2,3))
print(manager.get_total_area())