Python进阶-XVII 非python的接口类、多态、python自己的封装

1、python模拟java中的接口类

　　python中是没有接口类的概念的，因为它支持多继承，但是java不能，所以就提出一个接口类的概念

　　java ： 面向对象编程
　　设计模式   —— 接口
　　接口类 ： python原生不支持
　　抽象类 ： python原生支持的

　　例子：有三种特性，能走，能飞，能游泳，如下三个类，就有了类似java中接口类的作用了。

 class Fly:pass
 class Walk:pass

 # 用多继承，可以表明一个动物的多个本领
 class Swan(Fly, Walk):pass
 class Dog(Walk):pass

 # 上面只是模拟，真实情况下不是这样使用，而是使用语法糖@abstarctmethod来实现。规范代码用！
 from abc import ABCMeta,abstractmethod
 class Swim(metaclass=ABCMeta):
     @abstractmethod
     def swim(self):pass

 class Fish(Fly):
     def swim(self):   # 如果不实现该方法，会报错：TypeError: Can't instantiate abstract class Fish with abstract methods swim
         print('eagle fling')

 eagle = Fish()

继续举例：

 class Wechat(Payment):
     def pay(self,money):
         print('已经用微信支付了%s元'%money)

 class Alipay(Payment):
     def pay(self,money):
         print('已经用支付宝支付了%s元' % money)

 class Applepay(Payment):
     def pay(self,money):
         print('已经用applepay支付了%s元' % money)

 def pay(pay_obj,money):  # 统一支付入口
     pay_obj.pay(money)

 # wechat = Wechat()
 # ali = Alipay()
 app = Applepay()
 # wechat.pay(100)
 # ali.pay(200)
 #p = Payment() #TypeError: Can't instantiate abstract class Payment with abstract methods pay

接口类就是多继承

 # tiger 走路 游泳
 # swan 走路 游泳 飞
 # oldying 走路 飞
 from abc import abstractmethod,ABCMeta
 class Swim_Animal(metaclass=ABCMeta):
     @abstractmethod
     def swim(self):pass

 class Walk_Animal(metaclass=ABCMeta):
     @abstractmethod
     def walk(self):pass

 class Fly_Animal(metaclass=ABCMeta):
     @abstractmethod
     def fly(self):pass

 class Tiger(Walk_Animal,Swim_Animal):
     def walk(self):
         pass
     def swim(self):
         pass
 class OldYing(Fly_Animal,Walk_Animal):pass
 class Swan(Swim_Animal,Walk_Animal,Fly_Animal):pass

 # 接口类  刚好满足接口隔离原则 面向对象开发的思想 规范

 

2、强类型语言中的多态

什么是多态
python 动态强类型的语言
鸭子类型
list tuple
不崇尚根据继承所得来的相似
我只是自己实现我自己的代码就可以了。
如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型
list tuple 这种相似，是自己写代码的时候约束的，而不是通过父类约束的
优点 ： 松耦合 每个相似的类之间都没有影响
缺点 ： 太随意了,只能靠自觉

 class Payment:pass

 class Alipay():
     def pay(self,money):
         print('已经用支付宝支付了%s元' % money)

 class Applepay():
     def pay(self,money):
         print('已经用applepay支付了%s元' % money)

 def pay(pay_obj,money):  # 统一支付入口  归一化设计
     pay_obj.pay(money)

 pay()

因为强类型语言，传参时必须指定参数类型！
而python不必如此，天生支持多态，因为它是动态的强类型语言，在传参时没有要求指定类型！

多态 python 天生支持多态

 class List():
     def __len__(self):pass
 class Tuple():
     def __len__(self):pass

 def len(obj):
     return obj.__len__()

 l = Tuple()
 len(l)

 # 强类型语言     多态
 # python 语言    鸭子类型

 # 接口类和抽象类 在python当中的应用点并不是非常必要

3、抽象类

抽象类 ： 规范
一般情况下 单继承 能实现的功能都是一样的，所以在父类中可以有一些简单的基础实现
多继承的情况 由于功能比较复杂，所以不容易抽象出相同的功能的具体实现写在父类中

抽象类还是接口类 ： 面向对象的开发规范 所有的接口类和抽象类都不能实例化
java ：
java里的所有类的继承都是单继承,所以抽象类完美的解决了单继承需求中的规范问题
但对于多继承的需求，由于java本身语法的不支持，所以创建了接口Interface这个概念来解决多继承的规范问题

python
python中没有接口类  ：
   python中自带多继承 所以我们直接用class来实现了接口类
python中支持抽象类  ： 一般情况下 单继承  不能实例化
   且可以实现python代码

 #一切皆文件
 import abc #利用abc模块实现抽象类

 class All_file(metaclass=abc.ABCMeta):
     all_type='file'
     @abc.abstractmethod #定义抽象方法，无需实现功能
     def read(self):
         '子类必须定义读功能'
         with open('filaname') as f:
             pass

     @abc.abstractmethod #定义抽象方法，无需实现功能
     def write(self):
         '子类必须定义写功能'
         pass

 class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
     def read(self):
         print('文本数据的读取方法')
     def write(self):
         print('文本数据的读取方法')

 class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
     def read(self):
         print('硬盘数据的读取方法')

     def write(self):
         print('硬盘数据的读取方法')

 class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
     def read(self):
         print('进程数据的读取方法')

     def write(self):
         print('进程数据的读取方法')

 wenbenwenjian=Txt()

 yingpanwenjian=Sata()

 jinchengwenjian=Process()

 #这样大家都是被归一化了,也就是一切皆文件的思想
 wenbenwenjian.read()
 yingpanwenjian.write()
 jinchengwenjian.read()

 print(wenbenwenjian.all_type)
 print(yingpanwenjian.all_type)
 print(jinchengwenjian.all_type)

4、python自己的封装

广义上面向对象的封装 ：代码的保护，面向对象的思想本身就是一种
只让自己的对象能调用自己类中的方法

狭义上的封装 —— 面向对象的三大特性之一
属性 和 方法都藏起来 不让你看见

 class A:
     name = 'jack'
     def get(self):
         return A.name

 print(A.name)
 a = A()
 print(a.get())

 class B:
     __name = 'tom' # 私有化的属性
     def __get(self):  # 私有化的方法，外边不能访问
         return A.name

     def get(self):  # 共有方法，调用私有方法
         self.__get()

 #print(B.__name) # AttributeError: type object 'B' has no attribute '__name'
 b = B()
 #print(b.__get()) # AttributeError: 'B' object has no attribute '__get'
 b.get()

 class Person:
     __key = 123  # 私有静态属性
     def __init__(self,name,passwd):
         self.name = name
         self.__passwd = passwd   # 私有属性

     def __get_pwd(self):         # 私有方法
         return self.__passwd   #只要在类的内部使用私有属性，就会自动的带上_类名

     def login(self):          # 正常的方法调用私有的方法
         self.__get_pwd()

 alex = Person('alex','alex3714')
 print(alex._Person__passwd)   # _类名__属性名
 #print(alex.get_pwd())

所有的私有 都是在变量的左边加上双下划綫
    对象的私有属性
    类中的私有方法
    类中的静态私有属性
所有的私有的 都不能在类的外部使用