Python面向对象（2）

1、除了封装，Python面向对象还有继承这一功能，如下代码，这是简单的继承功能.

class Animal:

    def chi(self):
        print(self.name+‘ 吃‘)
    def he(self):
        print(self.name + ‘ 喝‘)

class Cat:
    def __init__(self, name):
        self.name = name
    def jiao(self):
        print(‘瞄‘)
class Dog(Animal):#继承Animal这个父类，拥有父类的方法
    def __init__(self, name):
        self.name = name
    def jiao(self):
        print(self.name+‘汪‘)

Jay = Dog(‘name‘)
Jay.chi()#这里就可以调用父类里面的方法

　　如果子类和父类都有相同的一个方法，会默认执行子类的方法

/2、

2、Python里面也可以同时继承多个父类，继承方法的优先级是先找自己的方法，然后先左后右

#Python里面一个类可以同时继承多个类，java，C#里面是不可以的
class Animal:
    def chi(self):
        print(self.name+‘ 吃‘)
    def she(self):
        print(self.name + ‘ 爱喝‘)
class god:
    def shit(self):
        print(‘shit‘)
    def she(self):
        print(‘黄赌毒‘)
# class Cat:
#     def __init__(self, name):
#         self.name = name
#     def jiao(self):
#         print(‘瞄‘)
class Dog(Animal,god):
    ‘‘‘如果方法重复，优先从自己这里寻找，如果方法在两个父类重复
    例如这里的she方法，这里默认是左边的父类优先，先在左边父类的寻找
    she方法，没有再去下一个父类寻找
    ‘‘‘
    def __init__(self, name):
        self.name = name
    def he(self):
        print(self.name + ‘ 不爱喝‘)
    def jiao(self):
        print(self.name+‘汪‘)
Jay = Dog(‘Jay‘)
Jay.she()#多个父类的方法继承是先左后右，这里会打印出Jay 爱喝

　　在Python3的类的继承里面，是深度优先的，如下面代码

class Jay(object):
    def f1(self):
        print(‘Jay‘)
class A(Jay):
    def f(self):
        print(‘A‘)
class B(Jay):
    def f1(self):
        print(‘B‘)
class C(A):
    def f(self):
        print(‘C‘)
class D(B):
    def f(self):
        print(‘D‘)
class E(C,D):
    def f(self):
        print(‘E‘)
obj = E()
‘‘‘在Python类的继承里面是深度优先的，这里调用f1的方法，会先在E自身里面寻找
，然后接着在C类里面寻找，还是找不到的话会在C的父类A类里面寻找，还找不到就轮
到去D类里面寻找，这里A类B类都继承了Jay这个基类，但是最后才会去Jay里面寻找f1
这个方法，也就是在D和B都找不到f1方法之后才会去Jay类里面寻找
‘‘‘
obj.f1()#这里输入结果是B

　　顺序如图所示

/3

3、多态，Python本身支持多态

#多态，就是多种形态

class Foo:
    def f1(self):
        print(‘Foo‘)
class Bar:
    def f1(self):
        print(‘Bar‘)
def func(arg):#这里显示arg的多种形态，可以是Foo类对象,也可以是Bar类的对象
    arg.f1()
f=Foo()
e=Bar()
func(f)#默认参数给的什么就是什么，没有就报错
func(e)

4、如果子类和父类都有构造函数，那么可以有两种方法可以继承

class A:
    def __init__(self):
        print(‘A的构造方法‘)
        self.name=‘佳鹏‘
        self.height = ‘1.65‘
class B(A):
    def __init__(self):
        print(‘B的构造方法‘)
        self.age = 23
        super(B,self).__init__()#先执行父类的构造方法，再执行自己
b =B()#这样b也有了A的属性
print(b.__dict__)

　　结果如图所示

还有一种方法是这样

class A:
    def __init__(self):
        print(‘A的构造方法‘)
        self.name=‘佳鹏‘
        self.height = ‘1.65‘
class B(A):
    def __init__(self):
        print(‘B的构造方法‘)
        self.age = 23
        A.__init__(self)#执行父类的构造函数，把B的实例传进去
b =B()#这样b也有了A的属性
print(b.__dict__)

　　结果是一样的。