Python_015(面向对象(接口类,抽象类,多态,封装)

 1 #版本一
 2 class Alipay:
 3     def __init__(self,money):
 4         self.money = money
 5     def pay(self):
 6         print(‘阿里支付了%s元!‘ % self.money)
 7 class Jdpay:
 8     def __init__(self,money):
 9         self.money = money
10     def pay(self):
11         print(‘京东支付了%s元!‘ % self.money)
12 p1 = Alipay(1000)
13 p1.pay()            #这里是Alipay.pay()
14 p2 = Jdpay(1000)
15 p2.pay()            #这里是Jdpay.pay()
16 #输出结果:
17 阿里支付了1000元!
18 京东支付了1000元!

 1 #版本二
 2 class Alipay:
 3     def __init__(self,money):
 4         self.money = money
 5     def pay(self):
 6         print(‘阿里支付了%s元!‘ % self.money)
 7 class Jdpay:
 8     def __init__(self,money):
 9         self.money = money
10     def pay(self):
11         print(‘京东支付了%s元!‘ % self.money)
12 def pay(obj):        #接口函数(约定俗成,内行程序员大家都看的懂)
13     obj.pay()
14 p1 = Alipay(1000)
15 pay(p1)
16 p2 = Jdpay(1000)
17 pay(p2)
18 #输出结果:
19 阿里支付了1000元!
20 京东支付了1000元!

 1 class Pay(metaclass=ABCMeta):
 2     all_type = ‘alex‘
 3     @abstractmethod        #每一个子类中都要有这个方法,定义格式
 4     def pay(self):pass    #规范一个方法上面加一句@abstractmethod
 5 class Alipay(Pay):
 6     def __init__(self,money):
 7         self.money = money
 8     def pay(self):
 9         print(‘阿里支付了%s元!‘ % self.money)
10 class Jdpay(Pay):
11     def __init__(self,money):
12         self.money = money
13     def pay(self):
14         print(‘京东支付了%s元!‘ % self.money)
15 class Wxpay(Pay):
16     def __init__(self,money):
17         self.money = money
18     def wupay(self):        #这里没有pay方法,再实例化对象时会报错
19         pass
20 p1 = Wxpay(200)
21 #输出结果:
22 TypeError: Can‘t instantiate abstract class Wxpay with abstract methods pay

就比如:老师,下课铃响了(),学生,下课铃响了(),老师执行的是下班操作,学生执行的是方向操作,
虽然二者消息一样,但是执行的效果不同;

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

#str,list,tuple都是序列类型
s=str(‘hello‘)
l=list([1,2,3])
t=tuple((4,5,6))

#我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()

len(s)
len(l)
len(t)

#其实这仅仅这是一种变形操作且仅仅只在类定义阶段发生变形
#类中所有双下划线开头的名称如__x都会在类定义时自动变形成：_类名__x的形式：

class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print(‘from A‘)
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.
#A._A__N是可以访问到的，
#这种，在外部是无法通过__x这个名字访问到。