抽象类与接口的区别
抽象方法和接口的区别

抽象方法和接口的区别
抽象方法和接口是面向对象编程中的两个重要概念,它们之间存在以下区别:
1. 定义方式:抽象方法是在抽象类中定义的方法,使用关键字abstract修饰,没有方法体;接口是由方法签名组成的集合,使用关键字interface进行定义。
2. 继承关系:抽象方法通过继承的方式实现子类对该方法的重写,一个类只能继承一个抽象类;接口通过实现的方式实现对接口中方法的定义,一个类可以实现多个接口。
3. 状态:抽象方法可以有非抽象方法和属性,并可以包含构造函数,一个抽象类可以有自己的状态;接口只能包含抽象方法和常量,没有自己的状态。
4. 实例化:抽象方法不能直接被实例化,需要通过子类继承和重写来实现;接口不能被实例化,但可以通过实现类实例化,使用接口引用来调用实现类的方法。
5. 使用场景:抽象方法适用于需要有默认实现和状态的情况,可以用作基类从而提供一些共享的实现;接口适用于需要强制与不同类之间进行某种逻辑上的约束的情况。
总结来说,抽象方法提供了一种非强制性的基类实现,而接口则是一种强制性的实现规范。
抽象方法更强调类的继承和共享实现,接口更强调类的多态和实现规范。
金航数码面试

sendRedirect:在容器之间的跳转,跳转后地址栏地址为跳转后的地址,效率较低。
通常采用jsp:forward方式跳转。
25、类变量的初始化
答:在Java中类变量在局部中一定要初始化,因为局部变量会覆盖全局变量,否则会报错:变量未初始化。全局变量则可以不初始化,而到具体的内部方法或其他的类成员中初始化。
9) 数据校验的对比:Struts 1支持在ActionForm重写validate方法中手动校验,或者通过整合Commons alidator框架来完成数据校验。Struts 2支持通过重写validate方法进行校验,也支持整合XWork校验框架进行校验。
10) Action执行控制的对比:Struts 1支持每一个模块对应一个请求处理(即生命周期的概念),但是模块中的所有Action必须共享相同的生命周期。Struts 2支持通过拦截器堆栈(Interceptor Stacks)为每一个Action创建不同的生命周期。开发者可以根据需要创建相应堆栈,从而和不同的Action一起使用。
3) Servlet依赖方面的对比:Struts 1 Action依赖于Servlet API,因为Struts 1 Action的execute方法中有HttpServletRequest和HttpServletResponse方法。Struts 2 Action不再依赖于Servlet API,从而允许Action脱离Web容器运行,从而降低了测试Action的难度。 当然,如果Action需要直接访问HttpServletRequest和HttpServletResponse参数,Struts 2 Action仍然可以访问它们。但是,大部分时候,Action都无需直接访问HttpServetRequest和HttpServletResponse,从而给开发者更多灵活的选择。
接口和抽象类的区别和作用(功能、用途、好处)

接⼝和抽象类的区别和作⽤(功能、⽤途、好处)接⼝:抽象类和接⼝亲兄弟,但是有嫡出庶出的区别总结了4点接⼝存在的意义:1、重要性:在Java语⾔中, abstract class 和interface 是⽀持抽象类定义的两种机制。
正是由于这两种机制的存在,才赋予了Java强⼤的⾯向对象能⼒。
2、简单、规范性:如果⼀个项⽬⽐较庞⼤,那么就需要⼀个能理清所有业务的架构师来定义⼀些主要的接⼝,这些接⼝不仅告诉开发⼈员你需要实现那些业务,⽽且也将命名规范限制住了(防⽌⼀些开发⼈员随便命名导致别的程序员⽆法看明⽩ 3、维护、拓展性:⽐如你要做⼀个画板程序,其中⾥⾯有⼀个⾯板类,主要负责绘画功能,然后你就这样定义了这个类。
可是在不久将来,你突然发现这个类满⾜不了你了,然后你⼜要重新设计这个类,更糟糕是你可能要放弃这个类,那么其他地⽅可能有引⽤他,这样修改起来很⿇烦。
如果你⼀开始定义⼀个接⼝,把绘制功能放在接⼝⾥,然后定义类时实现这个接⼝,然后你只要⽤这个接⼝去引⽤实现它的类就⾏了,以后要换的话只不过是引⽤另⼀个类⽽已,这样就达到维护、拓展的⽅便性。
4、安全、严密性:接⼝是实现软件松耦合的重要⼿段,它描叙了系统对外的所有服务,⽽不涉及任何具体的实现细节。
这样就⽐较安全、严密⼀些(⼀般软件服务商考虑的⽐较多)。
那么什么是接⼝呢?接⼝是⼀种能⼒1:接⼝的命名规则与类型不同。
如果修饰符是public。
则该接⼝在整个项⽬中可见,如果省略修饰符则该接⼝只能在该包可见2:接⼝中可以定义常量,不能定义变量,接⼝中的属性都会⾃动⽤public static final修饰,即接⼝中的属性都是全局静态常量,接⼝中的常量必须在定义时指定初始值3:接⼝中所有的⽅法抽象⽅法。
接⼝中的⽅法都会⾃动⽤public abstract修饰。
即接⼝中只有全局抽象⽅法,4:和抽象类⼀样,接⼝不能被实例化,接⼝中不能有狗构造⽅法5:接⼝之间可以通过extends 实现继承关系,⼀个接⼝可以继承多个接⼝。
接口和抽象类的区别和联系

接⼝和抽象类的区别和联系1、抽象类抽象类不能创建实例,它只能作为⽗类被继承。
抽象类是从多个具体类中抽象出来的⽗类,它具有更⾼层次的抽象。
从多个具有相同特征的类中抽象出⼀个抽象类,以这个抽象类作为其⼦类的模板,从⽽避免了⼦类的随意性。
(1) 抽象⽅法只作声明,⽽不包含实现,可以看成是没有实现体的虚⽅法(2) 抽象类不能被实例化(3) 抽象类可以但不是必须有抽象属性和抽象⽅法,但是⼀旦有了抽象⽅法,就⼀定要把这个类声明为抽象类(4) 具体派⽣类必须覆盖基类的抽象⽅法(5) 抽象派⽣类可以覆盖基类的抽象⽅法,也可以不覆盖。
如果不覆盖,则其具体派⽣类必须覆盖它们2、接⼝(1) 接⼝不能被实例化(2) 接⼝只能包含⽅法声明(3) 接⼝的成员包括⽅法、属性、索引器、事件(4) 接⼝中不能包含常量、字段(域)、构造函数、析构函数、静态成员3、接⼝和抽象类的区别(1)抽象类可以有构造⽅法,接⼝中不能有构造⽅法。
(2)抽象类中可以有普通成员变量,接⼝中没有普通成员变量(3)抽象类中可以包含静态⽅法,接⼝中不能包含静态⽅法(4)⼀个类可以实现多个接⼝,但只能继承⼀个抽象类。
(5)接⼝可以被多重实现,抽象类只能被单⼀继承(6)如果抽象类实现接⼝,则可以把接⼝中⽅法映射到抽象类中作为抽象⽅法⽽不必实现,⽽在抽象类的⼦类中实现接⼝中⽅法4、接⼝和抽象类的共同点(1) 都可以被继承(2) 都不能被实例化(3) 都可以包含⽅法声明(4) 派⽣类必须实现未实现的⽅法5、为什么要写接⼝或抽象类1. 减少代码的书写(代码重载)2. 提⾼了代码的可维护性和扩展性。
3. 在团队合作中,代码的规范性6、抽象类和接⼝都差不多,什么时候选择使⽤接⼝1. 在当前类族中不是必须的(例如Tager需要⽽Rabbit不需要)的⽅法时2. 不同类族的多个类需要实现同样的⽅法时(接⼝)。
C++中抽象类和接口的区别

C++中抽象类和接⼝的区别抽象类(abstract class)和接⼝(interface)的概念是⾯向对象设计中常⽤的概念, 也是⽐较容易混淆的概念. 在这⾥, 我提出⼀种区分它们的思路:1. 如果⼀个类B在语法上继承(extend)了类A, 那么在语义上类B是⼀个类A.2. 如果⼀个类B在语法上实现了(implement)接⼝I, 那么类B遵从接⼝I制定的协议.------------------------------------------------------------------------------------------------使⽤abstract class的根本原因在于, ⼈们希望通过这样的⽅式, 表现不同层次的抽象.⽽interface的本质是⼀套协议. 在程序设计的发展中, ⼈们⼜发现接⼝可以⽤来表⽰对⾏为的抽象, 不过, 这只是interface的⼀种⽤法不是其本质. ------------------------------------------------------------------------------------------------理论结合实际才是最好的学习⽅式, 不过在这⾥, 我只想举⼀些我见到过关于接⼝使⽤的反⾯教材:1. 在接⼝中包含数据成员. 这⼏乎肯定是错的, 因为协议是规范是标准, 不应该跟具体实现有任何牵连, 也不应该给具体实现造成任何负担.2. C++中 delete 掉⼀个接⼝. 例如:class IInterface(){Public:Virtual ~IInterface(){};…}Class ClassImpl : public IInterface{…}Int main(){IInterface* pInterface = new ClassImpl();…delete pInterface;}从语法的⾓度和语⾔⾃⾝的⾓度来看, 这是可⾏的, ⽽且只要将接⼝的析构函数设置为virtual, 就能避免内存泄漏.但我要说, 这不是语法和语⾔的问题, ⽽是从根本上就错了.因为接⼝是⼀套协议, ⼀套规范, 并不是实现.Delete ⼀个接⼝的代码, 到底想要表达什么样的语义? 如果⼀段代码从语义上都说不通, 就不应该出现在程序中.------------------------------------------------------------------------------------------------------------------------要在C++中表现接⼝的概念, ⼀种做法是这样:class IInterface{public:virtual void DoSomething() = 0;// 不应当有析构函数, 因为从语义上说, 接⼝是不能delete的.}如果要delete, 只能delete⼀个类的实例:Class A{Public:Virtual ~A();Public:Virtual void DoSomething() = 0;}Class B : public A{…}Int main(){A* pA = new B();…Delete pA;}我们可以这样做, 因为pA对应的是⼀个实例, 我们可以在A这⼀层将其销毁.先举个例⼦,⽅便⼤家理解,然后从例⼦中抽象概括出结理论。
java abstract方法继承

Java Abstract方法继承一、什么是Abstract方法Abstract方法是Java中一种特殊的方法,它只有声明而没有具体的实现。
在定义一个Abstract方法时,需要使用abstract关键字修饰方法,并且该方法所在的类必须是抽象类或者接口。
Abstract方法的定义如下:public abstract void methodName();二、抽象类与接口抽象类(Abstract Class)是一个不能被实例化的类,它可以包含Abstract方法和具体的方法实现。
抽象类通过使用abstract关键字进行修饰。
接口(Interface)是一种纯抽象的类,它只包含Abstract方法和常量。
接口定义方法时,默认使用public abstract修饰。
抽象类和接口的区别如下: - 抽象类可以有构造方法,而接口不能有构造方法。
- 类只能继承一个抽象类,但可以实现多个接口。
- 抽象类可以有成员变量,而接口只能有常量。
- 接口中的方法默认是public的,而抽象类中的方法可以有不同的访问修饰符。
三、Abstract方法的继承方式Abstract方法在继承关系中有以下几种继承方式:子类覆盖方法、子类重载方法、子类继续声明抽象方法。
1. 子类覆盖方法当一个子类继承自一个抽象类或者实现一个接口时,它必须实现抽象类或接口中的所有Abstract方法。
子类通过覆盖Abstract方法来提供具体的实现。
例如,有一个抽象类Animal,其中定义了一个Abstract方法eat(),如下所示:public abstract void eat();}如果一个子类Dog继承自Animal,则必须实现eat()方法:public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃骨头");}}2. 子类重载方法除了覆盖Abstract方法,子类还可以重载Abstract方法。
面向对象程序设计中的接口和抽象类的对比研究

面向对象程序设计中的接口和抽象类的对比研究在面向对象程序设计当中,接口(Interface)和抽象类(Abstract Class)是常用的两种机制,它们旨在提高程序的复用性、可扩展性和可维护性。
接口和抽象类虽然都可以实现多态性,但是它们的实现方式和应用场景却存在一些区别。
本文将针对接口和抽象类进行对比研究,分别从概念、实现、使用、优缺点等方面进行探讨。
一、概念接口是一组抽象方法的集合,其中的方法都是公共的,不提供具体的实现。
接口的主要目的是定义整个系统的服务,让接口与接口之间的实现独立开来。
接口的定义方式为 interface,接口的成员默认为 public static final,可以省略这些修饰符。
抽象类也是一种不完整的类,不提供具体的实现,只是定义出一些抽象方法。
其主要目的在于为子类提供一个通用的类型,并可以通过继承的方式来实现具体的方法。
抽象类的定义方式为 abstract class,其中可以同时定义具体的方法和抽象的方法,在子类中必须实现抽象方法才能进行实例化。
二、实现接口和抽象类的实现方式存在较大的差别。
接口的实现方式为类实现接口,一个类可以实现多个接口,接口之间是独立任意的,通过关键字 implements 来实现。
接口的方法必须在实现类中进行实现,实现类中需要完全实现接口中的所有方法,否则这个类仍是一个抽象类。
抽象类的实现方式为子类继承抽象类,并对抽象方法进行具体实现。
抽象类可以有自己的属性和具体实现的方法,同时可以定义抽象方法。
抽象类的子类需要在继承抽象类的同时必须实现抽象方法,否则仍是一个抽象类。
三、使用接口和抽象类在使用上也有不同的特点。
接口主要用于解耦合,实现系统的松散耦合。
通过定义接口和实现类之间的关系,可以方便地进行接口的解耦合。
接口的定义时一种规范,通过这些规范来确保不同类之间的互操作性以及符合代码复合原则。
抽象类主要用于继承,提供了一个通用的类型,并让子类去具体实现这个通用类型所需要的方法。
面向对象程序设计中的抽象类与接口研究

面向对象程序设计中的抽象类与接口研究随着软件开发技术的不断发展,面向对象程序设计成为了当今十分流行和广泛使用的一种编程思想。
而在面向对象程序设计中,抽象类与接口则是两个非常重要的概念。
本文将对抽象类与接口进行深入研究。
一、什么是抽象类?抽象类是一种不能被实例化的类,它的主要作用是为其子类提供具有实现细节的基类。
抽象类一般用于描述某一类事物的抽象概念,而非具体的某一个事物。
在Java中,我们可以使用abstract关键字来定义一个抽象类。
抽象类中可以包含抽象方法和非抽象方法,抽象方法则是一种没有具体实现的方法,而非抽象方法则是有具体实现的方法。
abstract class Animal {String name;public void setName(String name) { = name;}public abstract void eat();}上述代码定义了一个名为Animal的抽象类和一个抽象方法eat()。
由于抽象方法没有具体实现,因此不需要在抽象类中对它进行实现。
二、什么是接口?接口是一种到处可见的类型,它定义了一组方法的规范,但并不提供对这些方法的具体实现。
接口只是指定了一组标准,由实现该接口的类来提供具体实现。
在Java中,我们可以使用interface关键字来定义一个接口。
接口中只能包含常量和抽象方法,常量必须使用public static final修饰符进行修饰,抽象方法则必须使用public abstract修饰符进行修饰。
interface Animal {public static final int NUM_LEGS = 4;public abstract void makeSound();}上述代码定义了一个名为Animal的接口和一个抽象方法makeSound()。
由于接口中的抽象方法没有具体实现,因此我们必须在实现该接口的类中对它进行实现。
三、抽象类与接口的区别虽然抽象类与接口都是用于描述某一类事物的抽象概念,但二者之间还是存在一些区别的,具体表现如下:1. 实现方式不同抽象类是一种类,是通过继承来实现的,而接口是一种接口,是通过实现来实现的。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
abstract void method1();
abstract void method2();
…
}
使用interface的方式定义Demo抽象类的方式如下:
javoid method1();
void method2();
从编程的角度来看,abstract class和interface都可以用来实现"design by contract"的思想。但是在具体的使用上面还是有一些区别的。
首先,abstract class在Java语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface。也许,这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。
在面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是反过来却不是这样。并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。
比如:如果我们进行一个图形编辑软件的开发,就会发现问题领域存在着圆、三角形这样一些具体概念,它们是不同的,但是它们又都属于形状这样一个概念,形状这个概念在问题领域是不存在的,它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能够实例化的。
在面向对象领域,抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述,但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类,而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体,因此它可以是不允许修改的;同时,通过从这个抽象体派生,也可扩展此模块的行为功能。熟悉OCP的读者一定知道,为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle),抽象类是其中的关键所在。
java代码
或者
java代码
interface Door {
void open();
void close();
void alarm();
}
那么具有报警功能的AlarmDoor的定义方式如下:
java代码
class AlarmDoor extends Door {
void open() { … }
void close() { … }
上面主要从语法定义和编程的角度论述了abstract class和interface的区别,这些层面的区别是比较低层次的、非本质的。本文将从另一个层面:abstract class和interface所反映出的设计理念,来分析一下二者的区别。作者认为,从这个层面进行分析才能理解二者概念的本质所在。
前面已经提到过,abstarct class在Java语言中体现了一种继承关系,要想使得继承关系合理,父类和派生类之间必须存在"is a"关系,即父类和派生类在概念本质上应该是相同的。对于interface来说则不然,并不要求interface的实现者和interface定义在概念本质上是一致的,仅仅是实现了interface定义的契约而已。为了使论述便于理解,下面将通过一个简单的实例进行说明。
解决方案二:
既然open、close和alarm属于两个不同的概念,根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有:这两个概念都使用abstract class方式定义;两个概念都使用interface方式定义;一个概念使用abstract class方式定义,另一个概念使用interface方式定义。
…
}
在abstract class方式中,Demo可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface方式的实现中,Demo只能够有静态的不能被修改的数据成员(也就是必须是static final的,不过在interface中一般不定义数据成员),所有的成员方法都是abstract的。从某种意义上说,interface是一种特殊形式的abstract class。
abstract class和interface是Java语言中的两种定义抽象类的方式,它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理,因为它们表现了概念间的不同的关系(虽然都能够实现需求的功能)。这其实也是语言的一种的惯用法。
如果我们对于问题领域的理解是:AlarmDoor在概念本质上是Door,同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢?前面已经说过,abstract class在Java语言中表示一种继承关系,而继承关系在本质上是"is a"关系。所以对于Door这个概念,我们应该使用abstarct class方式来定义。另外,AlarmDoor又具有报警功能,说明它又能够完成报警概念中定义的行为,所以报警概念可以通过interface方式定义。如下所示:
同样,如果不能在抽象类中定义默认行为,就会导致同样的方法实现出现在该抽象类的每一个派生类中,违反了"one rule,one place"原则,造成代码重复,同样不利于以后的维护。因此,在abstract class和interface间进行选择时要非常的小心。
三、从设计理念层面看abstract class和interface
java代码
abstract class Door {
abstract void open();
abstract void close();
}
java代码
interface Alarm {
void alarm();
}
java代码
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语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。
abstract class Door {
abstract void open();
abstract void close();
}
使用interface方式定义Door:
java代码
interface Door {
void open();
void close();
}
其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。
二、从语法定义层面看abstract class和interface
在语法层面,Java语言对于abstract class和interface给出了不同的定义方式,下面以定义一个名为Demo的抽象类为例来说明这种不同。使用abstract class的方式定义Demo抽象类的方式如下:
java代码
其次,在abstract class的定义中,我们可以赋予方法的默认行为。但是在interface的定义中,方法却不能拥有默认行为,为了绕过这个限制,必须使用委托,但是这会增加一些复杂性,有时会造成很大的麻烦。
在抽象类中不能定义默认行为还存在另一个比较严重的问题,那就是可能会造成维护上的麻烦。因为如果后来想修改类的界面(一般通过abstract class或者interface来表示)以适应新的情况(比如,添加新的方法或者给已用的方法中添加新的参数)时,就会非常的麻烦,可能要花费很多的时间(对于派生类很多的情况,尤为如此)。但是如果界面是通过abstract class来实现的,那么可能就只需要修改定义在abstract class中的默认行为就可以了。
1、我们可能没有理解清楚问题领域,AlarmDoor在概念本质上到底是Door还是报警器?
2、如果我们对于问题领域的理解没有问题,比如:我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的,那么我们在实现时就没有能够正确的揭示我们的设计意图,因为在这两个概念的定义上(均使用interface方式定义)反映不出上述含义。
其实,两者之间还是有很大的区别的,对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析,试图给开发者提供一个在二者之间进行选择的依据。
一、理解抽象类
abstract class和interface在Java语言中都是用来进行抽象类(本文中的抽象类并非从abstract class翻译而来,它表示的是一个抽象体,而abstract class为Java语言中用于定义抽象类的一种方法,请读者注意区分)定义的,那么什么是抽象类,使用抽象类能为我们带来什么好处呢?