python学习day25 接口类 抽象类 多态 封装

接口类和抽象类都是一种编程思想或者规范 从JAVA中而来

抽象类：python原生支持的

接口类：python原生不支持

 它们的目的是规范

 

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

python：
python中没有接口类，因为python中自带多继承 所以直接用class来实现了接口类
python中支持抽象类 ： 一般情况下 单继承

接口类和抽象类都不能实例化
接口类中的方法不能有可以实现的代码，抽象类中的方法可以有实现的python代码

接口类：

## 定义规范 继承这个类的时候必须使用这个类中的方法
from abc import abstractmethod,ABCMeta
class Payment(metaclass=ABCMeta):  # 元类 默认的元类 type
    @abstractmethod
    def pay(self,money):pass   # 没有实现这个方法 如果继承的子类中没有使用这个方法，就会报错

 接口类中的方法只定义 但是不能有实现代码

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

 

抽象类：

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)  # 'file'
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

 

抽象类规范的是几个类的功能非常相似的问题，一般是单继承

接口类规范的是几个类中的方法有重叠，也有不重叠，多继承

 接口类和抽象类其实就是用父类来规范，它们中的方法不能代替定义的新类中的方法 

 接口类和抽象类是在JAVA中区别的  python区分不明显

 

多态

面向对象三大特性：封装、继承、多态

python是动态强类型语言，也就是说它对有些问题不强，有些问题类型很强，所以说是动态的。它天生支持多态

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

比如一个函数如果要调用不同类的中相同的方法时，需要将这两个类继承同一个父类，如下 伪代码

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

# 对于其它语言，形参的前面需要加上数据类型，
# 这个函数调用不同类中的__len__方法，
def len(Foo obj):   # 给一个父类的数据类型 这就是多态
    return obj.__len__()

而在python中， 天生自带多态：

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

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

 这就是鸭子类型，python中的特有属性

两个类中的方法一致，但它们又不是被同一个父类规范所约束的兄弟关系。不依赖父类的情况下实现两个相似的类中的同名方法

比如List, Tuple 这两种类型中的方法相似，它们不是通过父类约束的

优点 ： 松耦合 每个相似的类之间都没有影响
缺点 ： 太随意了,只能靠自觉

 

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

因为python中有鸭子类型，不崇尚用继承来规范代码，

 

转载于:https://www.cnblogs.com/happyfan/p/10085400.html