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

    2021-01-20 22:47:28
    接口抽象类区别 抽象类中可以包含普通方法和普通字段, 可以被子类直接使用(不必重写), 接口中不能包含普通方法, 子类必须重写所有的抽象方法. No 区别 抽象类(abstract) 接口(interface) 1 结构组成 ...

    接口抽象类区别

    抽象类中可以包含普通方法和普通字段, 可以被子类直接使用(不必重写),
    接口中不能包含普通方法, 子类必须重写所有的抽象方法.

    No 区别 抽象类(abstract) 接口(interface)
    1 结构组成 普通类+抽象方法 抽象方法+全局变量
    2 权限 各种权限 public
    3 子类使用 extends继承抽象类 implements实现接口
    4 关系 一个抽象类可以实现多个接口 接口不能继承抽象类但是可以用extends继承多个父接口
    5 子类限制 一个子类只能继承一个抽象类 一个子类可以实现多个接口

    代码实例

    例如:Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此
    处的 Animal 只能作为一个抽象类, 而不应该成为一个接口.

    class Animal { 
     protected String name; 
     
     public Animal(String name) { 
     this.name = name; 
     } 
    }
    
    展开全文
  • 接口抽象类应该是Java语法中最常见的两个概念 关于两者,网上也是一搜一吨的对比,总体如下: 1,抽象类的成员可以具有访问级别 接口的成员全部public级别 2,抽象类可以包含字段 接口不可以 3,抽象类可以继承...

    文摘:


    接口+实现”最常见的优势就是实现类和接口分离,在更换实现类的时候,不用更换接口功能:既一个方法的形参数是一个接口对象

    那么凡是实现了这个接口的类都可以作为实参传入,并且,接口对象调用的只能是子类所实现的接口的方法,这样就降低了模块之间的

    耦合性


      很多JAVA初级程序员对于接口存在的意义很疑惑。不知道接口到底是有什么作用,为什么要定义接口。

          好像定义接口是提前做了个多余的工作。下面我给大家总结了4点关于JAVA中接口存在的意义:

      1、重要性:在Java语言中, abstract class 和interface 是支持抽象类定义的两种机制。正是由于这两种机制的存在,才赋予了Java强大的 面向对象能力。

      2、简单、规范性:如果一个项目比较庞大,那么就需要一个能理清所有业务的架构师来定义一些主要的接口,这些接口不仅告诉开发人员你需要实现那些业务,而且也将命名规范限制住了(防止一些开发人员随便命名导致别的程序员无法看明白)。

      3、维护、拓展性:比如你要做一个画板程序,其中里面有一个面板类,主要负责绘画功能,然后你就这样定义了这个类。

             可是在不久将来,你突然发现这个类满足不了你了,然后你又要重新设计这个类,更糟糕是你可能要放弃这个类,那么其他地方可能有引用他,这样修改起来很麻烦。

             如果你一开始定义一个接口,把绘制功能放在接口里,然后定义类时实现这个接口,然后你只要用这个接口去引用实现它的类就行了,以后要换的话只不过是引用另一个类而已,这样就达到维护、拓展的方便性。

      4、安全、严密性:接口是实现软件松耦合的重要手段,它描叙了系统对外的所有服务,而不涉及任何具体的实现细节。这样就比较安全、严密一些(一般软件服务商考虑的比较多)。


    接口是个规范”,这句没错。
    不如直接就在这个类中写实现方法岂不是更便捷”,你怎么保证这个接口就一个类去实现呢?如果多个类去实现同一个接口,程序怎么知道他们是有关联的呢?

    既然不是一个类去实现,那就是有很多地方有用到,大家需要统一标准。甚至有的编程语言(Object-C)已经不把接口叫 interface,直接叫 protocol。

    统一标准的目的,是大家都知道这个是做什么的,但是具体不用知道具体怎么做
    比如说:
    我知道 Comparable 这个接口是用来比较两个对象的,那么如何去比较呢?
    数字有数字的比较方法,字符串有字符串的比较方法,学生(自己定义的类)也有自己的比较方法。


    你写接口你写实现,就不用写接口了。
    我写接口你实现,接口不就用上了。我不给你规定好了,你怎么知道该实现哪些内容呢。
    更进一步,我写接口你实现,你今天不在,我明天出差,程序后天交工,那我今天必须把调用这个接口的代码写好。所以就需要接口中有函数,有明确的函数签名。我写个接口,再把调用函数写好,明天你把接口实现了,传个实例进来,交工。




    接口和抽象类应该是Java语法中最常见的两个概念

    关于两者,网上也是一搜一吨的对比,总体如下:

    1,抽象类的成员可以具有访问级别接口的成员全部public级别
    2,抽象类可以包含字段接口不可以
    3,抽象类可以继承接口接口不能继承抽象类
    4,抽象类的成员可以具有具体实现接口不行
    5,抽象的子类可以选择性实现其基类的抽象方法接口的子类必须实现

    6,接口是抽象类的一种特例!

    概念虽然简单

    不过到具体使用场景中,什么情况下用抽象类,什么情况下用接口呢,很多人却搞不明白


    下面我举个例子

    有一个Door,里面有方法open()和方法close()

    我们要把他抽象出来,形成一个类,可以有下面两种方法

    1,抽象成抽象类,如下

    [java] view plain copy
     print?
    1. abstract class Door{  
    2.     void open() {}  
    3.     void close(){}  
    4. }  


    2,抽象成接口,如下

    [java] view plain copy
     print?
    1. interface Door{  
    2.     void open();  
    3.     void close();  
    4. }  

    看起来两者好像没啥区别,现在我们要加一个功能,门铃功能

    没啥问题,那就加上

    1,抽象类

    [java] view plain copy
     print?
    1. abstract class Door{  
    2.     void open() {}  
    3.     void close(){}  
    4.     void bilibili(){}  
    5. }  

    2,接口

    [java] view plain copy
     print?
    1. interface Door{  
    2.     void open();  
    3.     void close();  
    4.     void bilibili();  
    5. }  


    那么问题来了,所有门都有开关门功能,是不是所有的门都有门铃呢?

    那不是所有的实现Door的类都得具有门铃方法?


    所以,我们应该把门铃理解成一种附件,一种Attach,可以加到门上面的一种点缀

    对于这种附件形式的类,我们就可以用接口来表示


    所以,啥叫接口,就是在门上凿出一个门铃大小的洞,用来放门铃的,就跟电脑上的usb接口一样,一个洞嘛!


    我们就可以这样来定义铃声这样一个接口

    [java] view plain copy
     print?
    1. interface Ring{  
    2.     void bilibili();  
    3. }  
    这样定义Door这个类

    [java] view plain copy
     print?
    1. abstract class Door{  
    2.     void open() {}  
    3.     void close(){}  
    4. }  

    这样,如果有一个铃铛的门,可以这样来写:

    [java] view plain copy
     print?
    1. class DoorWithRing extends Door implements Ring{  
    2.   
    3.     public void bilibili() {  
    4.         // TODO Auto-generated method stub  
    5.           
    6.     }  
    7. }  

    如果是一个没有铃铛的门

    [java] view plain copy
     print?
    1. class DoorWithRing extends Door{  
    2.   
    3. }  


    现在我们要在门上装一个猫眼,咋装呢,很简单

    买个猫眼:

    [java] view plain copy
     print?
    1. interface CatEye{  
    2.     void see();  
    3. }  


    把猫眼装进门上的洞里:

    [java] view plain copy
     print?
    1. class DoorWithRingAndCatEye extends Door implements Ring,CatEye{  
    2.         public void see() {  
    3.             // TODO Auto-generated method stub  
    4.               
    5.         }  
    6.         public void bilibili() {  
    7.             // TODO Auto-generated method stub  
    8.               
    9.         }  
    10.     }  

    一个门上可以打无数的洞,也就是可以实现多个接口!


    有人会问,门铃,猫眼,这些东西不也是类吗,为啥不做成类,做成接口呢?


    对的,当然可以做成一个正常的类,有他的属性什么的,这样猫眼,门铃和门的关系就变了,变成聚合关系了,不是组合,因为门没了门铃和猫眼还是门,这些基本的概念有机会再延伸吧


    所以,对于那种功能单一(响铃,看人),又需要拿来作为一个附件附加到基本类上的类,我们就把它定义成接口



    ok!

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

    1.概述

    一个软件设计的好坏,我想很大程度上取决于它的整体架构,而这个整体架构其实就是你对整个宏观商业业务的抽象框架,当代表业务逻辑的高层抽象层结构 合理时,你底层的具体实现需要考虑的就仅仅是一些算法和一些具体的业务实现了。当你需要再开发另一个相近的项目时,你以前的抽象层说不定还可以再次利用 。面对对象的设计,复用的重点其实应该是抽象层的复用,而不是具体某一个代码块的复用

    说到了抽象,我就不能不提到曾让我头痛的Java接口和Java抽象类了,这也是本文我想说的重点。

    既然面向对象设计的重点在于抽象,那Java接口和Java抽象类就有它存在的必然性了。

    Java接口(interface)和Java抽象类(abstract class)代表的就是抽象类型,就是我们需要提出的抽象层的具体表现。OOP面向对象的编程,如果要提高程序的复用率,增加程序 的可维护性,可扩展性,就必须是面向接口的编程,面向抽象的编程,正确地使用接口、抽象类这些有用的抽象类型作为你结构层次上的顶层。

    Java接口和Java抽象类有太多相似的地方,又有太多特别的地方,究竟在什么地方,才是它们的最佳位置呢?把它们比较一下,你就可以发现了。

    1. Java接口和Java抽象类最大的一个区别,就在于Java抽象类可以提供某些方法的部分实现,而Java接口不可以(就是interface中只能定义方法,而不能有方法的实现,而在abstract class中则可以既有方法的具体实现,又有没有具体实现的抽象方法),这大概就是Java抽象类唯一的优点吧,但这个优点非常有用。如果向一个抽象类里加入一个新的具体方法时,那么它所有的子类都一下子都得到了这个新方法,而Java接口做不到这一点,如果向一个Java接口里加入一个 新方法,所有实现这个接口的类就无法成功通过编译了,因为你必须让每一个类都再实现这个方法才行,这显然是Java接口的缺点这个在我的另外一篇博客mapreduce 新旧API 区别中有提到类似的问题,在新的mapreduce api中更倾向于使用抽象类,而不是接口,因为这更容易扩展。原因就是上面划线部分所说的。
    2. 一个抽象类的实现只能由这个抽象类的子类给出,也就是说,这个实现处在抽象类所定义出的继承的等级结构中,而由于Java语言的单继承性,所以抽象类作为类型定义工具的效能大打折扣。在这一点上,Java接口的优势就出来了,任何一个实现了一个Java接口所规定的方法的类都可以具有这个接口的类型,而一个类可以实现任意多个Java接口,从而这个类就有了多种类型。(使用抽象类,那么继承这个抽象类的子类类型就比较单一,因为子类只能单继承抽象类;而子类能够同时实现多个接口,因为类型就比较多。接口和抽象类都可以定义对象,但是只能用他们的具体实现类来进行实例化。)
    3. 从第2点不难看出,Java接口是定义混合类型的理想工具,混合类表明一个类不仅仅具有某个主类型的行为,而且具有其他的次要行为。
    4. 结合1、2点中抽象类和Java接口的各自优势,具精典的设计模式就出来了:声明类型的工作仍然由Java接口承担,但是同时给出一个Java 抽象类,且实现了这个接口,而其他同属于这个抽象类型的具体类可以选择实现这个Java接口,也可以选择继承这个抽象类,也就是说在层次结构中,Java 接口在最上面,然后紧跟着抽象类,这下两个的最大优点都能发挥到极至了。这个模式就是“缺省适配模式”。在Java语言API中用了这种模式,而且全都遵循一定的命名规范:Abstract +接口名。(A extends AbstractB implements interfaceC,那么A即可以选择实现(@Override)接口interfaceC中的方法,也可以选择不实现;A即可以选择实现(@Override)抽象类AbstractB中的方法,也可以选择不实现)

    Java接口和Java抽象类的存在就是为了用于具体类的实现和继承的,如果你准备写一个具体类去继承另一个具体类的话,那你的设计就有很大问题了。Java抽象类就是为了继承而存在的,它的抽象方法就是为了强制子类必须去实现的。

    使用Java接口和抽象Java类进行变量的类型声明、参数是类型声明、方法的返还类型说明,以及数据类型的转换等。而不要用具体Java类进行变量的类型声明、参数是类型声明、方法的返还类型说明,以及数据类型的转换等。

    2.实例

    下面给出一个具体的接口Action,代码如下所示:

    [java] view plain copy
    1. package org.springframework.webflow.execution;  
    2. public interface Action {  
    3.     public Event execute(RequestContext context) throws Exception;  
    4. }  
    在这个接口中,定义了一个没有具体实现的方法,方法名叫做execute(),返回类型是Event。如前面第一条所述,接口中的方法都是没有实现的。这些方法的具体实现是在实现(implements)这个接口的类中给出的。

    再来看一个实现Action接口的抽象类AbstractAction,代码如下。

    [java] view plain copy
    1. package org.springframework.webflow.action;  
    2.   
    3. import org.apache.commons.logging.Log;  
    4. import org.apache.commons.logging.LogFactory;  
    5. import org.springframework.beans.factory.BeanInitializationException;  
    6. import org.springframework.beans.factory.InitializingBean;  
    7. import org.springframework.util.ClassUtils;  
    8. import org.springframework.webflow.core.collection.AttributeMap;  
    9. import org.springframework.webflow.execution.Action;  
    10. import org.springframework.webflow.execution.Event;  
    11. import org.springframework.webflow.execution.RequestContext;  
    12.   
    13. public abstract class AbstractAction implements Action, InitializingBean {  
    14.   
    15.     protected final Log logger = LogFactory.getLog(getClass());  
    16.   
    17.     public EventFactorySupport getEventFactorySupport() {  
    18.         return new EventFactorySupport();  
    19.     }  
    20.   
    21.     public void afterPropertiesSet() throws Exception {  
    22.         try {  
    23.             initAction();  
    24.         } catch (Exception ex) {  
    25.             throw new BeanInitializationException("Initialization of this Action failed: " + ex.getMessage(), ex);  
    26.         }  
    27.     }  
    28.   
    29.     protected void initAction() throws Exception {  
    30.     }  
    31.   
    32.     protected Event success() {  
    33.         return getEventFactorySupport().success(this);  
    34.     }  
    35.   
    36.     protected Event success(Object result) {  
    37.         return getEventFactorySupport().success(this, result);  
    38.     }  
    39.   
    40.     protected Event error() {  
    41.         return getEventFactorySupport().error(this);  
    42.     }  
    43.   
    44.     protected Event error(Exception e) {  
    45.         return getEventFactorySupport().error(this, e);  
    46.     }  
    47.   
    48.     protected Event yes() {  
    49.         return getEventFactorySupport().yes(this);  
    50.     }  
    51.   
    52.     protected Event no() {  
    53.         return getEventFactorySupport().no(this);  
    54.     }  
    55.   
    56.     protected Event result(boolean booleanResult) {  
    57.         return getEventFactorySupport().event(this, booleanResult);  
    58.     }  
    59.   
    60.     protected Event result(String eventId) {  
    61.         return getEventFactorySupport().event(this, eventId);  
    62.     }  
    63.   
    64.     protected Event result(String eventId, AttributeMap resultAttributes) {  
    65.         return getEventFactorySupport().event(this, eventId, resultAttributes);  
    66.     }  
    67.   
    68.     protected Event result(String eventId, String resultAttributeName, Object resultAttributeValue) {  
    69.         return getEventFactorySupport().event(this, eventId, resultAttributeName, resultAttributeValue);  
    70.     }  
    71.   
    72.     public final Event execute(RequestContext context) throws Exception {  
    73.         Event result = doPreExecute(context);  
    74.         if (result == null) {  
    75.             result = doExecute(context);  
    76.             doPostExecute(context);  
    77.         } else {  
    78.             if (logger.isInfoEnabled()) {  
    79.                 logger.info("Action execution disallowed; pre-execution result is '" + result.getId() + "'");  
    80.             }  
    81.         }  
    82.         return result;  
    83.     }  
    84.   
    85.     protected String getActionNameForLogging() {  
    86.         return ClassUtils.getShortName(getClass());  
    87.     }  
    88.   
    89.     protected Event doPreExecute(RequestContext context) throws Exception {  
    90.         return null;  
    91.     }  
    92.   
    93.     //抽象方法  
    94.     protected abstract Event doExecute(RequestContext context) throws Exception;  
    95.   
    96.     protected void doPostExecute(RequestContext context) throws Exception {  
    97.     }  
    98. }  
    在抽象类AbstractAction中,既有具体实现的方法,又有没有具体实现的抽象方法

    [java] view plain copy
    1. //抽象方法  
    2. protected abstract Event doExecute(RequestContext context) throws Exception;  
    需要注意的是在抽象类中,如果方法没有具体实现(就是方法后面没有{}),那么必须加上abstract来声明这个方法,而接口中不需要使用abstract来声明(抽象类之所以被称为抽象类,就是因为它包含有抽象方法。含有抽象方法的类叫做抽象类)
    展开全文
  • Java抽象类 1、抽象类使用abstract修饰;2、抽象类不能实例化,即不能使用new关键字来实例化对象;3、含有抽象方法(使用abstract关键字修饰的方法)的类是抽象类,必须使用abstract关键字修饰;4、抽象类可以含有...

    目录

     

    Java抽象类

    Java接口

    抽象类和接口使用区别:

    activity 深度继承关系 


    Java抽象类

    1、抽象类使用abstract修饰;2、抽象类不能实例化,即不能使用new关键字来实例化对象;3、含有抽象方法(使用abstract关键字修饰的方法)的类是抽象类,必须使用abstract关键字修饰;4、抽象类可以含有抽象方法,也可以不包含抽象方法,抽象类中可以有具体的方法;5、如果一个子类实现了父类(抽象类)的所有抽象方法,那么该子类可以不必是抽象类,否则就是抽象类;6、抽象类中的抽象方法只有方法体,没有具体实现;

    Java接口

    接口:1、接口使用interface修饰;2、接口不能被实例化;3、一个类只能继承一个类,但是可以实现多个接口;4、接口中方法均为抽象方法;5、接口中不能包含实例域或静态方法(静态方法必须实现,接口中方法是抽象方法,不能实现)

     

    抽象类和接口使用区别:

    抽象类中的成员变量可以是各种类型的    而接口中的成员变量只能是public static final类型的。

     

    A,B,C 三个类貌似差不多啊,有很多公共的属性或者方法,于是我,抽象出一个抽象类D,将这些公共的部分放到抽象类中,然后ABC三个类继承自这个抽象类D。所以,抽象类是“自下而上”的;

    抽象类是很有用的重构工具,它将继承层次结构上移,这种上移操作一般是后发的

    抽象类是对一类事物的抽象。它通过继承操作实现它的终极目标:复用

    所以,抽象类是能拥有普通属性和普通方法的,它除了不能实例化和必须有抽象方法外,和普通类没太大区别。

     


    接口则不一样,它是“自上而下”的设计理念,我们工作的设计过程中,一般都是先设计好接口,先不考虑具体的实现。

    所以,如果说抽象类是对事物的抽象,接口就是对行为的抽象,接口建立了类和类之前的契约和协议,这也是它的终极目标:行为契约。

    接口将接口和具体实现两者解耦的更加彻底,使得面向接口编程更加的容易和纯粹。
     

    activity 深度继承关系 

     

    activity  ---ContextThemeWrapper---ContextWrapper---Context

     

    Context:

    public abstract class Context {}
    

    是一个抽象类,里面有很多的activity的一些操作以及文件操作等等

    例如:

    public abstract void startActivity(Intent var1);
    
    public abstract void startActivity(Intent var1, Bundle var2);
    
    展开全文
  • 抽象类是可以有私有方法或私有变量的,另外,实现接口的一定要实现接口里定义的所有方法,而实现抽象类可以有选择地重写需要用到的方法,一般的应用里,最顶级的是接口,然后是抽象类实现接口,最后才到具体类实现...
  • 最近看到论坛里有个帖子在讨论接口抽象类区别和作用,这其实也是很多面试官喜欢问的问题,这里我就说说我的总结,顺便说说内部类的作用,当是给刚入门,或者想学习java的同学们能更好的理解它们的用法。...
  • java接口抽象类区别

    2019-05-14 14:39:44
    抽象类接口区别: A:成员区别 抽象类: 成员变量:可以变量,也可以常量 构造方法:有 成员方法:可以抽象,也可以非抽象 接口: 成员变量:只可以常量 成员方法:只可以抽象 B:关系区别 类与类 继承,单继承 类...
  • Java接口抽象类区别

    2020-02-02 17:23:28
    抽象类体现的是一种模板模式的设计,作为多个子类的通用模板,...接口类是从多个类中抽象出来的模板,只是将这种抽象进行的更彻底,提炼出一种更加特殊的抽象类接口interface。接口用途:(1)定义变量,也可以用于...
  • JAVA接口抽象类区别

    2019-10-01 15:36:43
    3.接口只能有抽象方法,继承接口的类必须实现所有的抽象方法,但是如果是抽象类的话,就可以不实现。 4.接口的方法都是public abstarct的,隐式声明; 5.接口没有构造方法,不能直接实例化; 抽象类 1...
  • java接口抽象类区别

    2014-02-17 18:00:00
    OOP中接口抽象类区别 Java语言接口与继承的本质 深入理解接口抽象类   OOP中接口抽象类区别 OOP中的INTERFACE和ABSTRACT CLASS是两个不同的概念 我们在使用的时候往往将两个混在一起使用,不做什么区别,...
  • Java接口抽象类区别 Java接口抽象类区别
  • Java接口和Java抽象类最大的一个区别,就在于Java抽象类可以提供某些方法的部分实现,而Java接口不可以,这大概就是Java抽象类唯一的优点吧,但这个优点非常有用。如果向一个抽象类里加入一个新的具体方法时,那么它...
  • 1)Java接口和Java抽象类最大的一个区别,就在于Java抽象类可以提供某些方法的部分实现,而Java接口不可以,这大概就是Java抽象类唯一的有点吧,但是这个优点非常有用。 如果向一个抽象类里家一个新的具体方法,...
  • Java 接口抽象类区别
  • Java接口和Java抽象类最大的一个区别,就在于Java抽象类可以提供某些方法的部分实现,而Java接口不可以,这大概就是Java抽象类唯一的优点吧,但这个优点非常有用。西安达内Java培训讲师表示,如果向一个抽象类里加.....
  • Java接口抽象类区别

    2017-04-25 11:24:34
    接口(interface)可以说是抽象类的一个特例,接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型,接口中的成员变量类型默认为public static final(既然一个变量被final修饰,那么这个变
  • 抽象类接口区别  出处:http://liudang.blogbus.com/logs/2006/03/2047296.html abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,306
精华内容 2,922
关键字:

java接口抽象类区别

java 订阅