Python基础——继承、多态

一、slots

• __slots__属性对应的是元组类型的值
• 规定对象可以使用的属性，只有在元组里出现的值，才能设置给对象

class Person(object):

    __slots__ = ('name', 'age') # 要的是一个元祖（ ）

    def __init__(self, name, age):
        self.name = name
        self.age = age

p = Person('zhangsan', 18)  # 对象P，有姓名和年龄属性
p.addr = '上海'

# 会报错AttributeError: 'Person' object has no attribute 'addr'，要想不报错，需要把addr加入至slots参数中
# 如果没有__slots__方法，不会报错，因为python支持动态类型，加属性是OK的

二、私有属性和私有方法

• 1、私有属性：添加两个下划线（self.__money），这种属性我们称之为私有属性，只能在内部访问，不能在外部访问
• 使用内部方法可以访问，返回该私有属性return self.__money
• print(p._Person__money)可以使用 对象名._类名__私有属性名 来强制访问私有属性，不建议使用该方式
• 2、私有方法：私有方法使用 __ 开始，定义的私有方法__demo只让内部使用，外部无法访问
• p._Person__demo() 可以通过对象名._类名__私有方法名强制访问，不建议使用该方式

import time

class Person(object):
    def __init__(self, name, age, money):
        self.name = name
        self.age = age
        # 添加两个下划线，这种属性我们称之为私有属性，只能在内部访问，不能在外部访问
        self.__money = money

    def get_money(self):  # 内部可以访问money，然后外部再调用该方法，作为一个接口（连接内外）
        print('{}查询余额了！！！！'.format(time.asctime()))  # 查询余额时间
        return self.__money

    def set_money(self, money):
        print('修改余额了！！！')
        self.__money = money

    def test(self):
        self.__demo()
        print('加密以后的代码1')
        print('加密以后的代码2')
        print('加密以后的代码3')
        print('加密以后的代码4')
        print('加密以后的代码5')
        print('我是person里的test函数')

    def foo(self):  # 定义的私有方法__demo只让内部使用
        self.__demo()

    # 私有方法使用 __ 开始
    def __demo(self):
        print('加密第1步')
        print('加密第2步')
        print('加密第3步')
        print('加密第4步')
        print('加密第5步')
        print('加密第6步')
        print('加密第7步')


p = Person('zhangsan', 18, 2000)
p.test()
print(p.get_money())

# p.__demo()  私有方法，外部无法访问
# p._Person__demo()  可以通过对象名._类名__私有属性名强制访问，不建议使用该方式

p.set_money(1500)
print(p.get_money())

# 如果想要访问私有属性，可以使用  对象名._类名__私有属性名  来强制访问
# print(p._Person__money)   # 强烈不推荐使用这种方式来访问私有属性

# 私有属性 __money 在外部不能直接访问
# print(p.__money)
# p.__money -= 500
# print(p.__money)

三、继承

1、私有属性、私有方法

• 私有属性不会被子类继承；
• 私有方法也不会被子类继承；
• Student 类继承自 Person 类，就可以使用Person类里的方法；
• s 对象还可以调用自己类的方法

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.money = 1000
        self.__xxx = 'hello'  # 私有属性

    def eat(self):
        print(self.name + '正在吃饭')

    def sleep(self):
        print(self.name + '正在睡觉')

    def __foo(self):
        print('fooooooooooooooooooooooooooo')


class Student(Person):
    # def __init__(self, name, age, school):
    #     self.name = name
    #     self.age = age
    #     self.school = school

    def study(self):
        # print(self.__xxx)    私有属性不会被子类继承
        # self.__foo()  私有方法也不会被子类继承
        print(self.name + '正在学习')


# s = Student('zhangsan', 18, '春天花花幼稚园')
s = Student('zhangsan', 18)
print(s.money)  # 1000

# Student 类继承自 Person 类，就可以使用Person类里的方法
s.eat()

# s 对象还可以调用自己类的方法
s.study()

2、继承的特点（多层继承）

父类（基类）、子类（派生类）

• 当调用一个对象的属性或者方法时，会按照__mro__属性指定的属性查找，如果找到了就直接停止；如果最后都没找到，就报错！！！

class Animal(object):
    def eat(self):
        print('动物正在吃东西')

    def sleep(self):
        print('动物正在睡觉')

    def demo(self):
        print('我是animal里的demo方法')


class Person(Animal):
    def drive(self):
        print('人正在开车')

    def make_money(self):
        print('挣了一点点点点钱')


class Dog(Animal):
    def bark(self):
        print('狗正在叫')


class RichPeople(Animal):
    def make_money(self):
        print('富人挣了好多好多好多钱')


class Boss(object):
    def offer(self):
        print('老板把公司给你了')

    def demo(self):
        print('我是boss里的demo方法')


class Student(RichPeople, Person, Boss):  # 多继承
    def study(self):
        print('学生正在学习')


class Teacher(Person):
    def teach(self):
        print('老师正在上课')


s = Student()  # 实例化一个对象s
s.study()
s.drive()
s.eat()
s.make_money()
s.offer()
s.demo()  # 我是animal里的demo方法，会按照父类顺序调用
s.xxx()  # 会报错，因为所有父类都没有该方法

# (<class '__main__.Student'>, <class '__main__.RichPeople'>, <class '__main__.Person'>, <class '__main__.Animal'>, <class '__main__.Boss'>, <class 'object'>)
# 当调用一个对象的属性或者方法时，会按照  __mro__ 属性指定的属性查找，如果找到了就直接停止；如果最后都没找到，就报错！！！
print(Student.__mro__)

3、新式类和经典类

新式类:继承自object的类是新式类
经典类: 没有继承自object的类
在python3以后，如果创建一个类不指定父类，默认继承自object,python3没有经典类

class Person(object):
    def test(self):
        print('hello')

p = Person()
p.test()
print(Person.__mro__)  # (<class '__main__.Person'>, <class 'object'>)

四、方法的重写

• 子类在父类的基础上又扩展了自己的功能：父类名.函数名(参数)，此时需要传参数self
• 即在调用子类test方法前，先调用父类的test方法，即子类扩展了父类的方法，先调父类的方法，再做子类的实现
• super().函数名()

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.money = 1000

    def test(self):
        print(self.name + ' say hello')

class Student(Person):
    def __init__(self, name, age, school):
        # 子类在父类的基础上又扩展了自己的功能
        # 父类名.函数名(参数)
        # Person.__init__(self, name, age)

        # super().函数名()
        super().__init__(name, age)
        self.school = school

    def study(self):
        print('学生正在学习')

    def test(self):
        # Person.test(self)  # 
        super().test()  # 在调用子类test方法前，先调用父类的test方法，即子类扩展了父类的方法，先调父类的方法，再做子类的实现
        print('hehe')


s = Student('zhangsan', 18, '春田花花幼稚园')
print(s.money)
s.test()  # zhangsan say hello hehe此时先调用的是父类的test方法，后调用子类的test方法
# s.study()

五、多态

多态：不同的子类对象，调用相同的父类方法，得到的结果可能不一样

#  1、不使用多态时

class SearchDog(object):
    def sd_work(self):
        print('搜救犬正在搜索生命')

class PoliceDog(object):
    def pd_work(self):
        print('警犬正在抓坏人')

class FlyDog(object):
    def fd_work(self):
        print('飞天犬正在飞')

class Person(object):
    def __init__(self, dog=None):
        self.dog = dog

    def work_with_sd(self):
        self.dog.sd_work()

    def work_with_pd(self):
        self.dog.pd_work()

    def work_with_fd(self):
        self.dog.fd_work()


p = Person()

sd = SearchDog()
pd = PoliceDog()
fd = FlyDog()

p.dog = sd  # 换一条狗就得换相应的方法
p.work_with_sd()

#  2、使用多态时
class Dog(object):
    def dog_work(self):
        print('狗正在工作')

# 都继承Dog类
class SearchDog(Dog):
    def dog_work(self):  # 重写Dog方法
        print('搜救犬正在搜索生命')


class PoliceDog(Dog):
    def dog_work(self):
        print('警犬正在抓坏人')


class FlyDog(Dog):
    def dog_work(self):
        print('飞天犬正在飞')


class BlindDog(Dog):
    def dog_work(self):
        print('导盲犬正在领路')


class Person(object):
    def __init__(self, dog=None):
        self.dog = dog

    def work_with_dog(self):
        self.dog.dog_work()  # self.dog找到导盲犬 ，然后调用dog_work()方法，而BlindDog()又重写类该方法


sd = SearchDog()
pd = PoliceDog()
fd = FlyDog()
bd = BlindDog()

p = Person(bd)  # 将bd传入，即BlindDog导盲犬，如果调用其他就把参数传入即可
p.work_with_dog()  # 导盲犬正在领路