精华内容
下载资源
问答
  • python中的抽象类

    2021-06-09 08:57:07
    1.首先知道python中的抽象类其实就是一种代码规范,前面两篇文章python中的单继承和python中的多继承说的都是一个道理归根到底都是为了代码规范,同样也是从Java中继承的思想,抽象类一般都是单继承,由于多个子类...

    python中的抽象类

    1.首先知道python中的抽象类其实就是一种代码规范,和前面两篇文章python中的单继承和python中的多继承说的都是一个道理归根到底都是为了代码规范,同样也是从Java中继承的思想,抽象类一般都是单继承,由于多个子类都需要继承同一个类,所以可以在抽象类中实现具体的方法,但是子类中还是要实现具体的方法,看下面的例子,抽象类中实现了文件打开和关闭操作,但是子类中还是定义了 读写功能,为了理解的简便还是可以直接理解成抽象类中不实现具体的方法,子类中必须实现具体的方法

    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)
    print(yingpanwenjian.all_type)
    print(jinchengwenjian.all_type)
    
    # 抽象类 : 规范
    # 一般情况下 单继承 能实现的功能都是一样的,所以在父类中可以有一些简单的基础实现
    # 多继承的情况 由于功能比较复杂,所以不容易抽象出相同的功能的具体实现写在父类中
    
    
    # 抽象类还是接口类 : 面向对象的开发规范 所有的接口类和抽象类都不能实例化
    # java :
    # java里的所有类的继承都是单继承,所以抽象类完美的解决了单继承需求中的规范问题
    # 但对于多继承的需求,由于java本身语法的不支持,所以创建了接口Interface这个概念来解决多继承的规范问题
    
    # python
    # python中没有接口类  :
      #  python中自带多继承 所以我们直接用class来实现了接口类
    # python中支持抽象类  : 一般情况下 单继承  不能实例化
      #  且可以实现python代码
    
    展开全文
  • 这两个概念来自于Java,因为Java中没有多继承,是通过接口实现的多继承,所以在java中他们是两个东西; 而在Python中,因为有多继承的存在,...class Payment(metaclass=ABCMeta): # 抽象类(接口类): @abstractmetho...

    这两个概念来自于Java,因为Java中没有多继承,是通过接口实现的多继承,所以在java中他们是两个东西;

    而在Python中,因为有多继承的存在,所以是同一种东西.

    from abc import ABCMeta, abstractmethod
    
    
    class Payment(metaclass=ABCMeta):  # 抽象类(接口类):
        @abstractmethod
        def pay(self): pass  # 制定了一个规范
    
        @abstractmethod
        def func(self): pass
    
    
    class Alipay(Payment):
        def __init__(self, money):
            self.money = money
    
        def pay(self):
            print('使用支付宝支付了%s' % self.money)
    
    
    class Jdpay(Payment):
        def __init__(self, money):
            self.money = money
    
        def pay(self):
            print('使用京东支付了%s' % self.money)
    
    
    class Wechatpay(Payment):
    
        def __init__(self, money):
            self.money = money
    
        def pay(self):
            print('使用微信支付了%s' % self.money)

     

    抽象类的子类通过不同的方式实现了同一个功能,有相同的方法名.

    转载于:https://www.cnblogs.com/DoingBe/p/9438322.html

    展开全文
  • python基础——抽象类

    2017-04-26 13:33:00
    java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化 2 为什么要有抽象类 如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类...

    python基础——抽象类

     

    1  什么是抽象类

    与java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化

     

    2 为什么要有抽象类

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

     

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

     

    从实现角度来看,抽象类与普通类的不同之处在于:抽象类中只能有抽象方法(没有实现功能),该类不能被实例化,只能被继承,且子类必须实现抽象方法。这一点与接口有点类似,但其实是不同的,即将揭晓答案

     

    3 在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)
    

     

     

    4 抽象类与接口  

    抽象类的本质还是类,指的是一组类的相似性,包括数据属性(如all_type)和函数属性(如read、write),而接口只强调函数属性的相似性。

    抽象类是一个介于类和接口直接的一个概念,同时具备类和接口的部分特性,可以用来实现归一化设计 

     

     

    转载于:https://www.cnblogs.com/niejinmei/p/6768120.html

    展开全文
  • Python--抽象类

    2018-06-25 15:48:36
    1什么是抽象类java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化2为什么要有抽象类如果说类是从一堆对象中抽取相同的内容而来的,那么...

    1什么是抽象类

    与java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化

    2为什么要有抽象类

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

     

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

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

    从实现角度来看,抽象类与普通类的不同之处在于:抽象类中只能有抽象方法(没有实现功能),该类不能被实例化,只能被继承,且子类必须实现抽象方法。

     

    3在python中实现抽象

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    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() #报错,子类没有定义抽象方法

      

     

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    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)

      

     

    4抽象类与接口

    抽象类的本质还是类,指的是一组类的相似性,包括数据属性(如all_type)和函数属性(如read、write),而接口只强调函数属性的相似性。

    抽象类是一个介于类和接口直接的一个概念,同时具备类和接口的部分特性,可以用来实现归一化设计

     

    5继承原理

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    class A(object):
     
        def test(self):
     
            print('from A')
     
      
     
    class B(A):
     
        def test(self):
     
            print('from B')
     
      
     
    class C(A):
     
        def test(self):
     
            print('from C')
     
      
     
    class D(B):
     
        def test(self):
     
            print('from D')
     
      
     
    class E(C):
     
        def test(self):
     
            print('from E')
     
      
     
    class F(D,E):
     
        # def test(self):
     
        #     print('from F')
     
        pass
     
    f1=F()
     
    f1.test()
     
    print(F.__mro__) #只有新式才有这个属性可以查看线性列表,经典类没有这个属性
     
      
     
    #新式类继承顺序:F->D->B->E->C->A
     
    #经典类继承顺序:F->D->B->A->E->C
     
    #python3中统一都是新式类
     
    #pyhon2中才分新式类与经典类

      

     

    对于你定义的每一个类,python会计算出一个方法解析顺序(MRO)列表,这个MRO列表就是一个简单的所有基类的线性顺序列表

    1
    2
    3
    >>> F.mro() #等同于F.__mro__
     
    [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

      

     

    为了实现继承,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。

    而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

    1.子类会先于父类被检查

    2.多个父类会根据它们在列表中的顺序被检查

    3.如果对下一个类存在两个合法的选择,选择第一个父类

    展开全文
  • python 抽象方法 抽象类实现

    千次阅读 2015-06-09 13:53:14
    抽象基类 ABC 是一些不能被实例化的Java 或 C++ 语言的程序员应该对此概念十分熟悉。Python 3 添加了一个新的框架 —abc— 它提供了对 ABC 的支持。 这个 abc 模块具有一个元(ABCMeta) 修饰符(@...
  • 1. 接口接口提取了一群共同的函数,可以把接口当做一个函数的集合。...# java : 面向对象编程# 设计模式 —— 接口# 接口python原生不支持# 接口不可以实例化from abc import abstractmethod,ABCM...
  • 最近在看回顾java 抽象类,顺便对比下python 抽象类。两者概念上基本一致,但是在java静态语言的原因,使用方式更加花俏些。 抽象类是包含抽象方法的类,而抽象方法不包含任何可实现的代码,只能在其子类中实现抽象...
  • python 接口类和抽象类

    2018-01-19 20:11:00
    首先要知道的就是,不管是接口类还是抽象类,都是一种设计模式,是面对对象开发规范 而这种设计模式是java提出来的,java还有很多类似的东西被其它编程语言沿用 接口类是java为了实现多继承,设计的一个概念 python...
  • 提起Java抽象类大家都比较熟悉,Python中我们可以使用abc模块来构建抽象类,这里就为大家讲解在Python中定义使用抽象类的方法
  • 先说一下补全代码快捷键alt+/ ,之后单词的部分或者全部就可以提示...1、抽象类和抽象方法 package myfirst_Java; //定义抽象类,abstract,抽象方法不能写方法的实现 abstract class Figure{ public abstract vo...
  • python的接口和抽象类

    2018-03-13 11:07:59
    python的接口和抽象类抽象基类有些面向对象的语言,如JAVA,支持接口,可以声明一个支持给定的一些方法方法,或者支持给定存取协议的类。抽象基类(或者ABCs)是Python里一个相同的特性。抽象基类由abc模块构成,...
  • python抽象类

    2019-08-19 16:53:49
    java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化 2 为什么要有抽象类 如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类...
  • python抽象类

    2017-04-24 19:06:00
    java一样,python也有抽象类的概念但是同样需要借助模块实现,抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化 2为什么要有抽象类 如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类...
  • 和Java一样,Python语言支持抽象类抽象类用于被继承,而不能被实例化。 抽象类至少有一个抽象方法。所谓抽象方法,在抽象类中,只有声明,没有具体实现,具体实现必须在子类中,或者说,子类需要实现抽象类中的...
  • python抽象类和接口

    千次阅读 2018-11-17 08:50:42
    起因 最近在写上两篇restframework的博文中遇到了一个问题,认证权限中有一个方法定义必须为...java中的抽象类和接口 参数 抽象类 接口 默认的方法实现 它可以有默认的方法实现 接口完全是...
  • java抽象类和接口类

    2016-05-07 16:23:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • JAVA抽象类和接口

    2016-11-08 11:21:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • python 抽象类和接口

    2020-07-07 21:41:45
    可以通过普通实现接口,但是并没有起到规范作用,继承者可以选择实现或不实现 ...通过abc模块来创建,类似于java中的abstract class # 通过`abc`模块来创建 # import abc # class Animal(metaclass=abc.ABCMeta): # @ab
  • 作者介绍:Runsen目前大三下学期,专业化学工程与工艺,大学沉迷日语,PythonJava和一系列数据分析软件。导致翘课严重,专业排名中下。.在大学60%的时间,都在CSDN。决定今天比昨天要更加努力。 我预计写零基础学...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 392
精华内容 156
关键字:

python和java抽象类

python 订阅
java 订阅