Python基础（2）面向对象

面向对象 Object Oriented

一、概述

  面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。面向对象编程（OOP）具体说是一种程序开发方法，一种编程思想、范式。你可以粗滤的理解为，项目经理干的活就是面向对象，负责分配任务，而coder干的活就是面向过程，负责具体任务的实施细节。

1.面向过程：分析出解决问题的具体细节、步骤，然后逐步实现。

1. 公式：程序 = 算法 + 数据结构
2. 优点：所有环节、细节自己掌控。
3. 缺点：考虑所有细节，工作量大。
4. 找出解决问题的人，然后分配职责。

2.面向对象：找出解决问题的人，然后分配职责，不关注实施细节。

1.公式：程序 = 对象 + 交互

2.优点

(1) 思想层面：

-- 可模拟现实情景，更接近于人类思维。

-- 有利于梳理归纳、分析解决问题。

(2) 技术层面：

-- 高复用：对重复的代码进行封装，提高开发效率。

-- 高扩展：增加新的功能，不修改以前的代码。

-- 高维护：代码可读性好，逻辑清晰，结构规整。

3.缺点：学习曲线陡峭。

二、类和对象

1.类（class）：具有相同属性（实例变量）和行为（实例方法）的对象的抽象。实际上就是一种自定义的数据类型，类也有对应的类变量和类方法。

2.对象（instance）：类的具体实例，即归属于某个类别的”个体”。

3.属性和行为：类与类方法不同，对象与对象属性值不同。

1.类和对象的创建

（1）创建类

1.格式

class 类名（object）:

“””文档说明”””

def _init_(self，参数列表):

self.实例变量名= 参数（形参）

def  实例方法名(self，参数列表):

pass

2.说明

--   类名所有单词首字母大写，多个单词不用下划线隔开，采用驼峰体。

-- (object)是表示该类是从object类继承下来的，python3.x版本可省略。

-- __init__也叫构造函数，创建对象时被调用，也可以省略。

-- self绑定的是被创建的对象的内存地址，名称可以随意。

拓展：object类和type类的区别，即基类与元类的区别

1.object类是继承层面的：其他的类或者对象都是通过继承的关系，直接或者间接的继承了object，翻阅所有对象的族谱，最后一定会发现它们的老祖宗就是object。

1 >>>list.__base__    #Python为所有类都提供了一个__bases__属性，通过该属性可以查看该类的所有直接父类，该属性返回所有直接父类组成的元组
  (<class 'object'>,)
2 >>>type.__bases__
  (<class 'object'>,)
3 >>>object.__bases__   #object类是所有类的基类
  ()

2.type类是类创建对象层面的：python中一切皆对象，数据、对象是由str、list等数据类型和自定义类创建的，而所有数据类型和自定义类都是由元类创建的

1 >>> type(list)
  <class 'type'>
2 >>> type(object)
  <class 'type'>
3 >>> type(type)
  <class 'type'>    #type类是所有类的元类，但是其本身是由虚拟机创建的

（2）创建对象(实例化)

1.格式

变量 = 类名 (实参数列表)

2.说明

--  python中无处不对象，对象是python中对数据的一种抽象的表示

 

--  所有对象都有三种特性：id、类型、值

id：对象的内存地址，由变量关联，查看通过：id(变量)

类型：生成对象的模型，对应类名，查看通过：type(变量)

值：对象中存放的数据，对应实参列表，查看通过：变量.__dict__

 

--  每个对象都是由其对应的类创建出来的

拓展：与对象的创建，调用，删除相关的魔法方法：__new__()方法，__init__()方法，__call__()方法，__del__()方法

1.__new__()方法和__init__()方法：__new__()方法是一个类方法，在对象被创建的时候调用，该方法负责创建（实例化）一个对象。如果创建对象成功，该对象会自动的调用__init__()方法，对自身进行初始化，如果创建对象失败，没有对象了，自然也就没谁去调用__init__()方法了。

2.__call__()方法：如果类中定义了该方法，可以使对象成为像函数和类一样的可调用对象。

class Entity:
    '''
    调用实体来改变实体的位置。
    '''

    def __init__(self, size, x, y):
        self.x, self.y = x, y
        self.size = size

    def __call__(self, x, y):
        '''改变实体的位置'''
        self.x, self.y = x, y


e = Entity(1, 2, 3)  # 创建实例
print(e.__dict__)  # {'x': 2, 'y': 3, 'size': 1}
e(4, 5)  # 实例可以象函数那样执行，并传入x y值，修改对象的x y
print(e.__dict__)  # {'x': 4, 'y': 5, 'size': 1}

3.__del__()方法：是python垃圾回收机制的实际应用，当类中定义了该方法时，创建的对象的引用计数为0时该方法被调用

>>> class D(object):
    def __init__(self):
        print 'this is D.__init__()'
    def __del__(self):
        print 'this is D.__del__()'

>>> d = D()
this is D.__init__()
>>> d2 = d
>>> d3 = d
>>> 
>>> del d
>>> del d2
>>> del d3   #当对象的引用计数为0时自动触发__del__()方法
this is D.__del__()

 

2.实例成员

（1）实例变量

1.语法

(1) 定义：对象地址.变量名=数据值

(2) 调用：对象地址.变量名=数据值

2.说明

(1) 首次通过对象赋值为创建，再次赋值为修改。

(2) 通常在__init__构造函数中（self.实例变量名=形参）创建，创建对象时赋值。也可以在

(3) 每个对象存储一份，通过对象地址访问。

 3.作用：描述对象自身的数据。

 4.__dict__：对象的属性，用于存储自身实例变量（包括私有化变量）的字典。

（2）实例方法

1.语法

(1) 定义： def  方法名称(self, 形参列表):

方法体

(2) 调用： 对象地址.实例方法名(实参列表)

2.说明

(1) 定义时至少有一个形参，一般命名为"self"，用于绑定调用这个方法的对象地址，通过对象调用实例方法时self不用传参。

(2)每个对象共用一份，通过对象地址访问。不建议通过类名访问实例方法(对象与对象数据值不同，通过类名调用实例方法时，需要给self参数传参具体的对象)

3.作用：表示对象行为。

 

"""
    实例成员
        记住一句话:实例成员,使用对象地址访问.
"""
class Student:
    pass

s01 = Student()
# 定义实例变量: 对象.变量名 = 数据值
s01.name = "lennie"
print(s01.name)  #"lennie"
s02 = Student()
# print(s02.name)# AttributeError,因为s02指向的对象,没有创建过实例变量name
# 通过__dict__获取当前对象的所有实例变量
print(s01.__dict__)  #{'name': 'lennie'}
print(s02.__dict__)  #{}


class Student02:
    def __init__(self, name, height):
        self.name = name
        self.height = height

    # 实例方法
    def print_self(self):
        print(self.name,self.height)


s01 = Student02("lennie", 170)
s02 = Student02("ginger", 162)
# 建议:实例方法,通过对象地址访问.
s01.print_self()
# 不建议:Student02.print_self(),若没有传递对象地址,实例方法不能正确访问对象数据.
Student02.print_self(s02)

 

3.类成员

（1）类变量

1.语法

(1) 定义：在类中，方法外定义变量。

class 类名:

   变量名 = 表达式

(2) 调用：类名.变量名

      不建议通过对象访问类变量

2.说明

(1) 存储在类中。

(2)所有对象共享一份，可通过类或者对象直接调用。

3.作用：描述所有对象的共有数据。

（2）类方法

1.语法

(1) 定义：

    @classmethod

    def 方法名称(cls,形参列表):

         方法体

(2) 调用：类名.方法名(实参列表)

      不建议通过对象访问类方法

2.说明

(1) 至少有一个形参，一般命名为'cls'，用于绑定类的内存地址。

(2) 使用@classmethod修饰的目的是调用类方法时可以隐式传递类，即通过类名调用类方法时cls不需要传参。

(3) 类方法中不能访问实例成员，实例方法中可以访问类成员。

3.作用：操作类变量。

 

"""
    类成员,用类的地址去访问
"""
class ICBC:
    # 类变量:总行的钱
    total_money = 1000000
    # 类方法
    @classmethod
    def print_total_money(cls):
        # print(id(cls), id(ICBC))
        # cls : 存储当前类的地址
        # print("当前总行金额:",ICBC.total_money)
        print("当前总行金额:", cls.total_money)

    def __init__(self, name, money):
        self.name = name
        self.money = money
        # 从总行扣除当前支行的钱
        ICBC.total_money -= money


i01 = ICBC("天坛支行", 100000)
i02 = ICBC("陶然亭支行", 100000)
# 主流:通过类访问类成员
ICBC.print_total_money()  #"当前总行金额: 800000"
print(ICBC.total_money)   #800000
# 非主流:通过对象访问类成员
# print(i02.total_money)
# i02.print_total_money()

 

（3）静态方法

1.语法

(1) 定义：

    @staticmethod

    def 方法名称(形参列表):

            方法体

(2) 调用：类名.方法名(实参列表)

      不建议通过对象访问静态方法

2.说明

(1) 使用@ staticmethod修饰的目的是该方法不需要隐式传参数，即参数列表不含self，cls参数，其实就是个函数

(2) 静态方法不能访问实例成员和类成员

3.作用：定义常用的工具函数。

三、三大特征

1.封装

（1）数据角度讲

1.定义：将一些基本属性封装成共有属性，类的创建中的__init__初始化

2.优势：将数据与对数据的操作相关联，代码可读性（相比容器）更高（类是对象的模板）。

（2）行为角度讲

1. 定义：类外提供必要的功能，隐藏实现的细节，私有化操作

2. 优势：简化编程，使用者不必了解具体的实现细节，只需要调用对外提供的功能。

3. 私有成员：

(1) 作用：只有类内部可以直接访问，外部不能直接访问，可以对参数做检查，避免传入无效的参数

(2) 做法：__成员名

(3) 本质：障眼法，实际也可以访问。私有成员的名称被修改为：_类名__成员名，可以通过_dict_属性或dir函数查看。

class Coder:
    """
    私有成员的读和写操作
    """
    def __init__(self, name, age):
        self.name = name
        self.__age = age  #私有化方式一：私有成员命名采用双下划线开头
        # self.set_age(age)  #私有化方式二

    # 使用两个公开的方法获取和修改私有属性
    def get_age(self):
        return self.__age  # 类内部访问无限制

    def set_age(self, value):
        if 0 <= value <= 100:  # 检验数据的有效性，限制随意更改属性值
            self.__age = value
        else:
            raise ValueError

    age=property(get_age,set_age)  #无读写限制
    # age=property(get_age,None)  #写限制
    # age=property(None,set_age)  #读限制
    # age=property(None,None)  #读写均限制

c = Coder("lennie", 26)
# 1.私有成员不能直接访问
print(c.__age)  #AttributeError: 'Coder' object has no attribute '__age'
print(c.__dict__)  # {'name': 'lennie', '_Coder__age': 26}
# 2.可通过 对象._类名__成员名 访问(此种访问无限制)
c._Coder__age = 27
print(c._Coder__age)  # 27
# 3.可通过两个私有方法实现私有成员的读写(此种方式可限制私有成员被随意改写)
c.set_age(30)
print(c.get_age())  # 30
#4.可通过设置property（读方法名，写方法名），实现私有成员的读写
c.age=32
print(c.age)  #32

4.属性@property：

公开的实例变量，缺少逻辑验证。私有的实例变量与两个公开的方法相结合，又使调用者的操作略显复杂。而属性可以将两个方法的使用方式像操作变量一样方便。

(1) 定义：

@property             #允许读，等价于定义类变量：属性名=property（读方法名，None）

 

def 属性名(self):

return self.__属性名

@属性名.setter              #允许写，等价于定义类变量：属性名=property（读方法名，None）

def 属性名(self, value):

self.__属性名= value

(2) 调用：

对象.属性名 = 数据

变量 = 对象.属性名

(3) 说明：

• 通常两个公开的属性，保护一个私有的变量。
• @property 负责读取，@属性名.setter 负责写入
•  只写：属性名= property(None, 写入方法名)

class Coder:
    """
    @property和@私有成员名.setter
    """
    def __init__(self, name, age):
        self.name = name
        self.__age = age  #私有成员

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, value):
        if 0 <= value <= 100:  # 检验数据的有效性，限制随意更改属性值
            self.__age = value
        else:
            raise ValueError

c=Coder("lennie",26)
# print(c.__age)  #依然不能直接调用，AttributeError
#1.可直接由_类名__属性名调用
c._Coder__age=27
print(c._Coder__age)  #27
#2.避免使用两个方法的繁琐，使私有成员如变量般调用
c.age=30
# c.age=120   #ValueError
print(c.age)  #30

（3）设计角度讲

1. 定义：

(1) 分而治之

将一个大的需求分解为许多类，每个类处理一个独立的功能。 设计角度看类的创建应先考虑方法（行为，干什么），在考虑初始化（数据）

(2) 变则疏之  #拆分的度

变化的地方独立封装，避免影响其他类。

(3) 高 内 聚

类中各个方法都在完成一项任务(单一职责的类)。

(4) 低 耦 合    #低不是杜绝，是有互相调用才能完成

类与类的关联性与依赖度要低(每个类独立)，让一个类的改变，尽少影响其他类。

2.优势：

便于分工，便于复用，可扩展性强。

2.继承

（1）语法角度讲

• 继承方法

1. 语法:

class 父类:

def 父类方法(self):

    方法体

class 子类(父类)：

def 子类方法(self):

方法体

儿子 = 子类()

儿子.子类方法()

儿子.父类方法()

2.说明：子类直接拥有父类的方法.

• 内置函数

1. isinstance(对象, 类型) 返回bool值，判断对象是否是类的对象。
2. issubclass(类型1，类型2)返回bool值，判断类型1是否是类型2子类。

"""
    继承 -- 方法
        编程:代码不用子类写,但是可以用.
"""
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()

# "是不是 实例"
# s01的对象 是一种 Student类型
print(isinstance(s01,Student))# True
print(isinstance(s01,Person))# True    isinstance用于鉴定对象的直接模板以及其父模板
print(isinstance(s01,Teacher))# False

# s01的类型 等于 Student类型
print(type(s01) == Student)# True
print(type(s01) == Person)# False  type只能判定对象的直接模板

# Student 类型 是一种 Person类型
print(issubclass(Student,Person))# True
print(issubclass(Student,Student))# True
print(issubclass(Student,Teacher))# False   issubclass用于鉴定两个类是否有亲属关系

• 继承数据

1. 语法

class 子类(父类):

def __init__(self,参数列表):

super().__init__(参数列表)

self.自身实例变量 = 参数

2.说明

子类如果没有构造函数，将自动执行父类的，但如果有构造函数将覆盖父类的,此时必须通过super()函数调用父类的构造函数，以确保父类实例变量被正常创建。

• 定义

重用现有类的功能，并在此基础上进行扩展。子类直接具有父类的成员（共性），还可以扩展新功能。

"""
    继承 -- 数据
"""
class Person:
    def __init__(self, name=""):
        self.name = name

class Student(Person):
    def __init__(self, name="", score=0):
        # self.name = name
        # 如果子类没有构造函数,使用父类构造函数
        # 如果子类有构造函数,必须铜通过super()调用父类构造函数,
        # 否则会覆盖父类(不执行)的.
        super().__init__(name)
        self.score = score


# 创建实例变量
s01 = Student("lennie", 100)
print(s01.name)  #"lennie"
print(s01.score)  #100
p01 = Person("ginger")
print(p01.name)  #"ginger"
print(p01.score) #报错AttributeError，子直接继承父，但父不能调用子类成员

• 优点

一种代码复用的方式。

• 缺点

耦合度高：父类的变化，直接影响子类。

（2）设计角度讲

• 定义

将相关类的共性进行抽象，统一概念，隔离变化。类是对象的抽象，同理父类是子类的抽象。

• 适用性

多个类在概念上是一致的，且需要进行统一的处理。

 

"""
    继承 -- 设计角度。隔离变化
        老张开车去东北.
        需求变化:还可能坐飞机,坐火车......
"""


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

    def go_to(self,str_position,vehicle):
        #通过一个参数vehicle将对象传递进来，从而调用方法transport()，
　　　　　　　　鸭子类型的概念（此处传入的对象只要有transport()方法，就视为也是Vehicle类型，并非一定是其子类）
         print(self.name,vehicle.transport(),"去",str_position,sep="")


class Vehicle:
    """
        交通工具类，抽象的
        将共有的功能（运输）进行提取，供其子类对象继承复用
    """
    def transport(self):
        pass

# -------------------------------------隔离变化
class Car(Vehicle):

    def transport(self):
        return "坐车"

class Airplane(Vehicle):

    def transport(self):
        return "坐飞机"


c01 = Car()
a01 = Airplane()
lz = Person("老张")
lz.go_to("东北",c01)  #老张坐车去东北
lz.go_to("东北",a01)  #老张坐飞机去东北

 

 

• 相关概念

1. 父类（基类、超类）、子类（派生类）。
2. 父类相对于子类更抽象，范围更宽泛；子类相对于父类更具体（功能更强大），范围更狭小。
3. 单继承：父类只有一个（例如 Java，C#）。
4. 多继承：父类有多个（例如C++，Python）。
5. Object类：任何类都直接或间接继承自 object 类。

• 多继承

一个子类继承两个或两个以上的基类，父类中的属性和方法同时被子类继承下来。

MRO（Method Resolution Order）查看同名方法的解析顺序:print(D.mro)类自身 --> 父类继承列表（由左至右）--> 再上层父类

      A

     /   

    B     C

        /

      D

class A:
    pass
class B(A):
    pass
class C(A):
    pass
class D(B,C):
    pass

print(D.mro())#[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
print(C.mro())#[<class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
print(B.mro())#[<class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
print(A.mro())#[<class '__main__.A'>, <class 'object'>]

3.多态

（1）设计角度讲

• 定义

父类的同一种动作或者行为，在不同的子类上有不同的实现。

• 作用

1. 在继承的基础上，体现类型的个性化（一个行为有不同的实现）。
2. 增强程序扩展性，体现开闭原则。

（2）语法角度讲

• 重写

子类中定义（def）了父类中同名的方法（方法名、参数）。虽然该同名方法在子类中定义了，依然认为是父类的方法。

在调用该方法时，实际执行的是子类的方法。

• 快捷键

Ctrl + O

• 内置可重写函数

Python中，以双下划线开头、双下划线结尾的是系统定义的成员。我们可以在自定义类中进行重写，从而改变其行为。

• 转换字符串

__str__函数：将对象（打印时显示内存地址）转换为字符串（打印对象时显示自定义字符串）(对人友好的)

__repr__函数：将对象转换为字符串(解释器可识别的)

 

"""
    内置可重写函数
        自定义对象 -->  str
"""
class Car:
    def __init__(self, brand="", price=0,max_speed = 0):
        self.brand = brand
        self.price = price
        self.max_speed = max_speed

    # # 对人友好的,随心所欲的规定字符串内容-->将<__main__.Car object at 0x...>转换为自定义的字符串
    # def __str__(self):
    #     return "品牌是%s,单价是%d"%(self.brand,self.price)

    # 对解释器友好,根据python语法规定字符串内容-->功能同__str__()，但是更强大，通常与eval("")配合使用
    def __repr__(self):
        return "Car('%s',%d,%d)"%(self.brand,self.price,self.max_speed)

# 应用:将对象换成自定义的字符串显示出来
c01 = Car("宝马",1000000,260)
print(c01)  #"品牌是宝马,单价是1000000",会自动调用c01.__str__()方法
#当已经定义了__str__()时必须显式调用c01.__repr__()或者repr(c01)才会执行
print(c01.__repr__())  #"Car('宝马',1000000,260)"

 

拓展：eval("代码")函数

1. 功能：将字符串中的内容（去掉引号）直接作为代码运行
2. 参数：python代码格式的字符串，否则报错
3. 返回值：字符串内容代码的执行结果

>>> eval("1+2")
3
>>> eval("lennie")          #等价于在命令行直接输入lennie
NameError: name 'lennie' is not defined
>>> lennie
NameError: name 'lennie' is not defined
>>>

4.应用：eval("")函数与__repr__()方法配合使用，实现深拷贝对象

 

# 定义技能类(技能名称,攻击比例,持续时间)
# 创建技能对象,直接print对象.
# 克隆（深拷贝）技能对象,体会改变其中一个,不影响另外一个.

class Skill:
    def __init__(self, name="", atk_ratio=0.1, duration=0.1):
        self.name = name
        self.atk_ratio = atk_ratio
        self.duration = duration

    def __str__(self):
        return "%s---%d---%d" % (self.name, self.atk_ratio, self.duration)
 
    def __repr__(self):
        return "Skill('%s',%d,%d)" % (self.name, self.atk_ratio, self.duration)


s01 = Skill("佛怒火莲", 3, 5)
print(s01)     #佛怒火莲---3---5

# s02 = eval("Skill('佛怒火莲',3,5)")
s02 = eval(s01.__repr__())
s01.name = "焰分噬浪尺"
print(s02)     #佛怒火莲---3---5

 

• 运算符重载

定义：让自定义的类生成的对象(实例)，能够像str、int、list类型数据对象一样，使用运算符进行操作。

• • 算数运算符

• • 反向算数运算符重载

• • 复合运算符重载（不产生新对象）

• • 比较运算重载

"""
    运算符重载(重写)
"""

# 多态:调用父,执行子.
class Vector:
    """
        向量
    """

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

    def __str__(self):
        return "分量是:" + str(self.x)

    # 算数运算符 --> 返回新结果
    def __add__(self, other):
        """
             当前对象与其他数据相加时被自动调用
        :param other: 其他数据
        :return: 向量
        """
        # 如果other 是 向量
        if type(other) == Vector:
            return Vector(self.x + other.x)
        # 否则
        else:
            return Vector(self.x + other)

    def __rsub__(self, other):
        return Vector(other - self.x)

    # 复合运算符 --> 在原有对象基础上修改
    def __iadd__(self, other):
        self.x += other
        return self

    def __gt__(self, other):
        return self.x  > other.x

# 1. 算数运算符
v01 = Vector(10)
# 自定义向量 + 整数  -->  向量
print(v01 + 5)  # v01.__add__(5)
# 自定义向量 + 自定义向量  -->  向量
v02 = Vector(2)
print(v01 + v02)

# 2. 反向算数运算符
# 整数 - 自定义向量 --> 向量
print(5 - v01)  # v01.__rsub__(5)

"""
list01 = [1]

# print(id(list01))
list01 += [2]# 在原有基础上增加新元素
# print(id(list01))

# print(id(list01))
list01 = list01 + [3]# 产生新的对象
# print(id(list01))

print(list01)
"""

# 3. 复合运算符
#       默认使用算数运算符
print(id(v02))
v02 += 3  # v02 = v02 + 3
print(v02)
print(id(v02))

# 4. 比较运算符
# 自定义类 > 自定义类
print(v01 > v02)# v01.__gt__(v02)

四、六大设计原则

1.开-闭原则（目标、总的指导思想）

Open Closed Principle

对扩展开放，对修改关闭。

增加新功能，不改变原有代码。

2.类的单一职责（一个类的定义）

Single Responsibility Principle   

一个类有且只有一个改变它的原因。

3.依赖倒置（依赖抽象）

Dependency Inversion Principle

客户端代码(调用的类)尽量依赖(使用)抽象。

抽象不应该依赖细节，细节应该依赖抽象。

4.组合复用原则（复用的最佳实践）

Composite Reuse Principle

如果仅仅为了代码复用优先选择组合复用，而非继承复用。

组合的耦合性相对继承低。

5.里氏替换（继承后的重写，指导继承的设计）

Liskov Substitution Principle

父类出现的地方可以被子类替换，在替换后依然保持原功能。

子类要拥有父类的所有功能。

子类在重写父类方法时，尽量选择扩展重写，防止改变了功能。在Ctrl+o时，别删东西，重写后扩展重写

6.迪米特法则（类与类交互的原则）

Law of Demeter

不要和陌生人说话。

类与类交互时，在满足功能要求的基础上，传递的数据量越少越好。因为这样可能降低耦合度（利用抽象去调用子类，隔离变化）。

"""
    面向对象的应用:
        定义员工管理器,记录所有员工,计算总工资.
        程序员:底薪 + 项目分红
        测试员:底薪 + bug * 5
        要求:增加新的岗位,不影响员工管理器.
        指出:三大特征,六个原则.

        封装:员工管理器,程序员,测试员
        继承:员工隔离员工管理器与具体员工的变化
        多态:员工管理器调用员工,执行程序员,测试员.
        开闭:增加新的岗位,不影响员工管理器.
        单一:员工管理器(管理员工),员工(隔离变化),程序员(计算薪资),测试员(计算薪资)
        依赖倒置:员工管理器调用员工,而不调用程序员/测试员
        组合复用:员工管理器存储具体员工的变量
　　　　　　 里氏替换：程序员（继承员工底薪后添加奖金），测试员（继承员工底薪后添加bug提成）
　　　　　　 迪米特法则：员工管理器与程序员，测试员的交互，改由与员工交互，减少了数据的传递

"""


class EmployeeManager:
    """
        员工管理器
    """

    def __init__(self):
        self.__all_employee = []

    def add_employee(self, emp):
        # 判断 emp 是员工 则 添加....?
        # if type(emp) == Employee:
        # emp 属于 员工
        if isinstance(emp, Employee):
            self.__all_employee.append(emp)

    def get_total_salary(self):
        total_sarlay = 0
        for itme in self.__all_employee:
            # 调用的是员工
            # 执行的是程序员/测试员
            total_sarlay += itme.calculate_salary()
        return total_sarlay


class Employee:
    """
        员工
        抽象的 --> 统一概念 --> 隔离变化

    """

    def __init__(self, base_salary):
        self.base_salary = base_salary

    def calculate_salary(self):
        """
            计算薪资
        :return: 小数类型的薪资
        """
        return self.base_salary


class Programmer(Employee):
    """
        程序员
    """

    def __init__(self, base_salary=0, bonus=0):
        super().__init__(base_salary)
        self.bonus = bonus

    def calculate_salary(self):
        # return self.base_salary + self.bonus
        return super().calculate_salary() + self.bonus


class Tester(Employee):
    def __init__(self, base_salary=0, bug_count=0):
        super().__init__(base_salary)
        self.bug_count = bug_count

    def calculate_salary(self):
        return super().calculate_salary() * self.bug_count * 5

    # def calculate_salary(self):
    #     return self.base_salary * self.bug_count * 5

manager = EmployeeManager()
p01 = Programmer(32000, 50000)
manager.add_employee(p01)
manager.add_employee(Tester(8000, 2))
print(manager.get_total_salary())