面向对象编程的继承和多态

一.继承（重要）

1.什么是继承？

继承就是一种新建类的方法，新建的类叫做子类或者父类，被继承的类我们叫做父类或者基类。

 

class ParentClass1:  # 定义父类
    pass


class ParentClass2:  # 定义父类
    pass


class SubClass1(ParentClass1):  # 单继承，基类是ParentClass1，派生类是SubClass
    pass


class SubClass2(ParentClass1, ParentClass2):  # python支持多继承，用逗号分隔开多个继承的类
    pass


print(SubClass1.__bases__)  # 查看所有继承的父类
print(SubClass2.__bases__)  # 查看所有继承的父类

 

2.为什么要用继承？

类解决了对象与对象之间代码冗余问题

继承解决的是类与类之间代码冗余问题

3.如何使用继承？

新式类：继承了object类的子子孙孙类都是新式类

经典类：没有继承了object类的子子孙孙类都是经典类

1.只有在python2中才分新式类和经典类，python3中统一都是新式类

2.在python2中，没有显式的继承object类的类，以及该类的子类，都是经典类

3.在python2中，显式地声明继承object的类，以及该类的子类，都是新式类

4.在Python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式类

二.类的继承

　通过继承建立了派生类与基类之间的关系，它是一种'是'的关系，比如白马是马，人是动物。

　当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如老师是人，学生是人。

# 类的继承
# 父类公共类
class People:
    school = 'SH'

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


class Student(People):
    def __init__(self, name, age, gender, course=None):
        if course is None:
            course = []
        People.__init__(self, name, age, gender)
        self.course = course

    def choose_course(self, course):
        self.course.append(course)
        print('%s选课成功 %s' % (self.name, self.course))


class Teacher(People):
    def __init__(self, name, age, gender, level):
        self.level = level
        People.__init__(self, name, age, gender)

    def score(self, stu_obj, score):
        stu_obj.score = score
        print('%s给%s打了%s分' % (self.name, stu_obj.name, score))


stu1 = Student('jason', 18, 'male')
tea = Teacher('jack', 18, 'female', '初级')
# print(Student.choose_course(stu1, 'python'))
stu1.choose_course('python')
Teacher.score(tea, stu1, 90)
print(stu1.__dict__)

三.单继承下属性查找

　单属性查找的顺序就是现在对象中查找先在对象中查找，没找到再去产生对象的类中查找，没找到的话再去父类中查找。

class Foo:
    def f1(self):  # _Foo__f1()
        print('Foo.f1')

    def f2(self):
        #
        print('Foo.f2')
        self.f1()  # _Foo__f1()


class Bar(Foo):
    def f1(self):  # # _Bar__f1()
        print('Bar.f1')


obj = Bar()  # {}
obj.f2()

四.多属性查找

新式类：按照广度有限查询，如图

经典类：按照深度优先查询

class A(object):
    def test(self):
        print('from A')


class B(A):
    def test(self):
        print('from B')

    pass


class C(A):
    def test(self):
        print('from C')


class D(B):
    def test(self):
        print('from D')
    pass


class E(C):
    def test(self):
        print('from E')


class F(D, E):
    pass


f1 = F()
f1.test()
print(F.mro())

五.super()和mro列表

class Student:
    school = 'SH'

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


class Teacher(Student):
    def __init__(self, name, age, gender, level):
        self.level = level
        super().__init__(name, age, gender)  # super的使用

    def score(self, stu_obj, score):
        stu_obj.score = score
        print('%s给%s打了%s分' % (self.name, stu_obj.name, score))


stu = Student('jason', 18, 'male')
tea = Teacher('jack', 18, 'female', '初级')
tea.score(stu, 80)

# mro列表练习1
class A:
    def test(self):
        print('from A.test')
        super().test()


class B:
    def test(self):
        print('from B')


class C(A, B):
    pass


c = C()
c.test()



class B:
    def test(self):
        print('B---->test')

    def aaa(self):
        print('B---->aaa')


class A:
    def test(self):
        print('A---->test')
        # super().aaa()


class C(A, B):
    def aaa(self):
        print('C----->aaa')


c = A()
c.test()  # 打印结果:A---->test
print(A.mro())

六.多态与多态性

class Animal:

    def eat(self):
        print('%s吃' % self.name)

    def drink(self):
        print('%s喝' % self.name)

    def shit(self):
        print('%s拉' % self.name)

    def pee(self):
        print('%s尿尿' % self.name)


class Dog(Animal):
    def __init__(self, name):
        self.name = name
        self.bread = '狗狗'

    def Call(self):
        print('汪汪汪')


class Cat(Animal):
    def __init__(self, name):
        self.name = name
        self.bread = '猫'

    def Call(self):
        print('喵喵喵')


# c1 = Dog('小白狗')
# c1.eat()
# c1.Call()
c2 = Cat('小白猫')
c2.pee()
c2.Call()