[复习]面向对象之继承

面向对象之继承

一.概念

　如果有两个或两个以上的类具有相同的属性和方法，我们可以抽取出来，把抽取出来的部分作为各个类的公共部分，我们称抽取出的这部分为基类[Base Class]或者父类[Father Class]、超类[Super Class].

　　举例：[我直接以多继承举例]

　　第一种情况，父类中没有构造函数

 

class Father(object):
    def eat(self):
        print('father is eating')


class Mother(object):
    def play(self):
        print('mother is playing')


class Children(Father, Mother):
    pass


c = Children()
c.eat()
c.play()

 

　　运行结果

father is eating
mother is playing

 

 

　　第二种情况，父类中有构造函数

class Father(object):
    def __init__(self, money):      # 构造函数
        self.money = money      # 实例属性

    def get(self):
        print(f'father had got {self.money}$')


class Mother(object):
    def __init__(self, clothes):        # 构造函数
        self.clothes = clothes      # 实例属性

    def shop(self):
        print(f'mother has go shopping to buy {self.clothes}')


# 如果子类想要用父类中的实例属性，则需要继承父类的构造函数才能使用，否则会报错
# 如果父类中含有多个重名的函数，那么子类只会调用父类列表第一个重名的函数
class Children(Father, Mother):
    def __init__(self, money, clothes):
        Father.__init__(self, money)
        Mother.__init__(self, clothes)


c = Children(100,'李宁')
c.get()
c.shop()

 

　　运行结果

father had got 100$
mother has go shopping to buy 李宁

　　第三种情况，父类中有构造函数，子类中没有

class Father(object):
    def __init__(self, money):      # 构造函数
        self.money = money      # 实例属性

    def get(self):
        print(f'father had got {self.money}$')


class Mother(object):
    def __init__(self, clothes):        # 构造函数
        self.clothes = clothes      # 实例属性

    def shop(self):
        print(f'mother has go shopping to buy {self.clothes}')


class Children(Father, Mother):
   
    pass


c = Children(100)
c.get()
c.shop()

 　　运行结果则是 只能调用Father中的函数，而Mother中的无法调用

 

总结:

1.在多继承中，如果父类中有构造函数，子类没有，而子类需要使用父类中的实例属性或函数，那么子类只会调用第一个父类的函数；如果想要子类使用所有父类的实例属性或函数，那么同样需要继承父类中的构造函数，但是如果使用super()都只能调用父类列表中第一个父类中的构造函数，所以只能使用上述例子的第二种继承方法

2.如果在父类中都没有构造函数，那么子类可以直接调用

 

二、函数的重写[重点掌握]

 　　函数的重写[override],使用的前提是在继承的情况下；

 　　如果在子类中重新实现了父类中的函数，那么这个过程叫做函数的重写。

　　举例：

 

# 1.第一种情况：普通函数的重写
class Animals(object):
    def walk(self):
        print('正在跑')


class Dog(Animals):
    pass


class Cat(Animals):
    pass


class Bird(Animals):
    def walk(self):
        print('鸟只会飞')


animal = Bird()
animal.walk()

animal2 = Dog()
animal2.walk()

# 2.第二种情况，系统函数的重写，拿object举例，因为所有类的基类都是object
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f'姓名:{self.name},年龄:{self.age}'

    def __repr__(self):
        return f'姓名:{self.name},年龄:{self.age}'

    __repr__ == __str__


p = Person('小刚',19)
print(p)

 

　　运行结果：

鸟只会飞
正在跑
姓名:小刚,年龄:19

 

 

总结：

1.什么时候用函数的重写

　　如果一个父类中有多个子类，父类中的函数能够满足大部分子类的使用，只有少部分函数无法使用时，我们可以用函数的重写；

2.什么时候需要重写__str__

　　如果希望打印出的信息是当前对象的属性，那么需要在子类中重写__str__，因为它返回的是一个字符串，所以建议将字符串格式化之后返回，如例子中的。

3.什么时候需要重写__repr__

　　如果打印出的信息对象元素是存在于列表等可迭代对象中，它会直接返回可迭代对象，也就是返回默认的地址形式，但是我们需要的是列表中的属性信息，那么我们就需要重写__repr__

4.只要有系统函数的重写都需要加上 __repr__ == __str__

 

 

三、函数的重写和函数的重载有什么区别

　　【面试题】简述函数重写和函数重载的区别
　　　　函数重写：override,在继承的前提下，如果子类中重新实现了父类中的函数
　　　　函数重载[运算符重载]：overload，对于自定义的类，通过该类创建的对象，如果不支持某些运算，如：+ - * / > < >= <= == !=等，则可以在该类中实现这些运算符对应的函数

 

　　　　

class Person(object):
    def __init__(self, age):
        self.age = age
    
    def __add__(self, other):        # 函数重载
       # self和other表示参与运算的两个对象
       # 结合实际情况，两个对象无法相加，可以对两个对象的属性进行加法运算
        return Person(self.age+other.age)    
    
    def __str__(self):　　　　
        return str(self.age)
    __repr__ == __str__


p1 = Person(10)
p2 = Person(5)

print(p1+p2)
print(p1.__add__(p2))