Java中Interface与Abstractclass区别

interface和abstract class是Java中实现多态的基础，都很有用，但也有一些区别：

1.interface被继承时用的关键字是implements，而且可以同时implements多个interface，而abstract class被继承时用的关键字是extends，而且只能同时extends一个abstract class。

2.interface内定义的方法都是public的，而abstract class内的则不一定。

3.interface内定义的成员对象都是static & final的，而abstract class不是(一定不能是final)

4.interface的方法不能有默认实现，只有一个声明，而abstract class内声明abstract的方法不能有实现，非声明abstract的方法可以有默认实现。

5.interface被implements时，所有方法都必须被实现，必须声明是public的，而abstract class被extends时只有abstract的方法才必须被实现，别的有默认实现的直接被继承过来。

注：不能创建接口或抽象类的实例。

public interface Instrument {
　　int i = 5; //static & final
　　//can't have method definitions:
　　void play(); //automatically public
　　void adjust();
　　}
public abstract class AbstractCachedTable {
　　public Hashtable table = new Hashtable();
　　abstract public void refresh();
　　public Object get(Object o) {
　　Object target = null;
　　target = table.get(o);
　　return target;
　　}
　}

　　一般情况下，建议使用interface（因为能同时implements多个interface的特性，能更好地实现多态），当需要有默认实现和成员对象时才考虑abstract class。

　　在Java中所有的对象都用类来描绘，但是不是每一个类都用来描绘对象的。用来描绘某一类对象共有的本质，这就是抽象。比如：形状存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类(这儿的抽象类并不是abstract class翻译而来的，它包括interface和abstract class)是不能够实例化的。我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。在面向对象领域，抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的；同时，通过从这个抽象体派生，也可扩展此模块的行为功能。熟悉OCP的读者一定知道，为了能够实现面向对象设计的一个最核心的原则OCP( Open-Closed Principle)，抽象类是其中的关键所在。

　　从语言层面上面来讲：abstract class可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface方式的实现中，只能够有静态的不能被修改的数据成员（也即interface是static final的），所有的成员方法都是abstract的。从这种角度来说，interface是abstarct class的一种特殊情况。abstract class可以提供某些方法的部分实现，而interface不可以，这大概就是abstract class唯一的优点吧，但这个优点非常有用。如果向一个抽象类里加入一个新的具体方法时，那么它所有的子类都一下子都得到了这个新方法，而 interface做不到这一点，如果向一个interface里加入一个新方法，所有实现这个接口的类就无法成功通过编译了，因为你必须让每一个类都再实现这个方法才行。

而从设计出发：假设在我们的问题领域中有一个关于Door的抽象概念，该Door具有执行两个动作open和close，此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型，定义方式分别如下所示：

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

　　其他具体的Door类型extends absract class或者implements interface就可以了。

　　看起来好像使用abstract class和interface没有大的区别。

　　但是现在如果要求Door加上报警的alarm功能，我们应该如何去设计程序的结构呢？

　　解决方案一：

　　简单的在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() { … }
　　｝

　　简单的在abstract class添加abstract void alarm()方法或者在interface中加一个alarm()方法？但是如果这样，在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变（比如：修改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方式定义。如下所示：

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