python之面向对象（接口和抽象类）

一、接口

什么是接口

继承有两种用途：

1：继承基类的方法，并且做出自己的改变或者扩展（代码重用）。

2：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能。

class File:　　　　  #定义接口File类来模仿接口的概念。
    def read(self): #定接口函数read
        pass

    def write(self): #定义接口函数write
        pass

class Txt(File): #文本，具体实现read和write
    def read(self):
        print(‘文本数据的读取方法‘)

    def write(self):
        print(‘文本数据的读取方法‘)

class Sata(file): #磁盘，具体实现read和write
    def read(self):
        print(‘硬盘数据的读取方法‘)

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

class Process(File):
    def read(self):
        print(‘进程数据的读取方法‘)

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

#父类要限制
#1：子类必须要有父类的方法
#2：子类实现的方法必须跟父类的方法的名字一样
import abc

class File(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def read(self):
        pass

    @abc.abstractmethod
    def write(self):
        pass

class Txt(File): #文本，具体实现read和write
    def read(self):
        pass
    def write(self):
        pass
t=Txt()

实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。

继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。

归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。

二、抽象类

1、什么是抽象类

抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化。

2、为什么要有抽象类

如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。

　 比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。

从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。

　 从实现角度来看，抽象类与普通类的不同之处在于：抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，且子类必须实现抽象方法。这一点与接口有点类似，但其实是不同的。

3、在python中实现抽象类

 1 import abc
 2 class File(metaclass=abc.ABCMeta):  #metaclass指的是元类，边会讲，现在只需记住这个词
 3     @abc.abstractmethod     #抽象方法，即一个装饰器装饰read属性
 4     def read(self):
 5         pass
 6     @abc.abstractmethod      #抽象方法，即一个装饰器装饰write属性
 7     def write(self):
 8         pass
 9 # # 当继承File类时候，如果没有read和write方法，会提示出错TypeError: Can‘t instantiate abstract class Txt with abstract methods read, write
10 # class Txt(File):
11 #     def du(self):
12 #         print(‘文本数据的读取方法‘)
13 #     def xie(self):
14 #         print(‘文本数据的写入方法‘)
15 #定义子类具体实现文本的读写操作
16 class Txt(File):
17     def read(self):
18         print(‘文本数据的读取方法‘)
19     def write(self):
20         print(‘文本数据的写入方法‘)
21 #定义子类具体实现硬盘的读写操作
22 class Sata(File):
23     def read(self):
24         print(‘硬盘数据的读取方法‘)
25     def write(self):
26         print(‘硬盘数据的写入方法‘)
27 #定义子类具体实现进程的读写操作
28 class Process(File):
29     def read(self):
30         print(‘进程数据的读取方法‘)
31     def write(self):
32         print(‘进程数据的写入方法‘)

测试验证：

1 t=Txt()
 2 t.read()
 3 t.write()
 4 s=Sata()
 5 s.read()
 6 s.write()
 7 输出结果：
 8 文本数据的读取方法
 9 文本数据的写入方法
10 硬盘数据的读取方法
11 硬盘数据的写入方法

三、组合的应用和序列化

1、日期类、课程类、人类、老师类、学生类的组合应用

class Date: 　　#定义日期类
    def __init__(self,name,year,mon,day):
        self.name=name
        self.year=year
        self.mon=mon
        self.day=day
    def tell_birth(self):
        print(‘%s %s-%s-%s‘%(self.name,self.year,self.mon,self.day))
class Course:　　#定义科目类
    def __init__(self, name, price, period):
        self.name = name
        self.price = price
        self.period = period
    def tell_course(self):
        print(‘‘‘----------%s info----------
course name:%s
course price:%s
course period:%s‘‘‘ % (self.name, self.name, self.price, self.period))
class Person:　　#定义人类
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
        self.courses=[]
    def walk(self):
        print(‘%s is walking‘ %self.name)
    def tell_course(self):
        for obj in self.courses:
            obj.tell_course()
class Teacher(Person):　　#定义老师类，继承Person
    def __init__(self,name,age,sex,salary,level):
        Person.__init__(self,name,age,sex)
        self.salary=salary
        self.level=level
    def teach(self):
        print(‘%s is teaching‘ %self.name)
    def tell_info(self):
        print(‘‘‘----------%s info ---------
    NAME:%s
    AGE: %s
    SEX: %s
    SAL: %s
    LEVEL:%s‘‘‘%(self.name,self.name,self.age,self.sex,self.salary,self.level))
class Student(Person):　　#定义学生类，继承Person
    def __init__(self,name,age,sex,group):
        Person.__init__(self,name,age,sex)
        self.group=group
    def study(self):
        print(‘%s is teaching‘ %self.name)
    def tell_info(self):
        print(‘‘‘----------%s info ---------
    NAME:%s
    AGE: %s
    SEX: %s
    GROUP: %s‘‘‘%(self.name,self.name,self.age,self.sex,self.group))

egon=Teacher(‘egon‘,18,‘male‘,3000,10)
python=Course(‘Python‘,15800,‘6mons‘)
linux=Course(‘Linux‘,1800,‘3mons‘)
egon.courses.append(python)
egon.courses.append(linux)
egon.tell_course()
egon.birth=Date(‘egon‘,1991,11,11)
egon.birth.tell_birth()
xh=Student(‘xh‘,18,‘male‘,‘group1‘)
xh.courses.append(python)
xh.tell_course()
xh.tell_info()

2、序列化

class Student:
    def __init__(self, name, age, sex, group):
        self.name=name
        self.age=age
        self.sex=sex
        self.group=group
    def study(self):
        print(‘%s is study‘ % self.name)
    def tell_info(self):
        print(‘‘‘
        ----------%s info---------
        NAME:%s
        AGE:%s
        SEX:%s
        group:%s
        ‘‘‘ %(self.name,self.name,self.age,self.sex,self.group))
import pickle
xh=Student(‘xh‘,18,‘male‘,‘group1‘)
with open(‘studentdb.pkl‘,‘wb‘)as f:
    pickle.dump(xh,f)
with open(‘studentdb.pkl‘,‘rb‘)as f:
    obj=pickle.load(f)
    obj.tell_info()