023_接口类，抽象类，多态，鸭子类型，封装

Posted 2021-11-10 eternity-twinkle

1，接口类

 1 class Wechat():
 2     def pay(self,money):
 3         print(‘已经用微信支付了%s元‘%money)

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

 7 wechat = Wechat()
 8 ali = Alipay()
 9 # wechat.pay(100)
10 # ali.pay(200)
11 #将上面两句用下面的替换，
12 def pay(pay_obj,money):  # 统一支付入口
13     pay_obj.pay(money)
14 pay(wechat,100)
15 psy(ali,200)

 

2
2.1，问题
如果来个人接手这个程序，他要添加一个应用支付。但他并不知道你的其它应用支付方法你定义的都是pay方法（程序如上例），且统一支付接口调用pay方法。
他自己添加的应用支付的支付方法并不是用pay命名的。因此，当用统一接口支付时，找不到对应的支付方法，就会报错。

例如在上程序添加如下代码
class Applepay():
    def zhifu(self,money):
        print(‘已经用applepay支付了%s元‘ % money)

app = Applepay()
pay(app,100) #报错

2.2，解决上问题，
定义一个父类，并将上面的支付程序都继承这个父类，当用统一接口调用时，如该应用的支付没有该方法，就会执行父类的这个pay方法，抛出异常给接受该程序的人看，告诉他，没有实现这个方法。
class Payment:
    def pay(self,money):
 raise NotImplemented   #抛出没有实现这个方法的异常

2.3，解决方法升级，规范化程序
from abc import abstractmethod,ABCMeta
class Payment(metaclass=ABCMeta):  # 元类 默认的元类 type #metaclass不是继承，而是指定元类
    @abstractmethod
    def pay(self,money):pass    # 没有实现这个方法
 

通过上面的代码，写一个规范程序的父类。将各支付类都继承该父类。起到规范子类程序的作用。
这样接手的人在实例化对象时，就会报错，并提示少了什么方法。
app = Applepay()  #报错

2.4，
# python中规范化程序称为 ：接口类或者抽象类都可以
#在Java中有严格区分：
# 接口类 支持多继承，接口类中的所有的方法都必须不能实现 —— java
# 抽象类 不支持多继承，抽象类中方法可以有一些代码的实现 —— java

3，多态
    python没有多态，因为python天生支持多态
    多态指的是一类事物有多种形态,动物有多种形态：人，狗，猪
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print(‘say hello‘)

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print(‘say wangwang‘)

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print(‘say aoao‘)

4,鸭子类型
逗比时刻：
　　Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’
python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象
也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。
例1：利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法
例2：序列类型有多种形态：字符串，列表，元组，但他们直接没有直接的继承关系
 

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

    def write(self):
        pass

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

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

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

# 所有的私有 都是在变量的左边加上双下划綫
    # 对象的私有属性
    # 类中的私有方法
    # 类中的静态私有属性
# 所有的私有的 都不能在类的外部使用
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())