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类名():

代码