面向对象基础三

1 继承

• 继承概念： 指一个类获取到其它一个或多个类中的属性和方法，但是父类（也称超类、基类）中的属性或者方法不能被继承
• 继承方式： 定义类时，在类后面的括号中指定当前类的父类
• 作用： 提高了类的复用性，使得类之间产生了关系，也因此有了多态的特性
• super()： 获取当前类的父类，并且可以用于调用父类的方法，直接用类名调用父类方法多用于单继承，但是如果使用多继承，会涉及到查找顺序、重复调用等种种问题。

class A:
    a1 = '公有类属性'
    __a2 = '私有类变量'

    def Pr(self):
        print('类名访问类公有变量', A.a1)
        print('对象访问类公有变量', self.a1)

    def Pr2(self):
        print('对象访问类私有变量', self.__a2)
        print('类访问类私有变量', A.__a2)

    def Pr3(self, name):
        self.name = name
        print('对象访问普通对象属性', name)

    def Pr4(self, name):
        self.__name = name  # 私有类属性
        print('对象访问私有对象属性', self.__name)

    def __Pr5(self):             # A类私有方法，只能在类内访问
        return (self.a1)

    def Pr5(self):
        print('类访问私有方法',A.__Pr5(self))
        print('对象访问类私有方法',(self.__Pr5()))

    @classmethod
    def Pr6(cls):
      cls.Pr4(cls,'QQQ')


    @staticmethod
    def Pr7(x):
        print(super(x))
        print(x.__Pr5(x))
        x.Pr3(x,'qwwe')


class B(A):
    b1 = 'b1'

    def Prb(self):
        print(self.b1)
        super().Pr4('mmmmmmm')

# 通过类内访问
print('通过类内访问')
x = B()
x.Pr()
x.Pr2()
x.Pr3('www')
x.Pr4('aaa')
x.Pr5()
x.Pr6()
x.Pr7(B)
x.Prb()


# 通过类外访问
print('\n通过类外访问', "*" * 50)
print(B.a1)
print(x._A__a2)
print(x.a1)
print(x.name)
# print(x._B__a2)                    #AttributeError: 'B' object has no attribute '_B__a2'

'''
运行结果：
通过类内访问
类名访问类公有变量 公有类属性
对象访问类公有变量 公有类属性
对象访问类私有变量 私有类变量
类访问类私有变量 私有类变量
对象访问普通对象属性 www
对象访问私有对象属性 aaa
类访问私有方法 公有类属性
对象访问类私有方法 公有类属性
对象访问私有对象属性 QQQ
<super: <class 'B'>, NULL>
公有类属性
对象访问普通对象属性 qwwe
b1
对象访问私有对象属性 mmmmmmm

通过类外访问 **************************************************
公有类属性
私有类变量
公有类属性
www
'''

2 方法重写

• 重写（覆盖）： 在子类中有和父类同名的方法，则通过子类实例去调用方法时，会调用子类中的方法而不是父类中的方法
• 调用对象方法的顺序：
  • 优先去当前对象中寻找是否具有该方法，有则直接调用该方法
  • 若当前对象没有该方法， 则去当前父类中寻找，如果父类中有则直接调用父类中的方法
  • 若父类中无此方法，则去父类中的父类寻找，直到找到该方法，如果依然没有找到则报错

class A:
    a1 = '公有类属性'
    __a2 = '私有类变量'

    def Pr(self):
        print('类名访问类公有变量', A.a1)
        print('对象访问类公有变量', self.a1)

class B(A):
    b1 = 'b1'

    def Pr(self):
        print(self.b1)

# 通过类内访问
x = B()
x.Pr()
'''
运行结果：
b1
'''

3 多重继承

推荐资料：python中的MRO与多继承

推荐资料：【整理】python 面向对象之继承**
Python面向对象之继承

• 概念： 即一个类同时继承多个父类
• 继承方式： 在当前类后的()里添加多个类，并用逗号隔开，以此实现多重继承
• 调用对象方法的顺序： 如果多个父类中有同名的方法，则先在第一个父类中寻找，然后找第二个，第三个…直到最后，即前面具有优先级，会覆盖后面的类

# 多重继承 示例1
class A1:
    def a1(self):
        print('A1')

class A2:
    def a2(self):
        print('A2')

class A3:
    def a3(self):
        print('A3')

class B(A1,A2,A3):
    def Pr(self):
       super().a3()

B().Pr()
'''
运行结果：
A3
'''
#-----------------------------------------------------------------
#多重继承示例2  如果多个父类中有同名的方法，前面具有优先级，会覆盖后面的类
class A1:
    def a(self):
        print('A1')

class A2:
    def a(self):
        print('A2')

class A3:
    def a(self):
        print('A3')

class B(A1,A2,A3):
    def Pr(self):
       super().a()

B().Pr()
'''
运行结果：
A1
'''
#-----------------------------------------------------------------
#多重继承示例3  单继承执行顺序
class A:
    def a(self):
        print('A',end=' ')

class B(A):
    def b(self):
        print('B',end=' ')
        super().a()
        print('B',end=' ')

class C(B):
    def c(self):
        print('C',end=' ')
        super().b()
        print('C',end=' ')

class D(C):
    def d(self):
        print('D',end=' ')
        super().c()
        print('D',end=' ')

D().d()
'''
运行结果：
A1
'''
#-----------------------------------------------------------------
#多重继承示例4  多继承执行顺序
class A:
    def a(self):
        print('A',end=' ')

class B1(A):
    def a(self):
        print('B1',end=' ')
        super().a()
        print('B1',end=' ')

class B2(A):
    def a(self):
        print('B2',end=' ')
        super().a()
        print('B2',end=' ')

class C(B1,B2):
    def a(self):
        print('C',end=' ')
        super().a()
        print('C',end=' ')

class D(C):
    def d(self):
        print('D',end=' ')
        super().a()
        print('D',end=' ')

D().d()
'''
运行结果：
D C B1 B2 A B2 B1 C D 
'''

4 多态

概念： 一个类继承了其它类的功能，根据不同的场景，切换不同的形态，实现不同的功能；简单来说，多态就是一个对象可以以不同的形态去呈现

参考链接：
python 多态性
Python之面向对象编程：封装、继承、多态

#多态示例一     函数式
class A:
    def Pr(self):
        print('父类很嚣张')


class B(A):
    def Pr(self):
        print('子类B很温柔')

class C(A):
    def Pr(self):
        print('子类C很自强')

class D(A):
    def Pr(self):
        print('子类D很优雅')


def test(x):             #通过此函数实现多态形式    
        x.Pr()

a=A()
b=B()
c=C()
d=D()

test(a)           #调用同一个函数，但输出结果不一样，体现了多态（原因为函数参数不同）
test(b)
test(c)
test(d)
'''
运行结果：
父类很嚣张
子类B很温柔
子类C很自强
子类D很优雅
'''


#--------------------------------------------------------------------------
#多态示例二         类式
class A:
    def Pr(self):
        print('父类很嚣张')

class B(A):
    def Pr(self):
        print('子类B很温柔')

class C(A):
    def Pr(self):
        print('子类C很自强')

class D(A):
    def Pr(self):
        print('子类D很优雅')


class te(object):             #通过此类实现多态形式
    x='a'

    def test(self,x):
        self.x=x
        x.Pr()


a=A()
b=B()
c=C()
d=D()
t=te()

t.test(a)    # 以下都是调用对象t，但输出结果不同，以此实现多态（原因为我们传递的test参数不同)）
t.test(b)
t.test(c)
t.test(d)
'''
运行结果：
父类很嚣张
子类B很温柔
子类C很自强
子类D很优雅 
'''