Python面向對象編程——抽象類

Python面向對象編程——抽象類

1、接口與歸一化設計

一、什麼是接口

hi boy，給我開個查詢接口。。。此時的接口指的是：本身提供給使用者來調用本身功能的方式\方法\入口，java中的interface使用以下：

=================第一部分：Java 語言中的接口很好的展示了接口的含義: IAnimal.java
/*
* Java的Interface接口的特徵:
* 1)是一組功能的集合,而不是一個功能
* 2)接口的功能用於交互,全部的功能都是public,即別的對象可操做
* 3)接口只定義函數,但不涉及函數實現
* 4)這些功能是相關的,都是動物相關的功能,但光合做用就不適宜放到IAnimal裏面了 */

package com.oo.demo;
public interface IAnimal {
    public void eat();
    public void run(); 
    public void sleep(); 
    public void speak();
}

=================第二部分：Pig.java：豬」的類設計,實現了IAnnimal接口 
package com.oo.demo;
public class Pig implements IAnimal{ //以下每一個函數都須要詳細實現
    public void eat(){
        System.out.println("Pig like to eat grass");
    }

    public void run(){
        System.out.println("Pig run: front legs, back legs");
    }

    public void sleep(){
        System.out.println("Pig sleep 16 hours every day");
    }

    public void speak(){
        System.out.println("Pig can not speak"); }
}

=================第三部分：Person2.java
/*
*實現了IAnimal的「人」,有幾點說明一下: 
* 1)一樣都實現了IAnimal的接口,但「人」和「豬」的實現不同,爲了不太多代碼致使影響閱讀,這裏的代碼簡化成一行,但輸出的內容不同,實際項目中同一接口的同一功能點,不一樣的類實現徹底不同
* 2)這裏一樣是「人」這個類,但和前面介紹類時給的類「Person」徹底不同,這是由於一樣的邏輯概念,在不一樣的應用場景下,具有的屬性和功能是徹底不同的 */

package com.oo.demo;
public class Person2 implements IAnimal { 
    public void eat(){
        System.out.println("Person like to eat meat");
    }

    public void run(){
        System.out.println("Person run: left leg, right leg");
    }

    public void sleep(){
        System.out.println("Person sleep 8 hours every dat"); 
    }

    public void speak(){
        System.out.println("Hellow world, I am a person");
    } 
}

=================第四部分：Tester03.java
package com.oo.demo;

public class Tester03 {
    public static void main(String[] args) {
        System.out.println("===This is a person==="); 
        IAnimal person = new Person2();
        person.eat();
        person.run();
        person.sleep();
        person.speak();

        System.out.println("\n===This is a pig===");
        IAnimal pig = new Pig();
        pig.eat();
        pig.run();
        pig.sleep();
        pig.speak();
    } 
}

 java中的interface

二、爲什麼要用接口

接口提取了一羣類共同的函數，能夠把接口當作一個函數的集合。

而後讓子類去實現接口中的函數。

這麼作的意義在於歸一化，什麼叫歸一化，就是隻要是基於同一個接口實現的類，那麼全部的這些類產生的對象在使用時，從用法上來講都同樣。

歸一化的好處在於：

一、歸一化讓使用者無需關心對象的類是什麼，只須要的知道這些對象都具有某些功能就能夠了，這極大地下降了使用者的使用難度。

二、歸一化使得高層的外部使用者能夠不加區分的處理全部接口兼容的對象集合

I、就好象linux的泛文件概念同樣，全部東西均可以當文件處理，沒必要關心它是內存、磁盤、網絡仍是屏幕（固然，對底層設計者，固然也能夠區分出「字符設備」和「塊設備」，而後作出針對性的設計：細緻到什麼程度，視需求而定）。

II、再好比：咱們有一個汽車接口，裏面定義了汽車全部的功能，而後由本田汽車的類，奧迪汽車的類，大衆汽車的類，他們都實現了汽車接口，這樣就好辦了，你們只須要學會了怎麼開汽車，那麼不管是本田，仍是奧迪，仍是大衆咱們都會開了，開的時候根本無需關心我開的是哪一類車，操做手法（函數調用）都同樣

三、模仿interface

在python中根本就沒有一個叫作interface的關鍵字，若是非要去模仿接口的概念

能夠藉助第三方模塊：http://pypi.python.org/pypi/zope.interface

也可使用繼承，其實繼承有兩種用途

一、繼承基類的方法，而且作出本身的改變或者擴展（代碼重用）：實踐中，繼承的這種用途意義並不很大，甚至經常是有害的。由於它使得子類與基類出現強耦合。

二、聲明某個子類兼容於某基類，定義一個接口類（模仿java的Interface），接口類中定義了一些接口名（就是函數名）且並未實現接口的功能，子類繼承接口類，而且實現接口中的功能。

class Interface:#定義接口Interface類來模仿接口的概念，python中壓根就沒有interface關鍵字來定義一個接口。
    def read(self): #定接口函數read
        pass

    def write(self): #定義接口函數write
        pass


class Txt(Interface): #文本，具體實現read和write
    def read(self):
        print('文本數據的讀取方法')

    def write(self):
        print('文本數據的讀取方法')

class Sata(Interface): #磁盤，具體實現read和write
    def read(self):
        print('硬盤數據的讀取方法')

    def write(self):
        print('硬盤數據的讀取方法')

class Process(Interface):
    def read(self):
        print('進程數據的讀取方法')

    def write(self):
        print('進程數據的讀取方法')

上面的代碼只是看起來像接口，其實並無起到接口的做用，子類徹底能夠不用去實現接口 ，這就用到了抽象類。

2、抽象類

一、什麼是抽象類

與java同樣，python也有抽象類的概念可是一樣須要藉助模塊實現，抽象類是一個特殊的類，它的特殊之處在於只能被繼承，不能被實例化。

二、爲何要有抽象類

若是說類是從一堆對象中抽取相同的內容而來的，那麼抽象類就是從一堆類中抽取相同的內容而來的，內容包括數據屬性和函數屬性。

好比咱們有香蕉的類，有蘋果的類，有桃子的類，從這些類抽取相同的內容就是水果這個抽象的類，你吃水果時，要麼是吃一個具體的香蕉，要麼是吃一個具體的桃子。。。。。。你永遠沒法吃到一個叫作水果的東西。

從設計角度去看，若是類是從現實對象抽象而來的，那麼抽象類就是基於類抽象而來的。

從實現角度來看，抽象類與普通類的不一樣之處在於：抽象類中只能有抽象方法（沒有實現功能），該類不能被實例化，只能被繼承，且子類必須實現抽象方法。這一點與接口有點相似，但實際上是不一樣的，即將揭曉答案

三、在python中實現抽象類

#一切皆文件
import abc #利用abc模塊實現抽象類

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定義抽象方法，無需實現功能
    def read(self):
        '子類必須定義讀功能'
        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)

四、抽象類與接口

抽象類的本質仍是類，指的是一組類的類似性，包括數據屬性（如all_type）和函數屬性（如read、write），而接口只強調函數屬性的類似性。

抽象類是一個介於類和接口直接的一個概念，同時具有類和接口的部分特性，能夠用來實現歸一化設計。