python学习Day19--面向对象的三大特性

【知识点】

 # python 没有接口这个概念

1、 接口类，抽象类：制定一个规范

　　如下几行代码就是制定规范的过程

1 from abc import ABCMeta,abstractmethod
2 
3 class Payment(metaclass=ABCMeta):# 抽象类（接口类）
4     @abstractmethod              # 强制执行一个规范，凡是继承我的类中必须有pay方法，否则实例化对象就会报错
5     def pay(self):   pass        # 制定了一个规范

　　具体的一个例子如下：

 1 from abc import ABCMeta,abstractmethod
 2 
 3 class Payment(metaclass=ABCMeta):# 抽象类（接口类）
 4     @abstractmethod              # 强制执行一个规范，凡是继承我的类中必须有pay方法，否则实例化对象就会报错
 5     def pay(self):   pass        # 制定了一个规范
 6 
 7 class Alipay(Payment):
 8     def __init__(self,money):
 9         self.money=money
10 
11     def pay(self):
12         print("使用支付宝支付了%s" % self.money)
13 
14 class Jdpay(Payment):
15     def __init__(self,money):
16         self.money=money
17 
18     def pay(self):
19         print("使用京东支付了%s" % self.money)
20 
21 class Wechat(Payment):
22     def __init__(self,money):
23         self.money=money
24 
25     def pay(self):             # 归一化设计
26         print("使用微信支付了%s" % self.money)
27 
28 def pay(obj):
29     obj.pay()
30 
31 a1=Alipay(500)
32 w1=Wechat(200)
33 pay(a1)         #归一化设计
34 pay(w1)         #归一化设计

2、多态：（python面向对象三大特征之一，python中处处是多态）

　　没有多态？它有什么？它有鸭子类型

　　# 鸭子类型：看着像鸭子，它就是鸭子

 3、封装：（广义）实例化一个对象，给对象空间封装一些属性

　　　　　（狭义）私有制

　　　　　  私有成员：私有静态字段，私有方法，私有对象属性

　　　　#1、私有静态字段：（可以访问，但不要使用）

　　　　　　对于私有静态字段，只能在本类中内部访问，类的外部，派生均不可访问

 1 # 私有静态字段
 2 class B:
 3     __money=20
 4 
 5 class A(B):
 6     name='alex'
 7     __age=100
 8     def func(self):
 9         print(self.__age)   #可以
10         print(A.__age)      #可以
11         print('func....')
12     def func1(self):
13         print(self.__money)  #不可以
14 a1=A()
15 # print(a1.name)
16 # print(A.name)
17 # print(a1.__age)   #实例化对象不能访问私有静态字段
18 # print(A.__age)    #类名不能访问私有静态字段
19 
20 #   对于私有静态字段，类的外部不能访问
21 a1.func()    # 类的内部可以访问私有静态字段
22 a1.func1()   # 报错
23 #   对于私有静态字段，只能在本类中内部访问，类的外部，派生均不可访问

　　　　#2、私有方法：

　　　　　　对于私有方法，只能在本类中内部访问，类的外部，派生均不可访问

 1 # 私有方法
 2 class B:
 3     __money=1000
 4 
 5     def __f1(self):
 6         print('B')
 7 
 8 class A(B):
 9     name='alex'
10 
11     def __func(self):
12         print('func....')
13     def func1(self):  # 类的内部可以访问私有方法
14         # self.__func()
15         self.__f1()   # 类的派生类也不能访问
16 a1=A()
17 # a1.__func()  # 类外部不能访问
18 a1.func1()

　　　　【一道题】

 1 class Parent:
 2     def __func(self):    # _Parent__func
 3         print('in Parent func')
 4 
 5     def __init__(self):
 6         self.__func()    # 对象.__Parent__func
 7 
 8 class Son(Parent):
 9     def __func(self):    #_Son__func
10         print('in Son func')
11 
12 son1=Son() # 运行结果是？
13 # 结果：in Parent func

　　　　分析：一开始就产生了_Parent__func，要执行的就是对象._Parent__func