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

1,接口类
class Wechat():
    def pay(self,money):
        print('已经用微信支付了%s元'%money)
class Alipay():
    def pay(self,money):
        print('已经用支付宝支付了%s元' % money)
wechat = Wechat()
ali = Alipay()
# wechat.pay(100)
# ali.pay(200)
#将上面两句用下面的替换,
def pay(pay_obj,money):  # 统一支付入口
    pay_obj.pay(money)
pay(wechat,100)
pay(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 NotImplementedError	#抛出没有实现这个方法的异常

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

def pay(pay_obj,money):  # 统一支付入口
	pay_obj.pay(money)
	
app = Applepay()
pay(app,100)	#报错
  2.3,解决方法升级,规范化程序
from abc import abstractmethod,ABCMeta
class Payment(metaclass=ABCMeta):       # 元类 默认的元类 type   #metaclass不是继承,而是指定元类
    @abstractmethod
    def pay(self,money):pass                # 没有实现这个方法
    通过上面的代码,写一个规范程序的父类。将各支付类都继承该父类。起到规范子类程序的作用。
    这样接手的人在实例化对象时,就会报错,并提示少了什么方法。
app = Applepay()  #报错
3,抽象类与接口类
              # python中规范化程序称为 :接口类或者抽象类都可以
    #在Java中有严格区分:
    # 接口类 支持多继承,接口类中的所有的方法都必须不能实现 —— java
    # 抽象类 不支持多继承,抽象类中方法可以有一些代码的实现 —— java

  抽象类的本质还是类,指的是一组类的相似性,包括数据属性(如all_type)和函数属性(如read、write),而接口只强调函数属性的相似性。

  抽象类是一个介于类和接口直接的一个概念,同时具备类和接口的部分特性,可以用来实现归一化设计 

  在python中,并没有接口类这种东西,即便不通过专门的模块定义接口,我们也应该有一些基本的概念。

 
4,多态
    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')
5,鸭子类型
  逗比时刻:
  • Python崇尚鸭子类型,即‘如果看起来像、叫声像而且走起路来像鸭子,那么它就是鸭子’ 。
  • python程序员通常根据这种行为来编写程序。例如,如果想编写现有对象的自定义版本,可以继承该对象,也可以创建一个外观和行为像,但与它无任何关系的全新对象,后者通常用于保存程序组件的松耦合度。
  • 例1:利用标准库中定义的各种‘与文件类似’的对象,尽管这些对象的工作方式像文件,但他们没有继承内置文件对象的方法
  • 例2:序列类型有多种形态:字符串,列表,元组,但他们直接没有直接的继承关系
  #二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass
    def write(self):
        pass
class DiskFile: def read(self): pass def write(self): pass
6,封装
  6.1,封装的方式
    # 广义上面向对象的封装 :代码的保护,面向对象的思想本身就是一种
    # 只让自己的对象能调用自己类中的方法
  # 狭义上的封装 —— 面向对象的三大特性之一
  # 属性 和 方法都藏起来 不让你看见
    # 所有的私有 都是在变量的左边加上双下划綫
            # 对象的私有属性
            # 类中的私有方法
           # 类中的静态私有属性
    # 所有的私有的 都不能在类的外部使用
    #在子类定义的__x不会覆盖在父类定义的__x,因为子类中变形成了:_子类名__x,而父类中变形成了:_父类名__x,即双下滑线开头的属性在继承给子类时,子类是无法覆盖的。
class Person:
    __key = 123  # 私有静态属性
    def __init__(self,name,passwd):
        self.name = name
        self.__passwd = passwd   
		# 在变量的左边加上双下划线,就变成私有属性  #变形为:_Person__passwd
    def __get_pwd(self):	# 私有方法   #变形为:_Person__get_pwd
        return self.__passwd   #只要在类的内部使用私有属性,就会自动的带上“_类名”,在外部这样定义不会。
    def login(self):          # 正常的方法调用私有的方法,即只在内部使用
        self.__get_pwd()
alex = Person('alex','alex3714')
print(alex._Person__passwd)   # “_类名或对象名__属性名”可以调出该属性,但是不要用此方法在外部操作。
# print(alex.get_pwd()) #不可调用

  6.2,可以设置,get和set方法以便在外部更改查看私有属性,可能会想为什么要多此一举,不设成私有的不久行了吗。

    这样写有它的好处,即可以在get和set方法中加限定条件,以满足要求。所以,如果不需要对外限定保护属性,可以不用设定成私有的。

 
class Room:
    def __init__(self,name,length,width):
        self.__name = name
        self.__length = length
        self.__width = width
    def get_name(self):       #不加限定条件的get
        return self.__name
    def set_name(self,newName):  #加限定条件的set
        if type(newName) is str and newName.isdigit() == False:
            self.__name = newName
        else:
            print('不合法的姓名')
    def area(self):
        return self.__length * self.__width

jin = Room('金老板',2,1)
print(jin.area())
jin.set_name('2')
print(jin.get_name())

  6.3,假设父类的私有属性 能被子类调用么?,不会

class Foo:
    __key = '123'       #变形为: _Foo__key

class Son(Foo):
    print(Foo.__key)     #继承属性后变形为: _Son__key

  6.4,会用到私有的这个概念de场景
    1.隐藏起一个属性 不想让类的外部调用
    2.我想保护这个属性,不想让属性随意被改变
    3.我想保护这个属性,不被子类继承

 
posted @ 2019-03-27 10:07  冰羽~zZ  阅读(139)  评论(0编辑  收藏  举报