面向对象的三大特性：

1. 封装：根据职责将属性和方法封装到一个抽象的类中

2. 继承：子承父类，能实现代码的重用, 相同的代码不需要重复的编写

3. 多态：不同的子类对象调用相同的父类方法, 产生不同的执行结果

目录：继承，多继承，多态

继承的简单介绍：

继承就是为了解决两个有大量重复性代码的类。 # 抽象出一个更抽象的类的公共代码。

# 其意义是重用代码，方便代码的管理与修改

# 类的继承包括属性和方法；继承可以理解为是子承父业

继承的格式和__bases__：

class 类名1(类名2)：

pass

#类名1继承了类名2的属性和方法，类名2是类名1的父类

#查询父类的魔法方法：__bases__；若没有规定继承的父类，默认继承的父类是object

继承到底继承了什么？

1.继承父类的属性、方法、魔法方法

#dir()可以查看类、实例对象的内置属性和方法

2.继承父类的私有属性，但是不能在子类的方法里直接调用父类的私有属性

3.继承中，属性或方法的寻找顺序：

依托于继承顺序 ---- 首先寻找实例对象本身 ---- 实例类 --- 父类 ---- 。。。。 --- object

#查看继承顺序：

【类名.__mro__】，

或者【实例.__class__.__mro__】；__class__用来查看类名

• 1.继承父类的属性、方法、魔法方法

#dir()可以查看类、实例对象的内置属性和方法

class Father():
    sex = '男'                   #属性
    def __init__(self):        #魔法方法，注意要在实例化后，实例对象才有hair属性；而类是没有这个属性的
        self.hair = '黑色'
  
    def run(self):             #方法
        print('跑步')
        
class Son(Father):      #Son类继承Father类的sex属性，__init__魔法方法，run方法
    pass

 #查看Father,Son,xiaoming的内置属性和方法
print(dir(Father))    
print(dir(Son))
xiaoming = Son()
print(dir(xiaoming))

• 2.继承父类的私有属性，但是不能在子类的方法里直接调用父类的私有属性

class Father():
    __sex = '男'

    def get(self):
        print(self.__sex)       #在Father类的方法里调用Father类的私有属性__sex

class Son(Father):              #Son继承Father类
    def get_from(self):
        print(self.__sex)         #在Son类的方法里调用Father类的私有属性__sex

a = Father()
a.get()        
b = Son()
b.get_from()         #在子类方法中不能直接调用父类的私有属性

男 #在当前类中可以在方法里调用自己类的私有属性

Traceback (most recent call last):

File "C:/Users/Administrator/Desktop/practice/func[副本].py", line 14, in <module>

b.get_from()

File "C:/Users/Administrator/Desktop/practice/func[副本].py", line 9, in get_from

print(self.__sex)

AttributeError: 'Son' object has no attribute '_Son__sex'

#在子类方法中不能直接调用父类的私有属性

• 3.继承中，属性或方法的寻找顺序：

依托于继承顺序 ---- 首先寻找实例对象本身 ---- 实例类 --- 父类 ---- 。。。。 --- object

class Father():
    age = 55

class Son(Father):
    age = 24

xiaoming = Son()
xiaoming.age = 12
print(xiaoming.age)

#查看xiaoming实例对象的继承顺序：
print(xiaoming.__class__.__mro__)   #或者print(Son.__mro__)

12

#在Father类，Son类，xiaoming实例对象都有age属性，但是最终age属性取决于xiaoming这个实例对象继承的顺序

(<class '__main__.Son'>, <class '__main__.Father'>, <class 'object'>)

#属性或方法的继承首先寻找实例对象本身，然后才是按照以上顺序继承，即Son-Father-object

多继承

1.多继承的格式

2.若子类和父类属性同名，依照继承顺序继承，其属性或方法取决于继承顺序

3.属性及方法重构（重写）---通过在子类中定义和父类相同的属性名或方法名来实现，这样就会优先继承子类的属性或方法，覆盖父类的属性或方法

4.重构沿用，定向继承指定类的父类的属性或方法，用super()方法

#super()：默认继承当前类的父类（就近原则）；

也可以指定继承特定类的父类-----super(指定类, self)

5.super(指定类, self).__init__() ----- 会继承父类初始化里的全部类，而且可以指定父类__init__里的属性调用

• 1.多继承格式的例子

class People():
    pass

class Father(People):
    pass

class Mother(People):
    pass

class Son(Father,Mother):   
    pass
#Son继承Father，Mother，People类，若Father和Mother类有属性或方法同名，
优先继承Father类，因为Father类在前，谁在前就优先继承谁

print(Son.__mro__)    #查询Son类的继承顺序

(<class '__main__.Son'>, <class '__main__.Father'>, <class '__main__.Mother'>, <class '__main__.People'>, <class 'object'>)

• 2.若子类和父类属性同名，依照继承顺序继承，其属性或方法取决于继承顺序

class People():
    typ = '人类'

class Father(People):
    typ = '男人'

class Mother(People):
    typ = '女人'

class Son(Father,Mother):   
    pass
#Son继承Father，Mother，People类，若Father和Mother类有属性或方法同名，
优先继承Father类，因为Father类在前，谁在前就优先继承谁
    
print(Son.__mro__)
print(Son.typ)

(<class '__main__.Son'>, <class '__main__.Father'>, <class '__main__.Mother'>, <class '__main__.People'>, <class 'object'>)

男人 ----继承Father类的typ属性之后，就不会再往后继承

• 3.属性及方法重构（重写）

---通过在子类中定义和父类相同的属性名或方法名来实现，这样就会优先继承子类的属性或方法，覆盖父类的属性或方法

class People():
    def __init__(self,typ):             #在People类里，使用初始化魔法方法__init__，需要传必备参数typ
        self.typ = typ

class Father(People):
    typ = '男人'

class Mother(People):
    typ = '女人'

class Son(Father,Mother):
    def __init__(self):
        self.age = 12              #在Son类里，使用初始化魔法方法__init__，不需要传参数

son = Son()    
#因为son实例对象优先继承Son类，所以son继承了Son的初始化，不需要传入参数；重构People的初始化方法
若只有People类里有初始化方法，则son在实例化时，必须传入参数，否则会报错

print(son.age)

12

• 4.重构沿用，定向继承指定类的父类的属性或方法，用super(指定类, self)方法

class People():
    def __init__(self,typ):
        self.typ = typ

class Father(People):
    typ = '男人'
    def run(self):
        print('遗传爸爸跑步技能')

class Mother(People):
    name = '继承妈妈的姓：李'
    def run(self):
        print('遗传妈妈跑步技能')

class Son(Father,Mother):
    def run(self):

        print(super(Son, self).name)
#继承Son类的父类里的name属性，因为Father类没有name，所以再往上一级查找name属性，即继承Mother类的name属性
        super(Son, self).run()
#继承Son类的父类(即Father类) 里的run方法
        super(Father,self).run()
#继承Father类的父类(即Mother类) 里的run方法

        print('孩子跑步')

print(Son.__mro__) #查看继承顺序，方便查看super()方法到底继承哪个类的父类的方法
son = Son(18)
son.run()

(<class '__main__.Son'>, <class '__main__.Father'>, <class '__main__.Mother'>, <class '__main__.People'>, <class 'object'>)

继承妈妈的姓：李

遗传爸爸跑步技能

遗传妈妈跑步技能

孩子跑步

• 5.super(指定类, self).__init__() ----- 会继承父类初始化里的全部类，而且可以指定父类__init__里的属性调用

class People():
    def __init__(self,typ):
        self.typ = typ
        self.skin_color = 'yellow'
        self.hair_color = 'black'
        return self.typ, self.hair_color    #返回指定的属性，调用时需用变量接收再打印，或者print输出


class Father(People):
    def run(self):
        print('遗传爸爸跑步技能')

class Mother(People):
    name = '继承妈妈的姓：李'
    def run(self):
        print('遗传妈妈跑步技能')

class Son(Father,Mother):
    def __init__(self):
        self.jicheng = super(Son, self).__init__('孩子')
#在Son类的初始化方法里，创建新的属性名来继承(接收)它父类中的初始化方法，即People类里的，
在People类的__init__必须传一个参数
#调用指定属性：不需要在super()后指定属性名调用所需属性，只需在实例化调用时，
使用和父类中初始化的属性名相同的属性名就可以调用，即【子类实例对象.父类中的属性名】

        self.age = 10
        #Son类自己的初始化属性

        
#实例化调用
son = Son()
print(dir(son))       #继承了Father,Mother,People里的属性，方法，初始化魔法方法

print(son.jicheng)      
#用新的属性名jicheng，接收了People__init__里的return的值，若return多个属性，则以元组的形式输出

print(son.typ)              #调用和父类中初始化属性名一样的typ
print(son.skin_color)   #调用和父类中初始化属性名一样的skin_color
print(son.hair_color)   #调用和父类中初始化属性名一样的hair_color
print(son.age)

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'hair_color', 'jicheng', 'name', 'run', 'skin_color', 'typ']

('孩子', 'black') ----- son.jicheng

孩子 ----son.typ

yellow --- son.skin_color

black ---- son.hair_color

10 ---- son.age

多态

定义：不同的子类对象调用相同的父类方法, 产生不同的执行结果

多态的两个前提：
1.继承；
2.重写父类方法：子类继承父类方法，当子类里有和父类同名的方法，则子类里的方法会覆盖父类同名的方法

多态的好处：可以增加代码的灵活度

调用Dog类（父类）的game方法

class Dog(object):               #父类
    def __init__(self, name):
        self.name = name

    def game(self):
        print('%s在玩耍...' % self.name)

class Sq(Dog):                  #子类，继承Dog类的name属性和game方法
    def game(self):             #重写父类的game方法，并覆盖Dog类的game方法
        print('%s飞到天上去玩耍...' % self.name)

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

    def game_with_dog(self, dog):
        print('%s和%s快乐的玩耍....' % (self.name, dog.name))
        dog.game()     
#调用game方法，取Dog类还是Sq类的game方法，取决于Person实例对象xm传入的参数

jm = Dog('金毛')
xm = Person('小明')
xm.game_with_dog(jm)    
#xm实例对象传入的参数属于Dog类，所以调用的是Dog类里的game方法和Dog类里的name属性

小明和金毛快乐的玩耍....

金毛在玩耍...

调用Sq类（子类）的game方法

class Dog(object):               #父类
    def __init__(self, name):
        self.name = name

    def game(self):
        print('%s在玩耍...' % self.name)

class Sq(Dog):                  #子类，继承Dog类的name属性和game方法
    def game(self):             #重写父类的game方法，并覆盖Dog类的game方法
        print('%s飞到天上去玩耍...' % self.name)

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

    def game_with_dog(self, dog):
        print('%s和%s快乐的玩耍....' % (self.name, dog.name))
        dog.game()      
#调用game方法，取Dog类还是Sq类的game方法，取决于Person实例对象xm传入的参数

jm = Sq('神犬')
xm = Person('小明')
xm.game_with_dog(jm)    
#xm实例对象传入的参数属于Sq类，所以调用的是Sq类里的game方法和Sq类里的name属性

小明和神犬快乐的玩耍....

神犬飞到天上去玩耍...