精华内容
下载资源
问答
  • 接口与抽象类区别

    2014-09-15 13:52:49
    主要介绍接口与抽象类区别,为那些困惑的人指点迷津。
  • 接口与抽象类区别: 关键字不同 1.声明:抽象类用 abstract class , 接口用 interface 2.使用:抽象类用 extends , 接口用 implements 属性 抽象类可以拥有普通的成员变量,而接口中的...

    接口与抽象类区别:

     

    关键字不同

    1.声明:抽象类用 abstract class   ,   接口用 interface

    2.使用:抽象类用 extends   ,    接口用 implements

    属性

    抽象类可以拥有普通的成员变量,而接口中的成员变量必须是公开、静态和最终的常量(public static final)

    方法

    jdk1.8之前:抽象类可以拥有默认的方法实现,而接口中的方法都是抽象方法

    jdk1.8之后:接口中可以有default和static方法

    构造方法

    抽象类拥有构造方法,而接口没有构造方法

    继承关系类与类之间是单继承,接口与接口之间是多继承
    main方法接口没有main方法,因此我们不能运行它。(java8以后接口可以有default和static方法,所以可以运行main方法)

                 

    展开全文
  • java接口与抽象类区别

    千次阅读 2011-10-27 18:21:21
    OOP中接口与抽象类区别 Java语言接口与继承的本质 深入理解接口抽象类   OOP中接口与抽象类区别 OOP中的INTERFACE和ABSTRACT CLASS是两个不同的概念 我们在使用的时候往往将两个混在一起使用,不做什么...
      
    

    很久没有看到如此精辟的文章了!作者写得实在太好了!正在学JAVA或者想了解抽象类与接口的朋友,绝对不可错过!本人极力推荐!

    1. OOP中接口与抽象类的区别
    2. Java语言接口与继承的本质
    3. 深入理解接口和抽象类
       

    OOP中接口与抽象类的区别

    OOP中的INTERFACE和ABSTRACT CLASS是两个不同的概念

    我们在使用的时候往往将两个混在一起使用,不做什么区别,大家可能在定义上对他们的区别有不少见解

    这里我不用什么专业术语什么的,一个字“烦”,我们就以最简单的白话来讨论.

    其实这两个东西在使用上是有很大区别的,我自己郁闷了好半天才有所领悟

    在我们对一个实体进行抽象的时候将他先分类处理,把他的属性跟主要方法划分为一个类,我们这时候就用到了ABSTRACT CLASS,而INTERFACE则是用来增加功能的直接对外的。

    一般应用里边,接口是直接对外的,抽象类其次,最后才是具体实现方法的类。

    我们用一个简单的例子说明:

    我们现在要分析“计算机”这个实体

    首先计算机部件有(主机,显示器)我们,然后分析部件的行为,主机可以(开机,关机),显示器也可以(打开,关闭),这些都是计算机的基本功能,也是必须的

    abstract Class jisuanji{

    String zhuji,xianshiqi;

    abstract zj_on();

    abstract zj_off();

    abstract xsq_on();

    abstract xsq_off();

    }

    以上就是电脑这个实体的基本组成,但是我们的电脑不光有这些设备,我们还需要键盘,鼠标什么的,这些都是必须的,否则电脑这个东西将不能完成他的基本任务我们可以用继承来实现他

    abstract class PC extends jisuanji{

    String shubiao,jianpan;

    abstract sb_click();

    abstract sb_dblclack();

    }

    我们将计算机的完整部件基本上做好了,但是我们PC是一个多功能设备,不是每个人都用他来做基本的计算工作的,我们可以用他来看电影,听音乐什么的,这个时候我们就需要对他的功能进行扩充,这些设备不一定是电脑上需要的,这里就用到interface

    我们的电脑现在只需要基本的功能和播放音乐的功能,我们用接口去实现他

    interface music{

    public void play();

    }

    这里我们播放音乐的功能也就生成了

    将这些功能集成在一起

    class Computer extends PC implements music{

    <具体实现>

    }

    这里我们就将一个有音乐功能的电脑做成了,我们可能还需要其他功能,在这个时候我们就可以充分利用接口的优点来做到这些功能的随意增加。

    说完了具体的例子,我们回过头来看接口跟抽象类在使用上的区别,抽象类在使用的时候是将主要功能封装起来,在主要部件上的增添(比如电脑的更新换代上)通过抽象类来实现,而接口则偏向于对附加功能的增删管理上。

    这时候有人会问,为什么要那么复杂的去定义一个抽象类又去定义一个接口呢?将这些功能集中起来写在一个类里边多方便,有好理解。这种想法在解决小问题的时候显得得心应手,又好理解,又好写。

    但是我们在解决复杂问题的时候采用这种方法就会暴露出很多的弊端:

    我们在解决一个复杂问题的时候就需要先将他简单的分类,然后针对分类在进行细化,先考虑问题的解决顺序什么的,最后对问题的每个模块都有了掌握之后,我们再对其进行过程的编写。这样我们在面对一个复杂的问题时就会显得得心应手,而那种写在一起的方法则不能将问题考虑周全,即使勉强考虑周全了,估计代码也就没几个人能看懂了,使用起来也显得很烦琐,找不到个头绪。

    事物不是一成不变的,他是在不断的发展,可能有很多变化,我们经常需要对一个已存在的程序进行功能的扩充和删除,使用这里我们分析的方法可以很有条理的去解决这个问题(将主要功能的增加用类的继承来实现,而将辅助功能的添加用接口去管理和分类,这样条理分明),在解决复杂问题和做很多修改的时候不必去大量更改代码。

    OOP这种思想帮助我们解决了很多复杂的问题,这里不在一一列举,只说我们这里的重点。


     Java语言接口与继承的本质

    大多数人认为,接口的意义在于顶替多重继承。众所周知Java没有c++那样多重继承的机制,但是却能够实作多个接口。其实这样做是很牵强的,接口和继承是完全不同的东西,接口没有能力代替多重继承,也没有这个义务。接口的作用,一言以蔽之,就是标志类的类别(type of class)。把不同类型的类归于不同的接口,可以更好的管理他们。OO的精髓,我以为,是对对象的抽象,最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如c++、java、c#等),就是因为设计模式所研究的,实际上就是如何合理的去抽象。(cowboy的名言是“抽象就是抽去像的部分”,看似调侃,实乃至理)。
      设计模式中最基础的是工厂模式(Factory),在我最近的一个很简单的应用中,我想尽量的让我的程序能够在多个数据库间移植,当然,这涉及很多问题,单是如何兼容不同DBMS的SQL就让人头痛。我们不妨先把问题简单化,只考虑如何连接不同的数据库。

      假设我有很多个类,分别是Mysql.java、SQLServer.java、Oracle.java、DB2.java,他们分别连接不同的数据库,统一返回一个Connection对象,并且都有一个close方法,用于关闭连接。只需要针对你的DBMS,选择不同的类,就可以用了,但是我的用户他会使用什么数据库?我不知道,我希望的是尽量少的修改代码,就能满足他的需要。我可以抽象如下接口:

      package org.bromon.test;
      public interface DB
      {
      java.sql.Connection openDB(String url,String user,String password);
      void close();
      }

      这个接口只定义两个方法,没有任何有实际意义的代码,具体的代码由实作这个接口的类来给出,比如Mysql.java:

      Package org.bromon.test;
      import java.sql.*;
      public class Mysql implements DB
      {
      private String url=”jdbc:mysql:localhost:3306/test”;
      private String user=”root”;
      private String password=””;
      private Connection conn;
      public Connection openDB(url,user,password)
      {
        //连接数据库的代码
      }

      public void close()
      {
        //关闭数据库
      }
      }

      类似的当然还有Oracle.java等等,接口DB给这些类归了个类,在应用程序中我们这样定义对象:

      org.bromon.test.DB myDB;
    使用myDB来操作数据库,就可以不用管实际上我所使用的是哪个类,这就是所谓的“开-闭”原则。但是问题在于接口是不能实例化的,myDB=new DB(),这样的代码是绝对错误的,我们只能myDB=new Mysql()或者myDB=new Oracle()。麻烦了,我还是需要指定具体实例化的是哪个类,用了接口跟没用一样。所以我们需要一个工厂:
      package org.bromon.test;
      public class DBFactory
      {
      public static DB Connection getConn()
      {
        Return(new Mysql());
      }
      }

      所以实例化的代码变成:myDB=DBFactory.getConn();

      这就是23种模式中最基础的普通工厂(Factory),工厂类负责具体实例化哪个类,而其他的程序逻辑都是针对DB这个接口进行操作,这就是“针对接口编程”。责任都被推卸给工厂类了,当然你也可以继续定义工厂接口,继续把责任上抛,这就演变成抽象工厂(Abstract Factory)。

      整个过程中接口不负责任何具体操作,其他的程序要连接数据库的话,只需要构造一个DB对象就OK,而不管工厂类如何变化。这就是接口的意义----抽象。

      继承的概念不用多说,很好理解。为什么要继承呢?因为你想重用代码?这绝对不是理由,继承的意义也在于抽象,而不是代码重用。如果对象A有一个run()方法,对象B也想有这个方法,所以有人就Class B extends A。这是不经大脑的做法。如果在B中实例化一个A,调用A的Run()方法,是不是可以达到同样的目的?如下:

      Class B
      {
      A a=new A();
      a.run();
      }

      这就是利用类的聚合来重用代码,是委派模式的雏形,是GoF一贯倡导的做法。

      那么继承的意义何在?其实这是历史原因造成的,最开始的OO语言只有继承,没有接口,所以只能以继承来实现抽象,请一定注意,继承的本意在于抽象,而非代码重用(虽然继承也有这个作用),这是很多Java烂书最严重的错误之一,它们所造成的阴影,我至今还没有完全摆脱,坏书害人啊,尤其是入门类的,流毒太大。什么时候应该使用继承?只在抽象类中使用,其他情况下尽量不使用。抽象类也是不能实例化的,它仅仅提供一个模版而已,这就很能说明问题。

      软件开发的万恶之源,一是重复代码而不是重用代码,二是烂用继承,尤以c++程序员为甚。Java中取缔多重继承,目的就是制止烂用继承,实是非常明智的做法,不过很多人都不理解。Java能够更好的体现设计,这是让我入迷的原因之一。

    深入理解接口和抽象类

    abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。其实,两者之间还是有很大的区别的,对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析,试图给开发者提供一个在二者之间进行选择的依据。

    理解抽象类

    abstract class和interface在Java语言中都是用来进行抽象类(本文中的抽象类并非从abstract class翻译而来,它表示的是一个抽象体,而abstract class为Java语言中用于定义抽象类的一种方法,请读者注意区分)定义的,那么什么是抽象类,使用抽象类能为我们带来什么好处呢?

    在面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是反过来却不是这样。并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。比如:如果我们进行一个图形编辑软件的开发,就会发现问题领域存在着圆、三角形这样一些具体概念,它们是不同的,但是它们又都属于形状这样一个概念,形状这个概念在问题领域是不存在的,它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能够实例化的。

    在面向对象领域,抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述,但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类,而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体,因此它可以是不允许修改的;同时,通过从这个抽象体派生,也可扩展此模块的行为功能。熟悉OCP的读者一定知道,为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle),抽象类是其中的关键所在。

    从语法定义层面看abstract class和interface

    在语法层面,Java语言对于abstract class和interface给出了不同的定义方式,下面以定义一个名为Demo的抽象类为例来说明这种不同。

    使用abstract class的方式定义Demo抽象类的方式如下:

    abstract class Demo {
    abstract void method1();
    abstract void method2();

    使用interface的方式定义Demo抽象类的方式如下:

    interface Demo {
    void method1();
    void method2();

    }

    在abstract class方式中,Demo可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface方式的实现中,Demo只能够有静态的不能被修改的数据成员(也就是必须是static final的,不过在interface中一般不定义数据成员),所有的成员方法都是abstract的。从某种意义上说,interface是一种特殊形式的abstract class。

    对于abstract class和interface在语法定义层面更多的细节问题,不是本文的重点,不再赘述,读者可以参阅参考文献〔1〕获得更多的相关内容。

    从编程层面看abstract class和interface

    从编程的角度来看,abstract class和interface都可以用来实现"design by contract"的思想。但是在具体的使用上面还是有一些区别的。

    首先,abstract class在Java语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface。也许,这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。

    其次,在abstract class的定义中,我们可以赋予方法的默认行为。但是在interface的定义中,方法却不能拥有默认行为,为了绕过这个限制,必须使用委托,但是这会增加一些复杂性,有时会造成很大的麻烦。

    在抽象类中不能定义默认行为还存在另一个比较严重的问题,那就是可能会造成维护上的麻烦。因为如果后来想修改类的界面(一般通过abstract class或者interface来表示)以适应新的情况(比如,添加新的方法或者给已用的方法中添加新的参数)时,就会非常的麻烦,可能要花费很多的时间(对于派生类很多的情况,尤为如此)。但是如果界面是通过abstract class来实现的,那么可能就只需要修改定义在abstract class中的默认行为就可以了。

    同样,如果不能在抽象类中定义默认行为,就会导致同样的方法实现出现在该抽象类的每一个派生类中,违反了"one rule,one place"原则,造成代码重复,同样不利于以后的维护。因此,在abstract class和interface间进行选择时要非常的小心。

    从设计理念层面看abstract class和interface

    上面主要从语法定义和编程的角度论述了abstract class和interface的区别,这些层面的区别是比较低层次的、非本质的。本小节将从另一个层面:abstract class和interface所反映出的设计理念,来分析一下二者的区别。作者认为,从这个层面进行分析才能理解二者概念的本质所在。

    前面已经提到过,abstarct class在Java语言中体现了一种继承关系,要想使得继承关系合理,父类和派生类之间必须存在"is a"关系,即父类和派生类在概念本质上应该是相同的(参考文献〔3〕中有关于"is a"关系的大篇幅深入的论述,有兴趣的读者可以参考)。对于interface 来说则不然,并不要求interface的实现者和interface定义在概念本质上是一致的,仅仅是实现了interface定义的契约而已。为了使论述便于理解,下面将通过一个简单的实例进行说明。

    考虑这样一个例子,假设在我们的问题领域中有一个关于Door的抽象概念,该Door具有执行两个动作open和close,此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型,定义方式分别如下所示:

    使用abstract class方式定义Door:

    abstract class Door {
    abstract void open();
    abstract void close();
    }


    使用interface方式定义Door:

    interface Door {
    void open();
    void close();
    }


    其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。

    如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢(在本例中,主要是为了展示abstract class和interface反映在设计理念上的区别,其他方面无关的问题都做了简化或者忽略)?下面将罗列出可能的解决方案,并从设计理念层面对这些不同的方案进行分析。

    解决方案一:

    简单的在Door的定义中增加一个alarm方法,如下:

    abstract class Door {
    abstract void open();
    abstract void close();
    abstract void alarm();
    }


    或者

    interface Door {
    void open();
    void close();
    void alarm();
    }


    那么具有报警功能的AlarmDoor的定义方式如下:

    class AlarmDoor extends Door {
    void open() { … }
    void close() { … }
    void alarm() { … }
    }


    或者

    class AlarmDoor implements Door {
    void open() { … }
    void close() { … }
    void alarm() { … }

    这种方法违反了面向对象设计中的一个核心原则ISP(Interface Segregation Priciple),在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变(比如:修改alarm方法的参数)而改变,反之依然。

    解决方案二:

    既然open、close和alarm属于两个不同的概念,根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有:这两个概念都使用abstract class方式定义;两个概念都使用interface方式定义;一个概念使用abstract class方式定义,另一个概念使用interface方式定义。

    显然,由于Java语言不支持多重继承,所以两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的,但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。

    如果两个概念都使用interface方式来定义,那么就反映出两个问题:1、我们可能没有理解清楚问题领域,AlarmDoor在概念本质上到底是Door还是报警器?2、如果我们对于问题领域的理解没有问题,比如:我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的,那么我们在实现时就没有能够正确的揭示我们的设计意图,因为在这两个概念的定义上(均使用interface方式定义)反映不出上述含义。

    如果我们对于问题领域的理解是:AlarmDoor在概念本质上是Door,同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢?前面已经说过,abstract class在Java语言中表示一种继承关系,而继承关系在本质上是"is a"关系。所以对于Door这个概念,我们应该使用abstarct class方式来定义。另外,AlarmDoor又具有报警功能,说明它又能够完成报警概念中定义的行为,所以报警概念可以通过interface方式定义。如下所示:

    abstract class Door {
    abstract void open();
    abstract void close();
    }
    interface Alarm {
    void alarm();
    }
    class AlarmDoor extends Door implements Alarm {
    void open() { … }
    void close() { … }
    void alarm() { … }
    }


    这种实现方式基本上能够明确的反映出我们对于问题领域的理解,正确的揭示我们的设计意图。其实abstract class表示的是"is a"关系,interface表示的是"like a"关系,大家在选择时可以作为一个依据,当然这是建立在对问题领域的理解上的,比如:如果我们认为AlarmDoor在概念本质上是报警器,同时又具有Door的功能,那么上述的定义方式就要反过来了。

    结论

    abstract class和interface是Java语言中的两种定义抽象类的方式,它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理,因为它们表现了概念间的不同的关系(虽然都能够实现需求的功能)。这其实也是语言的一种的惯用法,希望读者朋友能够细细体会

    展开全文
  • 接口与抽象类区别

    2019-05-07 21:58:50
    接口与抽象类区别接口与抽象类区别 接口与抽象类区别 1、接口抽象类的概念不一样。接口是对动作的抽象,抽象类是对根源的抽象。 2、接口中只能包含抽象方法;而抽象类中可以包含普通方法。 3、接口中不能...

    接口与抽象类的区别

    接口与抽象类的区别

    1、接口和抽象类的概念不一样。接口是对动作的抽象,抽象类是对根源的抽象。
    2、接口中只能包含抽象方法;而抽象类中可以包含普通方法。
    3、接口中不能定义静态方法;而抽象类可以定义静态方法。
    4、接口中只能定义静态常量,不能定义普通属性;而抽象类既 可以定义普通属性,也可以定义静态常量属性。
    5、接口不包含构造器;而抽象类中可以包含构造器。抽象类中的构造器并不是用于创建对象,而是让子类调用这些构造器来完成属于抽象类的初始化工作。
    6、接口中不包含初始化块;而抽象类可以包含初始化块。
    7、一个类最多有一个直接父类,包括抽象类;但是一个类可以直接实现多个接口,通过实现多个接口来弥补java单继承的不足。
    8、接口里所有方法都是抽象的,所有属性都是public static final;抽象类是接口的部分实现,既能定义抽象方法,也能定义普通方法和属性比接口更加灵活。
    9.、接口只可以继承一个或多个其它接口;抽象类可以继承一个类和实现多个接口。
    10、接口方法默认修饰符是public,可以使用其它修饰符。而抽象方法可以有public、protected和default这些修饰符。
    11、接口完全是抽象的,它根本不存在方法的实现;而抽象类可以有默认的方法实现;
    12、接口强调特定功能的实现;而抽象类强调所属关系。

    展开全文
  • 主要介绍了详解java中接口与抽象类区别的相关资料,希望通过本文能帮助到大家,让大家轻松理解掌握接口与抽象类区别,需要的朋友可以参考下
  • 本篇文章是对php中接口与抽象类区别进行了详细的分析介绍,需要的朋友参考下
  • C#类、接口、虚方法和抽象方法-接口与抽象类区别实例 C#类、接口、虚方法和抽象方法-接口与抽象类区别实例
  • Java接口与抽象类课件

    2013-01-25 09:44:05
    Java接口与抽象类的课件,适合初学者,主要对接口与抽象类进行简要介绍,PPT版本。
  • 本文简要论述了接口与抽象类之间的区别,适合初学编程的同学
  • 主要介绍了JDK8接口的默认静态方法-接口与抽象类区别详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,,需要的朋友可以参考下
  • 接口与抽象类

    2011-11-12 09:20:48
    接口与抽象类区别等等................................
  • 抽象类并不能继承接口,但可以实现接口抽象类可以继承具体类,前提是具体类必须具有构造函数且具有访问权限。这里需要说明,当一个具体类没有写构造函数时,系统会自动生成默认的无参构造器,意味着没有写构造...

    接口可以继承接口。

    抽象类并不能继承接口,但可以实现接口。

    抽象类可以继承具体类,前提是具体类必须具有构造函数且具有访问权限。这里需要说明,当一个具体类没有写构造函数时,系统会自动生成默认的无参构造器,意味着没有写构造函数的具体类也可以被抽象类继承。但是,一旦将具体类的无参构造器设置访问修饰符为 private 时,抽象类则不可以继承。

    抽象类可以有静态的 main 方法。抽象类在面向对象中是被用来描述现实中的抽象事物, 抽象类没有对象概念所以不能被实例化. 但可以定义属性和方法, 其中属性方法都可以是静态的. 静态的意义其实就是在栈内存中只有一个, 所以该成员也会先于对象出现在内存中, 所以静态并没有违反抽象的原则. 抽象类中可以定义静态成员.

    interface IA{}
    interface IB{}
    interface I extends IA,IB{}//接口可以继承多个接口
    abstract class E implements IA{} //抽象类可以实现接口,但不可以继承接口
    abstract class F extends C{}//抽象类可以继承具体类
    class D{private D(){}}
    //abstract class G extends D{}//Implicit super constructor D() is not visible for default constructor. Must define an explicit constructor抽象类不可以继承无权限构造器的具体类
    abstract class H{public static void main() {}}//抽象类可以有静态的main方法
    
    展开全文
  • 接口与抽象类区别(Java 7版本)

    千次阅读 2019-05-15 19:00:16
    本篇从 8 个方面介绍一下,接口与抽象类区别。 抽象 接口与抽象类具备抽象多类对象相同属性特征的特点,均可作为一种规范。 属性(成员变量) 抽象类中的成员变量普通的 Java 类声明一样; 接口中的成员变量...
  • 那么就可以使用抽象类定义基类,即使用abstract关键字声明Class并且abstract声明抽象类中方法(抽象类中可以有抽象方法也可以有实方法-》这里的实方法指的是非虚方法,abstract可以看做隐式的虚方法 ) ...
  • 本文主要介绍java 的接口抽象类,对接口抽象类进行介绍对比,深入理解,有需要的小伙伴可以参考下
  • 主要介绍了Java中接口抽象类区别与相同之处,本文讲解了抽象类的概念、接口的概念、接口抽象类区别与联系等内容,需要的朋友可以参考下
  • 主要介绍了java 中接口抽象类区别与对比的相关资料,这里详细说明他们之家的区别,需要的朋友可以参考下
  • java基础之接口与抽象类区别

    千次阅读 2016-11-22 17:54:23
    java基础之接口与抽象类区别  抽象类,包含一个抽象方法的类就是抽象类。什么是抽象方法呢?声明而未被实现的方法,抽象方法必须用abstract关键字,抽象类不能直接实例化,都是通过它的子类,即继承抽象类的类来...
  • 以下提到的其实算不上是区别,只是把接口抽象类的一些特殊之处例举出来,供读者分辨。 1、接口方法权限默认为public,abstract。(当然在代码中显式也没错误) 2、接口只能有抽象方法,而抽象类可以有非抽像方法...
  • 接口接口中定义的方法只能是public ,如果不写,它也是public .不能用private和protected去修饰接口的方法。 接口的方法无论是否用abstract修饰,都是抽象方法。 ...接口抽象类区别和联系
  • 接口与抽象类区别java基础一些东西,这些东西在面试中是常考的。大家可以看看
  • 接口与抽象类区别以及使用场景

    万次阅读 多人点赞 2017-01-06 11:42:11
    顺便做个记录 接口抽象类应该是Java语法中最常见...3,抽象类可以继承接口 接口不能继承抽象类 4,抽象类的成员可以具有具体实现 接口不行 5,抽象的子类可以选择性实现其基类的抽象方法 接口的子类必须实现 6,接
  • 接口抽象类区别

    万次阅读 多人点赞 2018-08-12 21:38:36
    接口抽象类有什么区别 你选择使用接口抽象类的依据是什么? 接口抽象类的概念不一样。接口是对动作的抽象,抽象类是对根源的抽象。 抽象类表示的是,这个对象是什么。接口表示的是,这个对象能做什么。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 789,754
精华内容 315,901
关键字:

接口与抽象类的区别