Python面向对象核心

1、析构函数

class Person:
    def __init__(self, name):  # 构造函数
        self.m_Name = name
        print('{}出生了！众生堪忧。。。'.format(self.m_Name))
        pass
    def __del__(self):  # 析构函数
        print('真君驾到，诛杀了{},人间回归和平！'.format(self.m_Name))
        pass
    pass
p1 = Person('易隆平')
del p1  # 手动清理对象，解释器调用析构函数
p2 = Person('季行')

2、继承

语法格式：class Derived(Base)

class Animal:
    def __init__(self):
        print('父类Animal构造函数调用！')
        pass
    def Eat(self):
        print('吃东西！')
        pass
    def Drink(self):
        print('喝东西!')
        pass
    def __del__(self):
        print('父类Animal析构函数调用')
    pass

class Dog(Animal):  # 单继承class 子类名(父类名):
    def __init__(self):
        print('子类Dog构造函数调用！')
        pass
    def Bark(self):
        print('汪汪叫!')
        pass
    def __del__(self):
        print('子类Dog析构函数调用！')
        pass
    pass
d = Dog()
d.Eat()

3、多继承问题

class Student:
    def Study(self):
        print('学习！')
        pass
    def Eat(self):  # 重名
        print('在食堂吃饭！')
        pass
    pass

class Son:
    def Care(self):
        print('赡养父母!')
        pass
    def Eat(self):  # 重名
        print('在家里吃饭!')
    pass
class Person(Student, Son):
    pass

p = Person()
p.Care()
p.Study()

• 重名问题：

# 当多个父类中存在相同名称的方法时
p.Eat()  # 按照继承列表里的顺序
# 广度优先，先找自己这一层，找不到再去父类里按照继承列顺序找，找不到然后再在父类的父类里找，直到找到第一个
# 下例证明：
class A:
    def func(self):
        print('A')
        pass
    pass
class B:
    def func(self):
        print('B')
        pass
    pass
class C(A):
    pass
class D(B):
    pass
class E(C, D):
    pass
e = E()
print(E.__mro__)  # 查询执行顺序
e.func()

总之：纵深优先，宽广其次，先深度后广度

4、重写父类方法

# 重写父类中的方法，在子类中会覆盖掉父类中同名的方法，实现多态
class Base:
    def __init__(self):
        print('基类构造函数调用！')
        pass
    def Speak(self):
        print('父亲说话！')
        pass
    pass
class Derived1(Base):
    def __init__(self):
        print('派生类1构造函数调用！')
        pass
    def Speak(self):
        print('大儿子说话！')
        pass
    pass
class Derived2(Base):
    def __init__(self):
        print('派生类2构造函数调用！')
        pass
    def Speak(self):
        print('小儿子说话！')
        pass
    pass
d1 = Derived1()
d2 = Derived2()
d1.Speak()
d2.Speak()

• 构造函数也可以被重写

# 以上，Speak()在子类中被重写，其实构造函数也是被重写，覆盖父类构造函数
# 此语句可以也调用父类的构造函数
# 如果重写了__init__ 时，要继承父类的构造方法，可以使用 super 关键字：super(子类，self).__init__(参数1，参数2，....)
# 还有一种经典写法：    # 父类名称.__init__(self,参数1，参数2，...)
class Derived3(Base):
    def __init__(self):
        super(Derived3, self).__init__()
        print('派生类3构造函数调用！')
        pass
    pass
d3 = Derived3()

class Derived4(Base):
    def __init__(self):
        Base.__init__(self)
        print('派生类4构造函数调用！')
        pass
    pass
d4 = Derived4()

补充：使用super()函数将重写的方法继承下来。

此处代码重写了父类中的PrintName函数。

class Base:
    def __init__(self, name, age):
        self.m_Name = name
        self.m_Age = 10
        self.m_Address = 'China'
        pass
    def PrintName(self):
        print('My name is ' + self.m_Name)
    pass
class Derived(Base):
    def __init__(self, name, age):
        super(Derived, self).__init__(name, age)
        pass
    def PrintName(self, name2):
        print('My name is ' + name2)
        pass
    pass
derived = Derived('Foer Kent', 18)
derived.PrintName('Falcont')

输出如下：

可以用super()函数关联，效果如下：

此时也会调用父类的PrintName函数

小结：super()函数，可以使被重写的父类方法也会在子类实例中被继承下来；
语法：super(子类名, self).重写方法名(父类中该方法除了self的其他形参变量)

5、多态

• 前提：1、继承关系 2、重写父类方法

class Father:
    __privacy = 10
    _Age = 35
    def __init__(self, _value):
        self._Age = _value
    def Speak(self):
        print('父亲说话！')
        pass
    pass
class Son(Father):
    def __init__(self, _value):
        super(Son, self).__init__(_value)
    def Speak(self):
        print('儿子说话！')
        pass
    pass
class Daughter(Father):
    def __init__(self, _value):
        super(Daughter, self).__init__(_value)
    def Speak(self):
        print('女儿说话！')
        pass
    pass
s = Son(18)
d = Daughter(17)
s.Speak()
d.Speak()
print(s._Age)
print(d._Age)
f = Father(35)
print(f._Age)

- 多态的好处

• 以不变应万变

def Speak(obj):
    obj.Speak()
    pass
_list = [Son(24),Daughter(25)]
for obj in _list:
    Speak(obj)
    print(obj._Age)

• 增加扩展性

class Younger_Son(Father):
    def __init__(self, _value):
        super(Younger_Son, self).__init__(_value)
        print('小儿子构造函数')
    def Speak(self):
        print('小儿子说话')
        pass
    def __del__(self):
        print('小儿子析构函数')
Younger_Son(14).Speak()
input() # 此语句加上后说明上一条语句，对象被创建了立即被释放