python 全栈 python基础 （十六）面向对象编程的 继承 多态与多态性 封装

 1 class B(object):
 2     def func(self):
 3         print(‘-----> B‘)
 4     pass
 5 class C(object):
 6     def func(self):
 7         print(‘-----> C‘)
 8     pass
 9 class D(B,C):
10     def func(self):
11         print(‘-----> D‘)
12     pass
13 class E(B,C):
14     def func(self):
15         print(‘-----> E‘)
16     pass
17 class F(D,E):
18     def func(self):
19         print(‘-----> F‘)
20     pass
21 # f=F()
22 # f.func()
23 print(F.__mro__)
24 
25 #执行结果：
26 (<class ‘__main__.F‘>, <class ‘__main__.D‘>, <class ‘__main__.E‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘object‘>)

 1 #coding:utf-8
 2 #super在python2中的用法：
 3     # 1:super(自己的类,self).父类的函数名字
 4     # 2：super只能用于新式类
 5 class People(object):
 6     def __init__(self,name,sex,age):
 7         self.name=name
 8         self.age=age
 9         self.sex=sex
10     def walk(self):
11         print(‘%s is walking‘ %self.name)
12 class Chinese(People):
13     country=‘China‘
14     def __init__(self,name,sex,age,language=‘Chinese‘):
15         # self.name=name
16         # self.sex=sex
17         # self.age=age
18         # People.__init__(self,name,sex,age)
19         super(Chinese,self).__init__(name,sex,age)
20         self.language=language
21 c=Chinese(‘egon‘,‘male‘,18)
22 print c.name,c.age,c.sex,c.language
23 
24 #执行结果：
25 egon 18 male Chinese

 1 #在python3中
 2 class People:
 3     def __init__(self,name,sex,age):
 4         self.name=name
 5         self.age=age
 6         self.sex=sex
 7     def walk(self):
 8         print(‘%s is walking‘ %self.name)
 9 class Chinese(People):
10     country=‘China‘
11     def __init__(self,name,sex,age,language=‘Chinese‘):
12         super().__init__(name,sex,age)#super()函数.父类函数名(参数)
13         # 由于super()相当于是带入一个类而不在是函数，所以传值的时候，不再需要给self传值，实例化的时候自动带入。
14         self.language=language
15     def walk(self,x):
16         super().walk()  #super()函数.父类函数名()
17         print(‘%s is chase %s‘%(self.name,x))
18 c=Chinese(‘anyone‘,‘male‘,18)
19 print(c.name,c.age,c.sex,c.language)
20 c.walk(‘somebody‘)
21 
22 #执行结果：
23 anyone 18 male Chinese
24 anyone is walking
25 anyone is chase somebody

 1 #多态：同一种事物的多种形态，动物分为人类，猪类（在定义角度）
 2 class Animal:
 3     def run(self):
 4         raise AttributeError(‘子类必须实现这个方法‘)
 5 
 6 class People(Animal):
 7     def run(self):
 8         print(‘人正在走‘)
 9 
10 class Pig(Animal):
11     def run(self):
12         print(‘pig is walking‘)
13 
14 class Dog(Animal):
15     def run(self):
16         print(‘dog is running‘)
17 
18 peo1=People()
19 pig1=Pig()
20 d1=Dog()
21 #实例化调用方法得到的结果
22 # peo1.run()
23 # pig1.run()
24 # d1.run()
25 
26 #多态性：一种调用方式，不同的执行效果（多态性）
27 # 多态性依赖于：
28 #     1.继承
29 #     2.
30 ##多态性：定义统一的接口，
31 def func(obj): #obj这个参数没有类型限制，可以传入不同类型的值
32     obj.run() #调用的逻辑都一样，执行的结果却不一样
33 
34 func(peo1)
35 func(pig1)
36 func(d1)
37 
38 #执行结果：
39 人正在走
40 pig is walking
41 dog is running

 1 class A:
 2     __x =1 #_A__x
 3     def __test(self): #_A__test
 4         print(‘from A‘)
 5 print(A.__dict__)  #在方法空间中查看变形的属性
 6 #print(A.__x) #用这种方法无法调用到变量，已变形
 7 print(A._A__x)  #若想强行访问，正确的调用方式
 8 a = A()  #实例化
 9 print(a.__dict__)
10 print(a._A__x)  #对象的调用
11 
12 A._A__test(123)  #强制访问，类的调用
13 a._A__test()    #强制访问，对象的调用
14 
15 #执行结果：
16 {‘__module__‘: ‘__main__‘, ‘_A__x‘: 1, ‘_A__test‘: <function A.__test at 0x000000000292C9D8>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘A‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘A‘ objects>, ‘__doc__‘: None}
17 1
18 {}
19 1
20 from A
21 from A　　

#注意：__名字，这种语法只在定义的时候才会有变形的效果，如果类或者对象已经产生了，就不会有变形效果。
#变形的过程只在类的定义时发生一次；在定义后的赋值操作，就不会变形
#1、内部定义
class A:
    def __init__(self):
        self.__x =1    #_A__x 定义在产生的过程中，肯定会变形
    def tell(self):   #在类内部定义的变形变量（隐藏），需要定义一个接口函数来实现访问，外部去访问这个接口进行调用
        print(self.__x) #在类内部可以直接用__名字调用，来访问到变形的属性
a = A()
print(a.__dict__) #在类的名称空间中查看，已变形
#print(a.__x)  #属性已经变形，调用不到
a.tell()

#执行结果：
{‘_A__x‘: 1}
1

#2、外部定义
class B:
    pass

B.__x =1 #给类添加一个为__x的变量，而不是变形
print(B.__dict__)  #在类的名称空间中查看，未变形
print(B.__x)   #打印结果

b = B()  #类实例化
b.__x =1  #为对象添加一个为__x的变量，而不是变形
print(b.__dict__) #查看对象的名称空间
print(b.__x)  #打印结果

#执行结果：
{‘__module__‘: ‘__main__‘, ‘__dict__‘: <attribute ‘__dict__‘ of ‘B‘ objects>, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘B‘ objects>, ‘__doc__‘: None, ‘__x‘: 1}
1
{‘__x‘: 1}
1

# 在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
# 1、正常情况下：
class A:
    def fa(self):
        print(‘from A‘)
    def test(self):
        self.fa()
class B(A):
    def fa(self):
        print(‘from B‘)
b = B()
b.test() #b.test--->B--->A 得到b.fa() 然后在对象b中找--->类B找--->父类A找

# 执行结果：
from B

# 注意：时刻谨记：在定义阶段就会变形
# 2、把fa定义成私有的，即__fa
class A:
    def __fa(self):   #_A__fa
        print(‘from A‘)
    def test(self):  #在定义阶段就会变形
        self.__fa()   #self._A__fa
class B(A):
    def __fa(self):   #_B__fa
        print(‘from B‘)
b = B()  #实例化
b.test()  #自己的对象和类名称空间没有，在父类的名称空间找到，函数已经变形。

#执行结果：
from A