java 接口（Interface）与 抽象类（abstract class）

在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

　　抽象类往往用来表征我们在对问题领域进行分析、 设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象，我们不能把它们实例化（拿不出一个具体的东西）所以称之为抽象。

　　比如：我们要描述“水果”，它就是一个抽象，它有质量、体积等一些共性（水果有质量），但又缺乏特性（苹果、橘子都是水果，它们有自己的特性），我们拿不出唯一一种能代表水果的东西（因为苹果、橘子都不能代表水果），可用抽象类来描述它，所以抽象类是不能够实例化的。当我们用某个类来具体描述“苹果”时，这个类就可以继承描述“水果”的抽象类，我们都知道“苹果”是一种“水果”。

　　在面向对象领域，抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为这个抽象类的所有派生类。

接口和抽象类中的所有抽象方法不能有具体实现，而应在它们的子类中实现所有的抽象方法（要有函数体，哪怕{ }里是空的），ｊａｖａ的设计者可能为抽象方法的灵活性考虑，每个子类可根据自己的需要来实现抽象方法。

[java]  view plain copy print ?

1. 抽象类（abstract class）的定义方式如下：   
2. public abstract class AbstractClass             //里面至少有一个抽象方法  
3. {  
4.  　　public int t;  //普通数据成员  
5. 　　 public abstract void method1();   //抽象方法，抽象类的子类在类中必须实现抽象类中的抽象方法  
6.  　　public abstract void method2();   
7.  　　public void method3();   //非抽象方法  
8.  　　public int method4();  
9.  　　publi int method4 (){  
10.       　　…… //抽象类中可以赋予非抽象方法方法的默认行为，即方法的具体实现  
11.  　　}  
12.        public void method3(){  
13.       　　…… //抽象类中可以赋予非抽象方法方法的默认行为，即方法的具体实现  
14.  　　}   
15. }  
16.    
17. 接口（interface）的定义方式如下：   
18. public interface Interface  
19. {   
20.  　　static final int i;  //接口中不能有普通数据成员，只能够有静态的不能被修改的数据成员,static表示全局，final表示不可修改，可以不用static final 修饰，会隐式的声明为static和final  
21.  　　  
22. 　　 public void method1();  //接口中的方法一定是抽象方法，所以不用abstract修饰  
23.  　　  
24.  　　public void method2();  //接口中不能赋予方法的默认行为，即不能有方法的具体实现  
25. }  

简言之抽象类是一种功能不全的类，接口只是一个抽象方法声明和静态不能被修改的数据的集合，两者都不能被实例化。

　　从某种意义上说，接口是一种特殊形式的抽象类，在ｊａｖａ语言中抽象类表示的是一种继承关系，一个类只能继承继承一个抽象类，而一个类却可以实现多个接口。在许多情况下，接口确实可以代替抽象类，如果你不需要刻意表达属性上的继承的话。

看一下这位仁兄的总结：

点击打开链接

下面比较一下两者的语法区别：
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然
eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，
但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。
 下面接着再说说两者在应用上的区别：
接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。
而抽象类在代码实现方面发挥作用，可以实现代码的重用，
例如，模板方法设计模式是抽象类的一个典型应用，
假设某个项目的所有Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，
那么就可以定义一个抽象的基类，让所有的Servlet都继承这个抽象基类，
在抽象基类的service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码
(这因该是最全最细的答案了)希望能帮到你

进一步理解，关于ｊａｖａ引入抽象类、接口的目的，向高手请教得到的答复如下：
 
1、从类的层次结构上看，抽象类是在层次的顶端，但在实际的设计当中，一般来说抽象类应当是后面才会出现。

为什么？实际上抽象类的获取有点像数学中的提取公因式：ax+bx，x就是抽象类，如果你没有前面的式子，你怎么知道x是不是公因式呢？
在这点上，也符合人们认识世界的过程，先具体后抽象。因此在设计过程中如果你得到大量的具体概念并从当中找到其共性时，
这个共性的集合就是抽象类应当是没错的。

 
2、interface从表面上看，和抽象类很相似，但用法完全不同。
它的基本功能就是把一些毫不相关的类（概念）集合在一起形成一个新的、可集中操作的“新类”。

我给学生的一个典型例子就是“司机”。谁可以当司机？谁都可以，只要领取了驾照。所以我不管你是学生，白领、蓝领还是老板，只要有驾照就是司机。 

[java]  view plain copy print ?

1. interface DriverLicence {   
2.     Licence getLicence();   
3. }  
4. class StudentDriver extends Student implements DriverLicence {   
5. }   
6.   
7. class WhtieCollarEmployeeDriver extends WhtieCollarEmployee implements DriverLicence {   
8. }   
9.   
10. class BlueCollarEmployeeDriver extends BlueCollarEmployee implements DriverLicence {   
11. }   
12.   
13. class BossDriver extends Boss implements Driver {   
14. }  
15.   
16. 当我定义了“汽车”类后，我就可以指定“司机”了。  
17. class Car {   
18.     setDriver(DriverLicence driver);   
19. }   

这时候，Car的对象并不关心这个司机到底是干什么的，他们的唯一共同点是领取了驾照（都实现了DriverLicence接口）。这个，应当是接口最强大的地方也是抽象类无法比拟的。 

      总结：抽象类是提取具体类的公因式，而接口是为了将一些不相关的类“杂凑”成一个共同的群体。通常我们平时养成良好的习惯就是多用接口，毕竟ｊａｖａ是单继承，不像C++，但是在需要使用抽象类的时候一定还是要用的（有点类似goto的用法），呵呵。
    以上借鉴：  http://www.cnblogs.com/xiaoao808/archive/2008/03/11/1100886.html

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抽象类的方式如下：

[java]  view plain copy print ?

1. abstract class Demo ｛      
2.      abstract void method1();      
3.      abstract void method2();      
4.  …      
5. ｝      
6.   
7. abstract class Demo ｛      
8.      abstract void method1();      
9.      abstract void method2();      
10.  …      
11. ｝      
12.      
13. 使用interface的方式定义Demo抽象类的方式如下：  
14.   
15.   
16. interface Demo {      
17.     void method1();      
18.      void method2();      
19.  …      
20. }      
21.   
22. interface Demo {      
23.     void method1();      
24.      void method2();      
25.  …      
26. }      

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


    【1】  从编程的角度来看，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间进行选择时要非常的小心。


 


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


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


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

[java]  view plain copy print ?

1. 考虑这样一个例子，假设在我们的问题领域中有一个关于Door的抽象概念，该Door具有执行两个动作open和close，  
2. 此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型，定义方式分别如下所示：    
3.   
4.   
5. 使用abstract class方式定义Door：      
6.     
7. abstract class Door {      
8.  abstract void open();      
9.  abstract void close()；      
10. }      
11.   
12. 使用abstract class方式定义Door：      
13.     
14. abstract class Door {      
15.  abstract void open();      
16.  abstract void close()；      
17. }      
18.   
19. 使用interface方式定义Door：      
20.     
21.     
22. interface Door {      
23.  void open();      
24.  void close();      
25. }      
26.   
27. 使用interface方式定义Door：      
28.     
29.     
30. interface Door {      
31.  void open();      
32.  void close();      
33. }      
34. 其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。  

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

如果现在要求Door还要具有报警的功能。
我们该如何设计针对该例子的类结构呢（在本例中，主要是为了展示abstract class和interface反映在设计理念上的区别，其他方面无关的问题都做了简化或者忽略）？

下面将罗列出可能的解决方案，并从设计理念层面对这些不同的方案进行分析。  

解决方案一：  

[java]  view plain copy print ?

1. 简单的在Door的定义中增加一个 方法，如下：   
2.   
3.   
4. abstract class Door {      
5.      abstract void open();      
6.      abstract void close()；      
7.      abstract void alarm();      
8. }      
9.     
10.        
11. 或者      
12.     
13. interface Door {      
14.      void open();      
15.      void close();      
16.      void alarm();      
17. }      
18.   
19. abstract class Door {      
20.      abstract void open();      
21.     abstract void close()；      
22.     abstract void alarm();      
23. }      
24.     
25.        
26. 或者      
27.     
28. interface Door {      
29.  void open();      
30.  void close();      
31.  void alarm();      
32. }      
33. 那么具有报警功能的AlarmDoor的定义方式如下：    
34.   
35.   
36. class AlarmDoor extends Door {      
37.     void open() { … }      
38.     void close() { … }      
39.      void alarm() { … }      
40. }      
41.     
42.        
43. 或者      
44.     
45. class AlarmDoor implements Door ｛      
46.      void open() { … }      
47.      void close() { … }      
48.      void alarm() { … }      
49. ｝      
50.   
51. class AlarmDoor extends Door {      
52.      void open() { … }      
53.      void close() { … }      
54.     void alarm() { … }      
55. }      
56.     
57.        
58. 或者      
59.     
60. class AlarmDoor implements Door ｛      
61.  void open() { … }      
62.  void close() { … }      
63.  void alarm() { … }      
64. ｝      

这种方法违反了面向对象设计中的一个核心原则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]  view plain copy print ?

1. abstract class Door {      
2.      abstract void open();      
3.      abstract void close()；      
4. }      
5. interface Alarm {      
6.      void alarm();      
7. }      
8. class AlarmDoor extends Door implements Alarm {      
9.      void open() { … }      
10.     void close() { … }      
11.       void alarm() { … }      
12. }      

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


结论  


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