python学习之老男孩python全栈第九期_day025知识点总结——接口类、抽象类、多态、封装

一. 接口类

java：面向对象编程

设计模式 -- 接口类

接口类：python原生不支持

抽象类：python 原生支持的

from abc import abstractclassmethod,ABCMeta

class Payment(metaclass= ABCMeta):         # 元类，默认元类：type

    @abstractclassmethod

    def pay(self, money):

        raise NotImplemented        # 没有实现这个方法

# Payment 规范：接口类/抽象类

# 一般使用多继承了，就用接口类

    # 接口类中的所有方法都必须不能实现 -- Java

# 抽象类不支持多继承

    # 抽象类中可以有一些代码的实现 -- Java

class Wechat(Payment):

    def pay(self, money):

        print('已经使用微信支付了%s元'%money)

class Alipay(Payment):

    def pay(self,money):

        print('已经使用支付宝支付了%s元' % money)

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

    pay_obj.pay(money)

class Applepay(Payment):

    def pay(self, money):

        print('已经使用applepay支付了%s元' % money)

wechat = Wechat()

# wechat.pay(100)

ali = Alipay()

# ali.pay(200)

app = Applepay()

# app.fuqian(199)

pay(wechat,100)

pay(ali,100)

pay(app,199)

tiger：走路，游泳           # 老虎

swan：走路，游泳，飞      # 天鹅

oldying：走路，飞          # 老鹰

from abc import abstractclassmethod,ABCMeta

class Swim_Animal(metaclass=ABCMeta):

    @abstractclassmethod

    def swim(self):

        pass

class Walk_Animal(metaclass=ABCMeta):

    @abstractclassmethod

    def walk(self):

        pass

class Fly_Animal(metaclass=ABCMeta):

    @abstractclassmethod

    def fly(self):

        pass

class Tiger(Walk_Animal, Swim_Animal):

    def walk(self):

        pass

    def swim(self):

        pass

class Swan(Walk_Animal, Swim_Animal, Fly_Animal):

    def walk(self):

        pass

    def swim(self):

        pass

    def fly(self):

        pass

class Oldying(Walk_Animal, Fly_Animal):

    def walk(self):

        pass

    def fly(self):

        pass

# 接口类

    # 原则：接口隔离原则：使用多个专门的接口，而不是使用单一的总接口，即客户端不应该依赖那些不需要的接口

    # 面向对象开发的思想、规范

---

二. 抽象类

# 一切皆文件

import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):

    all_type='file'

    @abc.abstractmethod #定义抽象方法，无需实现功能

    def read(self):

        '子类必须定义读功能'

        with open('fileName') as f:

            pass

    @abc.abstractmethod #定义抽象方法，无需实现功能

    def write(self):

        '子类必须定义写功能'

        pass

class Txt(All_file):

    pass

t1=Txt() #报错,子类没有定义抽象方法

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)

抽象类：规范

一般情况下，是单继承，能实现的功能都是一样的 ，所以在父类中可以有一些简单的基础实现

多继承的情况，由于功能比较复杂，所以不容易抽象出相同的功能的具体实现 写在父类中

不管是抽象类还是接口类：都是面向对象的开发规范

python中没有接口类。在Java中，有接口interface这个概念，是因为Java中不支持多继承。

    python中自带多继承，所以我们直接用class来实现了接口类

python中支持抽象类： 一般情况下为 单继承 ，且可以实现python代码

    接口类和抽象类都不能实现实例化

Java：

    java里的所有类的继承都是单继承，所以抽象类完美的解决了单继承需求中的规范问题

    但对于多继承的需求，由于Java本身语法的不支持，所以创建了接口interface这个概念来解决多继承的问题。

---

三. 多态

多态 python 天生支持多态

其他语言中：

def func(int num, str name):

    pass

func(2,'alex')

class Payment():pass

class Alipay(Payment):

    def pay(self,money):

        print('已经使用支付宝支付了%s元' % money)

def pay(Payment pay_obj, int money):

    pay_obj.pay(money)

class Applepay(Payment):

    def pay(self, money):

        print('已经使用applepay支付了%s元' % money)

实现了多态

什么是多态？

多态指的是一类事物有多种形态

文件有多种形态：文本文件，可执行文件

动物有多种形态：人，狗，猪

 python 动态强类型的语言

python崇尚 鸭子类型

list tuple

class foo:

    def slice(self):pass

    def index(self):pass

class list(foo):

    def slice(self):pass

    def index(self):pass

class tuple(foo):

    def slice(self):pass

    def index(self):pass

鸭子类型不崇尚根据继承所得来的相似

而是只是自己实现自己的代码就可以了

如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型

list tuple 这种相似，是自己写代码的时候约束的，而不是通过父类约束的

优点：松耦合 （每个相似的类之间都没有影响）

缺点：太随意了，只能靠自觉

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

---

四. 封装

广义上面向对象的封装：代码的保护，面向对象的思想本身就是一种封装

只让自己的对象能调用自己类中的方法

狭义上的封装 -- 面向对象的三大特性之一

把 属性 和 方法 都藏起来 ，不让你看见

class Person:

    __key = 123         # 私有的静态属性

    def __init__(self,name, password):

        self.name = name

        self.__password = password              # 私有属性：前面加上双下划线

    def __get_pwd(self):                          # 私有方法

        print(self.__dict__)

        return self.__password              # 只要在类的内部使用私有属性，就会自动的带上_类名

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

        self.__get_pwd()

alex = Person('alex','alex3714')

# print(alex.__password)

print(alex.__dict__)            # {'name': 'alex', '_Person__password': 'alex3714'}

# print(alex._Person__password)       # alex3714    可以这样调，但不能这么用（_类名__属性名）

alex.__high = 1

print(alex.get_pwd())           # {'name': 'alex', '_Person__password': 'alex3714', '__high': 1}

print(alex.__high)

所有的私有，都是在变量的左边加上双下划线

    对象的私有属性

    类中的私有方法

    类中的静态属性

所有的私有的，都不能在类的外部使用