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），而接口只强调函数属性的类似性。

抽象类是一个介于类和接口直接的一个概念，同时具有类和接口的部分特性，能够用来实现归一化设计。