一、接口

什麽是接口

繼承有兩種用途：

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()

python之面向對象（接口和抽象類）