抽象类和接口的区别【8】
|
若有不正之处，请多多谅解并欢迎批评指正，不甚感激。 本文原创作者：pipi-changing 本文版权归作者和博客园共有，未经作者同意必须保留此段声明，
抽象类和接口的区别
【概述】 一个软件设计的好坏，我想很大程度上取决于它的整体架构， 而这个整体架构其实就是你对整个宏观商业业务的抽象框架，当代表业务逻辑的高层抽象层结构 合理时， 你底层的具体实现需要考虑的就仅仅是一些算法和一些具体的业务实现了。 当你需要再开发另一个相近的项目时，你以前的抽象层说不定还可以再次利用 。 面向对象的设计，复用的重点其实应该是抽象层的复用，而不是具体某一个代码块的复用。
在 面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。 并不是 所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象， 这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、 设计中得出的抽象概念， 是对一系列看上去不同，但是本质上相同的具体概念的抽象。 比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、 三角形这样一些具体概念， 它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的， 它就是一个抽象概念。正是因为抽象的概念 在问题领域没有对应的具体概念， 所以用以表征抽象概念的抽象类是不能够实例化的。
在面向对象领域，抽象类主要用来进行类型隐藏。 我们可以构造出一个固定的一组行为的抽象描 述， 但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，
对于面向对象编程来说，抽象是它的一大特征之一。在Java中，可以通过两种形式来体现OOP（Object Oriented Programming，OOP，面向对象程序设计）的抽象：接口和抽象类。 这两者有太多相似的地方，又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用，但是实际则不然。 今天我们就一起来学习一下Java中的接口和抽象类。
【抽象类】
在了解抽象类之前，先来了解一下抽象方法。 抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。抽象方法的声明格式为：
abstract void fun();
抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法，则称这个类为抽象类， 抽象类必须在类前用abstract关键字修饰。因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。 抽象类不一定必须含有抽象方法。比如：
public abstract class Dog {
//普通方法
void bark() {
}
//抽象方法
abstract void Play();
}
[public] abstract class ClassName {
abstract void fun();
}
从这里可以看出，抽象类就是为了继承而存在的，如果你定义了一个抽象类，却不去继承它， 那么等于白白创建了这个抽象类，因为你不能用它来做任何事情。对于一个父类， 如果它的某个方法在父类中实现出来没有任何意义，必须根据子类的实际需求来进行不同的实现， 那么就可以将这个方法声明为abstract方法，此时这个类也就成为abstract类了。
包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样， 同样可以拥有成员变量和普通的成员方法。注意，抽象类和普通类的主要有三点区别： 1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法）， 缺省情况下默认为public。 2）抽象类不能用来创建对象； 3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。 如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。 在其他方面，抽象类和普通的类并没有区别。
public abstract class Animal { public abstract void cry(); } public class Cat extends Animal{ @Override public void cry() { System.out.println("猫叫：喵喵..."); } } public class Dog extends Animal{ @Override public void cry() { System.out.println("狗叫:汪汪..."); } } public class Test { public static void main(String[] args) { Animal a1 = new Cat(); Animal a2 = new Dog(); a1.cry(); a2.cry(); } } -------------------------------------------------------------------- Output: 猫叫：喵喵... 狗叫:汪汪...
创建抽象类和抽象方法非常有用,因为他们可以使类的抽象性明确起来, 并告诉用户和编译器打算怎样使用他们.抽象类还是有用的重构器, 因为它们使我们可以很容易地将公共方法沿着继承层次结构向上移动。
【接口】
接口，英文称作interface，在软件工程中，接口泛指供别人调用的方法或者函数。 从这里，我们可以体会到Java语言设计者的初衷，它是对行为的抽象。 在Java中，定一个接口的形式如下： [public] interface InterfaceName {
}
接口中可以含有 变量和方法。但是要注意，接口中的变量会被隐式地指定为public static final变量 （并且只能是public static final变量，用private修饰会报编译错误）， 而方法会被隐式地指定为public abstract方法且只能是public abstract方法 （用其他关键字，比如private、protected、static、 final等修饰会报编译错误）， 并且接口中所有的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法。 从这里可以隐约看出接口和抽象类的区别，接口是一种极度抽象的类型，它比抽象类更加“抽象”， 并且一般情况下不在接口中定义变量。
要让一个类遵循某组特地的接口需要使用implements关键字，具体格式如下： class ClassName implements Interface1,Interface2,[....]{
}
可以看出，允许一个类遵循多个特定的接口。如果一个非抽象类遵循了某个接口，就必须实现该接口中的所有方法。 对于遵循某个接口的抽象类，可以不实现该接口中的抽象方法。
【在使用接口过程中需要注意如下几个问题：】
1、Interface中的所有方法访问权限自动被声明为public。确切的说只能为public， 当然你可以显示的声明为protected、private，但是编译会出错！
2、接口中可以定义“成员变量”，或者说是不可变的常量， 因为接口中的“成员变量”会自动变为为public static final。可以通过类命名直接访问：ImplementClass.name。
3、接口中不存在实现的方法。
4、实现接口的非抽象类必须要实现该接口的所有方法。抽象类可以不用实现。
5、不能使用new操作符实例化一个接口，但可以声明一个接口变量， 该变量必须引用（refer to)一个实现该接口的类的对象。可以使用 instanceof 检查一个对象是否实现了某个特定的接口。 例如：if(anObject instanceof Comparable){}。
6、在实现多接口的时候一定要避免方法名的重复。
【抽象类和接口的区别】
1.语法层面上的区别 1）抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法； 2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的； 3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法； 4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。 2.设计层面上的区别 1）抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。 抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。 举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候， 可以将飞机设计为一个类Airplane，将鸟设计为一个类Bird，但是不能将 飞行 这个特性也设计为类， 因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly， 包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机， 比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。 从这里可以看出，继承是一个 "是不是"的关系，而 接口 实现则是 "有没有"的关系。 如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系， 比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口。 2）设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范， 它是一种辐射式设计。什么是模板式设计？最简单例子，大家都用过ppt里面的模板， 如果用模板A设计了ppt B和ppt C，ppt B和ppt C公共的部分就是模板A了，如果它们的公共部分需要改动， 则只需要改动模板A就可以了，不需要重新对ppt B和ppt C进行改动。而辐射式设计， 比如某个电梯都装了某种报警器，一旦要更新报警器，就必须全部更新。也就是说对于抽象类， 如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行， 如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。 下面看一个网上流传最广泛的例子：门和警报的例子：门都有open( )和close( )两个动作， 此时我们可以定义通过抽象类和接口来定义这个抽象概念： abstract class Door {
public abstract void open();
public abstract void close();
}
或者 interface Door {
public abstract void open();
public abstract void close();
}
本文原创作者：pipi-changing 本文原创出处：http://www.cnblogs.com/pipi-changing/
但是现在如果我们需要门具有报警alarm( )的功能，那么该如何实现？下面提供两种思路： 1）将这三个功能都放在抽象类里面，但是这样一来所有继承于这个抽象类的子类都具备了报警功能， 但是有的门并不一定具备报警功能； 2）将这三个功能都放在接口里面，需要用到报警功能的类就需要实现这个接口中的open( )和close( )， 也许这个类根本就不具备open( )和close( )这两个功能，比如火灾报警器。 从这里可以看出， Door的open() 、close()和alarm()根本就属于两个不同范畴内的行为， open()和close()属于门本身固有的行为特性，而alarm()属于延伸的附加行为。 因此最好的解决办法是单独将报警设计为一个接口，包含alarm()行为,Door设计为单独的一个抽象类， 包含open和close两种行为。再设计一个报警门继承Door类和实现Alarm接口。
interface Alram {
void alarm();
}
abstract class Door {
void open();
void close();
}
class AlarmDoor extends Door implements Alarm {
void oepn() {
//....
}
void close() {
//....
}
void alarm() {
//....
}
}
Java接口和Java抽象类最大的一个区别，就在于Java抽象类可以提供某些方法的部分实现， 而Java接口不可以（就是interface中只能定义方法，而不能有方法的实现， 而在abstract class中则可以既有方法的具体实现，又有没有具体实现的抽象方法）， 这大概就是Java抽象类唯一的优点吧，但这个优点非常有用。如果向一个抽象类里加入一个新的具体方法时， 那么它所有的子类都一下子都得到了这个新方法，而Java接口做不到这一点， 如果向一个Java接口里加入一个 新方法，所有实现这个接口的类就无法成功通过编译了， 因为你必须让每一个类都再实现这个方法才行，这显然是Java接口的缺点。
而由于Java语言的单继承性，所以抽象类作为类型定义工具的效能大打折扣。在这一点上， Java接口的优势就出来了，任何一个实现了一个Java接口所规定的方法的类都可以具有这个接口的类型， 而一个类可以实现任意多个Java接口，从而这个类就有了多种类型。 （使用抽象类，那么继承这个抽象类的子类类型就比较单一，因为子类只能单继承抽象类； 而子类能够同时实现多个接口，因为类型就比较多。接口和抽象类都可以定义对象， 但是只能用他们的具体实现类来进行实例化。）
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类进行变量的类型声明、参数的类型声明、 方法的返回类型说明，以及数据类型的转换等。
下面给出一个具体的接口Action，代码如下所示： package org.springframework.webflow.execution;
public interface Action {
public Event execute(RequestContext context) throws Exception;
}
在这个接口中，定义了一个没有具体实现的方法，方法名叫做execute()， 返回类型是Event。接口中的方法都是没有实现的。 这些方法的具体实现是在实现(implements)这个接口的类中给出的。 再来看一个实现Action接口的抽象类AbstractAction，代码如下。
package org.springframework.webflow.action; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.springframework.beans.factory.BeanInitializationException; import org.springframework.beans.factory.InitializingBean; import org.springframework.util.ClassUtils; import org.springframework.webflow.core.collection.AttributeMap; import org.springframework.webflow.execution.Action; import org.springframework.webflow.execution.Event; import org.springframework.webflow.execution.RequestContext; public abstract class AbstractAction implements Action, InitializingBean { protected final Log logger = LogFactory.getLog(getClass()); public EventFactorySupport getEventFactorySupport() { return new EventFactorySupport(); } public void afterPropertiesSet() throws Exception { try { initAction(); } catch (Exception ex) { throw new BeanInitializationException( "Initialization of this Action failed: " + ex.getMessage(), ex); } }
protected void initAction() throws Exception { } protected Event success() { return getEventFactorySupport().success(this); } protected Event success(Object result) { return getEventFactorySupport().success(this, result); } protected Event error() { return getEventFactorySupport().error(this); } protected Event error(Exception e) { return getEventFactorySupport().error(this, e); } protected Event yes() { return getEventFactorySupport().yes(this); } protected Event no() { return getEventFactorySupport().no(this); } protected Event result(boolean booleanResult) { return getEventFactorySupport().event(this, booleanResult); } protected Event result(String eventId) { return getEventFactorySupport().event(this, eventId); } protected Event result(String eventId, AttributeMap resultAttributes) { return getEventFactorySupport().event(this, eventId, resultAttributes); } protected Event result(String eventId, String resultAttributeName, Object resultAttributeValue) { return getEventFactorySupport().event(this, eventId, resultAttributeName, resultAttributeValue); } public final Event execute(RequestContext context) throws Exception { Event result = doPreExecute(context); if (result == null) { result = doExecute(context); doPostExecute(context); } else { if (logger.isInfoEnabled()) { logger.info("Action execution disallowed; pre-execution result is '" + result.getId() + "'"); } } return result; } protected String getActionNameForLogging() { return ClassUtils.getShortName(getClass()); } protected Event doPreExecute(RequestContext context) throws Exception { return null; } // 抽象方法 protected abstract Event doExecute(RequestContext context) throws Exception; protected void doPostExecute(RequestContext context) throws Exception { } } 在抽象类AbstractAction中，既有具体实现的方法，又有没有具体实现的抽象方法 //抽象方法 protected abstract Event doExecute(RequestContext context) throws Exception; 需要注意的是在抽象类中，如果方法没有具体实现（就是方法后面没有{}）， 那么必须加上abstract来声明这个方法，而接口中不需要使用abstract来声明 （抽象类之所以被称为抽象类，就是因为它包含有抽象方法。含有抽象方法的类叫做抽象类）。
注意： ISP（Interface Segregation Principle）：面向对象的一个核心原则。 它表明使用多个专门的接口比使用单一的总接口要好。
一个类对另外一个类的依赖性应当是建立在最小的接口上的。
一个接口代表一个角色，不应当将不同的角色都交给一个接口。 没有关系的接口合并在一起，形成一个臃肿的大接口，这是对角色和接口的污染。
【小结】 但是，一个类却可以实现多个interface。 只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中一般不定义数据成员）， 所有的成员方法都是abstract的。 其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。 8.抽象类里可以有构造方法，而接口内不能有构造方法。
在使用抽象类时需要注意几点：
1、抽象类不能被实例化，实例化的工作应该交由它的子类来完成，它只需要有一个引用即可。
2、抽象方法必须由子类来进行重写。
3、只要包含一个抽象方法的抽象类，该方法必须要定义成抽象类，不管是否还包含有其他方法。
4、抽象类中可以包含具体的方法，当然也可以不包含抽象方法。
5、子类中的抽象方法不能与父类的抽象方法同名。
6、abstract不能与final并列修饰同一个类。
7、abstract 不能与private、static、final或native并列修饰同一个方法。
再补充点两者在应用上的区别： 接口更多的是在系统框架设计方法发挥作用，主要定义模块之间的通信， 而抽象类在代码实现方面发挥作用，可以实现代码的重用
【什么时候试用抽象类和接口？】
1.如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。 2.如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承， 子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。 3.如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口， 那么就需要改变所有实现了该接口的类。
|
