python 面向对象之继承

如Exception 类可以层层继承
发现了一个问题 每个类中都有相同内容的init方法 和其他相同的函数 却出现在不同类中
面向对象编程中 将每个类中相同的代码 给他创建成一个父类 父类就是所有子类的共同特征
继承的方法 class Student(父类)

// class Employer:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print(self.name+'正在吃饭')
    def run(self):
        print(self.name+'正在吃饭')

class Doctor:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print(self.name+'正在吃饭')
    def run(self):
        print(self.name+'正在吃饭')
未使用继承的情况，存在大量重复代码，
 下边我们优化一下他

#继承：
Student Employer Doctor 都属于人类
有相同的代码–>代码甬余 可读性不高
将相同代码提取–>Person类
Student Employer Doctor -->继承Person
class Student(Person):
pass

#优化后的代码为

//class Person:
    def __init__(self,name,age2):

        self.name=name
        self.age =str(18)
        self.age2=str(age2)
    def eat(self):
        print(self.name+'正在吃饭')
    def run(self):
        print(self.name+'正在吃饭'+self.age+self.age2)

# Person('小明','18')
class Student(Person):
    def __init__(self,n,m):
        print('我已重写student的init方法')
        #虽然他重写了 但是他还想调用父类的init 组成一个双重init
        super().__init__(n,m)  #super() 指向父类对象 .init 调用父类init方法  最后一个()传形参
class Employer(Person):
    pass
class Doctor(Person):
    pass

s=Student('jack',25)

s.run()

结果为
我已重写student的init方法
jack正在吃饭1825

1。如果类中补丁已__init__ 则调用父类super class 的init 但是如果父类init中需要传入参数 则子类必须帮助父类传参–》子类定义init并super父类init
2.如果类继承父类也需要定义自己的__init__,就需要在当前类的__init__调用一下父类__init__
3.如何调用父类__init__:
super().init(形参)
super(类名,对象).init(参数)
4.如果父类有eat(),子类也定义一个eat方法，默认搜索的原则，先找当前类，再去找父类
s.eat() 先调子类的eat 再看父类的eat
override 重写 父类提供的方法不能满足子类的需求，就需要在子类中定义一个同名的方法,这种行为成为重写
5.子类的方法中也可以调用父类方法: super().方法名(参数)
6.父类私有属性和方法无法被继承和关联

第二种使用super的方式

self.name
super().init(n,m) 此时是不被允许的 必须super先引用下父类函数 才能使用父类函数中的属性

def init(self,n,m,name,age): #我传4个形参 2个分给父类 2个分给Student

def init(self, n, m): # 只要你是子类 子类必须创建一个init 里边写super方法引用父类init
super().init(n, m)

def eat(self): # 子类重写了父类的同名函数 当一个对象调用子类同名函数时 优先子类寻找 如果找不到才去父类里寻找
print(‘Doctor 的eat方法 而不是父类的同名eat方法’ + self.name)

//class Person:
    def __init__(self,name,age2):

        self.name=name
        self.age =str(18)
        self.age2=str(age2)
        print('父类属性已重写完毕')
    def eat(self):
        print(self.name+'正在吃饭')
    def run(self):
        print(self.name+'正在跑步'+self.age+self.age2)

# Person('小明','18') #是无效的 不能这么给父类传参
class Student(Person):
    def __init__(self,n,m,name,age):  #我传4个形参 2个分给父类 2个分给Student
        print('我已重写student的init方法')
        #self.name 此时是不被允许的 必须super先引用下父类函数 才能使用父类函数中的属性
        #虽然他重写了 但是他还想调用父类的init 组成一个双重init
        super().__init__(n,m)  #super() 指向父类对象 .init 调用父类init方法  最后一个()传形参
        self.name1=name
        self.age3=str(age)
        print('这是我Student的新属性'+self.name1+self.age3+self.name)
    def birthday(self,k):

        print('{}马上过生日拉'.format(self.name+self.age2)+k)

# Person('Employer','100')
class Employer(Person):
    def __init__(self,n,m):
        self.n=str(n)
        self.m=str(m)
        print('我是Employer 我的能力是'+self.n+self.m)
        super().__init__('Employer',100)
        print('父类的属性是'+self.name+self.age2)

class Doctor(Person):
    def __init__(self,n,m):  #只要你是子类 子类必须创建一个init 里边写super方法引用父类init
        super().__init__(n,m)

    def eat(self):  #子类重写了父类的同名函数 当一个对象调用子类同名函数时 优先子类寻找 如果找不到才去父类里寻找

        print('Doctor 的eat方法 而不是父类的同名eat方法'+self.name)

s=Student('小明',25,'小红',100)
print('--------------')
s.run()

s.birthday('BIRTHDAY')
print('---------------------------')
e=Employer(12,5)
print('-------------Doctor-----------')
D=Doctor('小芳',200)
D.eat()

结果为
我已重写student的init方法
父类属性已重写完毕
这是我Student的新属性小红100小明
--------------
小明正在跑步1825
小明25马上过生日拉BIRTHDAY
---------------------------
我是Employer 我的能力是125
父类属性已重写完毕
父类的属性是Employer100
-------------Doctor-----------
父类属性已重写完毕
Doctor 的eat方法 而不是父类的同名eat方法小芳

#无参父类 不需要子类单独调用super 因为默认传方法
#子类的方法中也可以调用父类方法: super().方法名(参数)

//class Person:
    def __init__(self,name):
        self.name=name
    def eat(self):
        print('父类的eat')

class Student(Person):  #如果子类不需要重写父类init方法 就可以不写init  但是有参数的情况扔需要传参
    def eat(self):
        super().eat()
        print(self.name)

s=Student('gkd')
s.eat()

#py中 当一个类中同时定义两个同名函数方法 就会发生重写 上个函数失效
class Person:
    def __init__(self,name):
        self.name=name
    def eat(self):
        print('---')
    def eat(self,food):
        print('--------->eat',food)
p=Person('小红')
p.eat('gkd')  #TypeError: eat() missing 1 required positional argument: 'food'
         #py中 当一个类中同时定义两个同名函数方法 就会发生重写 上个函数失效
print(Person.__mro__) #查找Person的继承顺序 涉及多继承