python面向对象进阶-继承、多态（python中面向对象编程）
python面向对象进阶-继承、多态
继承
python面向对象的继承指的是多个类之间的所属关系，及子类默认继承父类的所有属性和方法
#父类A
class A(object):
def __init__(self):
self.num = 1
#定义成员函数：方法
def info_print(self):
print(self.num)#子类，继承父类
class B(A):
pass# 3.创建对象验证结论
result = B()
result.info_print() #1在python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。
单继承
单个子类继承单个父类所有属性和方法
#1.师傅类，属性和方法
class Master(object):
def __init__(self):
self.kongfu = '【古法煎饼果子配方】'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')#2.定义徒弟类
class Prentice(Master):
pass#3.创建对象daqiu
daqiu = Prentice()#4.对象访问实例属性
print(daqiu.kongfu)
daqiu.make_cake()多继承
所谓多继承意思就是一个类同时继承了多个父类
#1.师傅类，属性和方法
class Master(object):
def __init__(self):
self.kongfu = '【古法煎饼果子配方】'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#添加school类
class School(object):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')#2.定义徒弟类,按调用顺序来作为第一个父类，显示同名函数和属性
#继承多个父类
class Prentice(Master,School):
pass
#用徒弟类，继承师傅类
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()注意：当一个类有多个父类的时候，默认使用第一个父类的同名属性和方法（不是按定义顺序排序，而是调用顺序）
子类重写父类同名方法和属性
以上代码修改子类，重写属性和函数即可
#2.定义徒弟类,按调用顺序来作为第一个父类，显示同名函数和属性
#继承多个父类 添加和父类同名的属性和方法
class Prentice(Master,School):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')注意：如果子类和父类拥有同名属性，子类创建对象调用属性和方法的时候，调用到的是子类里面的同名属性和方法
通过_mro_显示继承层级顺序
print(子类.__mro__)
显示了子类的继承关系
子类调用父类的同名方法
#1.师傅类，属性和方法
class Master(object):
def __init__(self):
self.kongfu = '【古法煎饼果子配方】'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#添加school类
class School(object):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')#2.定义徒弟类,按调用顺序来作为第一个父类，显示同名函数和属性
#继承多个父类 添加和父类同名的属性和方法
class Prentice(Master,School):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
def make_cake(self):
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
#子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
def make_master_cake(self):
#父类类名.函数（）
#再次调用初始化的原因：这里想要调用父类的同名方法和属性，
# 属性在init初始化位置，所以需要再次调用init
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
School.__init__(self)
School.make_cake(self)
#用徒弟类创建对象，调用实例属性和方法
daqiu = Prentice()
daqiu.make_cake()
daqiu.make_master_cake()
daqiu.make_school_cake()
daqiu.make_cake()多层继承
#1.师傅类，属性和方法
class Master(object):
def __init__(self):
self.kongfu = '【古法煎饼果子配方】'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#添加school类
class School(object):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')#2.定义徒弟类,按调用顺序来作为第一个父类，显示同名函数和属性
#继承多个父类 添加和父类同名的属性和方法
class Prentice(Master,School):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
def make_cake(self):
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
#子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
def make_master_cake(self):
#父类类名.函数（）
#再次调用初始化的原因：这里想要调用父类的同名方法和属性，
# 属性在init初始化位置，所以需要再次调用init
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
School.__init__(self)
School.make_cake(self)#1.创建Tusun，用这个类创建对象；2.用这个对象调用父类的属性或方法看是否能成功。
class Tusun(Prentice):
pass
xiaoqiu = Tusun()
xiaoqiu.make_cake()
xiaoqiu.make_master_cake()
xiaoqiu.make_school_cake()使用super()调用父类方法
当需要一次性调用父类：类一、类二的时候可以使用super()函数
作用：减少代码冗余，提高扩展性
带参与不带参数super()写法
#1.师傅类，属性和方法
class Master(object):
def __init__(self):
self.kongfu = '【古法煎饼果子配方】'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#添加school类
class School(Master):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#2.1 super()带参数写法
# super(School, self).__init__()
# super(School, self).make_cake()
#2.2 无参数的super()
super().__init__()
super().make_cake()#2.定义徒弟类,按调用顺序来作为第一个父类，显示同名函数和属性
#继承多个父类 添加和父类同名的属性和方法
class Prentice(School):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
def make_cake(self):
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
#子类调用父类的同名方法和属性：把父类的同名属性和方法再次封装
def make_master_cake(self):
#父类类名.函数（）
#再次调用初始化的原因：这里想要调用父类的同名方法和属性，
# 属性在init初始化位置，所以需要再次调用init
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
School.__init__(self)
School.make_cake(self)
#需求：一次性调用父类Shool Master的方法
#先定义一个类
def make_old_cake(self):
#方法一
#2.1 super(当前类明，self).函数()
# super(Prentice, self).__init__()
# super(Prentice, self).make_cake()
#2.2 无参数super()
super().__init__()
super().make_cake()
xiaoqiu = Prentice()
xiaoqiu.make_old_cake()私有属性
当想保留自己的密码不继承给别人时，就可以设置私有属性。
定义私有属性和方法
在属性名和方法名前加两条下划线__即可
如：
#定义私有属性：在属性名前加两条下划线__即可
self.__money = 2000000
#定义私有方法: 在方法名前加两条下划线__即可
def __info_print(self):
print("这是私有方法")
获取和修改私有属性值
在python中一般定义函数名get_xx用来获取私有属性，定义set_xx用来修改私有属性值。
#定义函数，获取私有属性值get_xx
def get_money(self):
return self.__money
#定义函数：修改私有属性值 set_xx
def set_money(self):
self.__money = 5000
#调用验证
xiaoqiu = Tusun()
print(xiaoqiu.get_money())
xiaoqiu.set_money()
print(xiaoqiu.get_money())继承总结：
特点：
子类默认拥有父类的所有属性和方法
子类重写父类同名方法和属性
子类调用父类同名方法和属性
super()方法快速调用父类方法
私有权限
不能继承给子类的属性和方法需要添加私有权限
私有权限语法
class 类名():
#私有属性
__属性名 = 值
#私有方法
def __函数名(self):
代码
面向对象—多态
多态：
指的是一类事物有多种形态。（一个抽象类有多个子类，因而多态的概念依赖于继承）。
定义：
多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果
好处：
调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化！
实现步骤：
定义父类，并提供公共方法
定义子类，并重写父类方法
传递子类对象给调用者，可以看到不同子类执行效果不同
案例
#警务人员和警犬一起工作，警犬2分钟：
# 追击敌人和毒品追查，携带不同的警犬，执行不同的工作
#1.定义狗的父类，子类重写父类方法：
class Dog(object):
def work(self):
pass#2.定义2个狗类表示不同的警犬，子类重写父类方法：
class ArmDog(Dog):
def work(self):
print("追击敌人...")
class DrugDog(Dog):
def work(self):
print("追查毒品...")
#定义人类
class Person(object):
def work_with_dog(self,dog):
dog.work()#3.创建对象·调用不同的功能传入不同的对象，观察执行的结果
ad = ArmDog()
dd = DrugDog()
daqiu = Person()
daqiu.work_with_dog(ad) #追击敌人...
daqiu.work_with_dog(dd) #追查毒品...类属性和实例属性
类属性
设置和访问类属性
类属性就是类对象所拥有的属性，它被该类的所有实例对象所共有。
类属性可以使用类对象或实例对象访问。
案例：
#1.定义类，定义类属性
class Dog(object):
tooth = 10#2.创建对象
wangcai = Dog()
xiaohei = Dog()#3.使用类和对象访问类属性
print(Dog.tooth) #10
print(wangcai.tooth) #10
print(xiaohei.tooth) #10类属性优点：
记录的某项数据始终保持一致时，则定义类属性。
实例属性 要求 每个对象为其 单独开辟一份内存空间来记录数据。
类属性 为全类共有，仅占一份内存，更加节省内存空间。
修改类属性
class Dog(object):
tooth = 10
wangcai = Dog()
xiaohei = Dog()
#1. 类 类.类属性 = 值
# Dog.tooth = 20
# print(Dog.tooth)
#
# #使用对象获取属性值
# print(wangcai.tooth)
# print(xiaohei.tooth)#2.测试通过对象修改类属性
wangcai.tooth = 200 #实际是为wangcai添加了实例属性
print(Dog.tooth) #10
print(wangcai.tooth) #200
print(xiaohei.tooth) #10注意：
类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例属性。
类方法和静态方法
类方法特点
需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数。
类方法使用场景
当方法中需要使用类对象（如访问私有类属性等）时，定义类放方法
类方法一般和类属性配合使用
#1.定义类：私有类属性，类方法获取这个私有类属性
class Dog(object):
__tooth = 10
#定义类方法
@classmethod
def get_tooth(cls):
return cls.__tooth#2.创建对象，调用类方法
wangcai = Dog()
result = wangcai.get_tooth()
print(result) #10静态方法特点
需要通过装饰器@staticmethod来进行装饰，静态方法既不需要传递类对象也不需要传递实例对象（形参没有self/cls）。
静态方法 也能够通过 实例对象和类对象访问。
使用场景
当方法中既不需要使用实例对象（如实例对象，实例属性），也不需要使用类对象（如类属性、类方法、创建实例时等）时，就定义类方法。
取消不需要的参数传递，有利于减少不必要的内存占用和性能消耗。
#1.定义类，定义静态方法
class Dog(object):
@staticmethod
def info_print():
print("这是一个静态方法")
#创建对象
wangcai = Dog()#2. 调用静态方法：类 和 对象
wangcai.info_print()
Dog.info_print()总结：
类方法语法：
@classmethod
def类名():
代码
静态方法语法：
@staticmethod
def类名():
代码