python day19--面向对象，借口，封装

#1.接口类，对象类。规范类中方法的统一。

# 第一版：三个类，每个类中有相同的方法
# class Alipay:
#     def __init__(self,money):
#         self.money=money
#     def pay(self):
#         print('用支付宝支付了{}钱'.format(self.money))
# class JDpay:
#     def __init__(self,money):
#         self.money=money
#     def pay(self):
#         print('用白条支付了{}钱'.format(self.money))
# class Wechatpay:
#     def __init__(self,money):
#         self.money=money
#     def pay(self):
#         print('用微信支付了{}钱'.format(self.money))
# p1=Alipay(200)
# p2=JDpay(300)
# p3=Wechatpay(260)
# p1.pay()#用第一种方法付钱
#第二版：改进，让方法一样
# class Alipay:
#     def __init__(self, money):
#         self.money = money
#     def pay(self):
#         print('用支付宝支付了{}钱'.format(self.money))
# class JDpay:
#     def __init__(self,money):
#         self.money=money
#     def pay(self):
#         print('用京东支付了{}钱'.format(self.money))
# class Wechatpay:
#     def __init__(self,money):
#         self.money=money
#     def pay(self):
#         print('用微信支付了{}钱'.format(self.money))
# def pay(obj):#统一pay的方法
#     obj.pay
# a1=Alipay(200)
# pay(a1)#归一化设计

#第三版，制定规则让方法统一

# from abc import ABCMeta,abstractmethod
#
# class payment(metaclass=ABCMeta):
#     @abstractmethod
#     def pay(self):pass#继承它的类中必须有pay这个方法,方法名也要相同。
# class Alipay(payment):
#     def __init__(self,money):
#         self.money=money
#     def pay(self):
#         print('用支付宝支付了{}钱'.format(self.money))
# class JDpay(payment):
#     def __init__(self,money):
#         self.money=money
#     def pay(self):
#         print('用京东支付了{}钱'.format(self.money))
# class Wechatpay(payment):
#     def __init__(self,money):
#         self.money=money
#     def pay(self):
#         print('用微信支付了{}钱'.format(self.money))
# def pay(obj):
#     obj.pay()
# w1=Alipay(200)
# a2=JDpay(100)
# pay(w1)
# pay(a2)

# from abc import ABCMeta,abstractmethod
# class payment(metaclass=ABCMeta):
#     @abstractmethod
#     def pay(self):pass
#
# class Alipay(payment):
#     def __init__(self,money):
#         self.money=money
#     def pay(self):
#         print('支付宝支付{}钱'.format(self.money))
# def pay(obj):
#     obj.pay()
# w1=Alipay(100)
# pay(w1)
# 2.多态：python没有多态， 处处是多态
#python弱类型语言，不管什么类型传入函数，封装到函数都可以。
#python有鸭子类型，是一种思想。
# class Animal:
#     def eat(self):
#         pass
# class Person:
#     def eat(self):
#         pass
# class machine:
#     def eat(self):
#         pass

#这些类 都互称为鸭子.有相同的方法，名字相同。

#3.封装
#广义的封装：实例化一个对象，给对象空间封装一些属性。
#狭义的封装：私有制

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

#1）私有静态字段
# class me:
#     __age=20
#     def __init__(self):
#         print(self.__age)
#     def my(self):
#         print(me.__age)
# class Anyone(me):
#     __name='alen'
#     def func(self):
#         print(Anyone.__name)#内部可以访问
#     def func1(self):
#         # print(self.__name)
#         print(self.age)
# a1=Anyone()#可以访问父类中__init__中的私有字段
# print(a1.__name)#实例化对象不能访问私有字段
# print(Anyone.__name)#类名不能访问私有字段

# 对于私有静态字段,类的外部不能访问.
# print(a1.func())#函数内部可以访问
# 对于私有静态字段,类的内部可以访问.
# print(a1.func1())
# 对于私有静态字段来说,只能在本类中内部访问,类的外部,派生类均不可访问.
# print(a1.my())#本类可以访问
#2)私有方法
# class A:
#     __my="asdfa"
#     def __mylove(self):
#         print('woaini')
# class B(A):
#     def __youlove(self):
#         print('oh my god')
#     def funck(self):
#         # self.__mylove# 类的派生类也不能访问.
#         self.__youlove()#类内部的方法可以访问
# a1=B()
# # a1.__youlove()#不能在类外部执行方法
# a1.funck()# 类的派生类也不能访问.





# class brith:
#     __air='020'
#     def __bb(self):
#         print('呼吸空气')
#     def __init__(self):
#         self.__bb()
#
# class day(brith):
#     def __aa(self):
#         print('阿斯顿发送到')
#
# a1=day()