abstract class 和 interface 区别

相信这个问题一定困扰不少小伙伴，今天来谈谈自己的理解

首先从概念上来区分

abstract class ：就是抽象类，用关键字abstract来修饰的类称为抽象类（abstractclass）

interface：用interface关键字来修饰的称为接口。

进入正题：

抽象类：

抽象类和抽象方法都通过abstract关键字来修饰

抽象类不能实例化，抽象类中可以没有，可以有一个或多个抽象方法，甚至可以全部都是抽象方法。

抽象方法只有方法声明没有方法实现，在抽象方法的类必须声明为抽象类，子类必须实现所有的抽象方法才能实例化，否则子类还是一个抽象类。

Abstract可以用来修饰类和方法，但是不能修饰属性和抽象方法。

抽象类仅去声明，而不去实现，用于创建一个体现具体某些基本行为的类，并为该类声明方法，但不在该类中具体实现，

不可以创建实例，但可以创建一个变量，让它指向具体子类的一个实例。

不能有构造函数和静态方法，子类为父类中的所有抽象方法提供实现。

一个抽象类只能使用一次继承关系，但可以通过继承多个接口（interface）实现多重继承。

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。
不能创建abstract 类的实例。
然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。
不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。
取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

接口：

关键字：interface

实现接口：implement

Ø 接口和类，抽象类是一个层次的概念，命名规则相同，如果修饰符是public 则该接口在整个项目中可见，如果省略修饰符，则该接口只在当前包可见。

Ø 接口中可以定义常量，不能定义变量，接口中属性都是自动调用public static final修饰，即接口中的属性都是全局静态常量，接口中的常量必须在定义时指定初始值。

Ø 接口中所有方法都是抽象方法，接口中方法都会自动用public abstract 修饰，即接口中只有全局抽象方法。

Ø 和抽象类一样，接口同样不能实例化，不能有构造方法。

Ø 接口之间可以通过extends 实现继承关系，一个接口可以继承多个接口，但是接口不能继承类。

Ø 一个类只能有一个父类，但可以通过implement实现多个接口，类必须实现接口的全部方法，否则必须定义为抽象类，类在继承父类的同时又实现了多个接口，extends 必须位于implement之前。

接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。

多继承性可通过实现 这样的接口而获得。

接口中的所有方法都是抽象的，没有一个有程序体。

接口只可以定义static final成员变量。

接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。

当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。 

然后，它可以在实现了该接口的类的任何对象上调用接口的方法。

由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。

引用可以转换到 接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。


接口可以继承接口。

抽象类可以实现(implements)接口，抽象类是可以继承实体类，但前提是实体类必须有明确的构造函数。

接口更关注“能实现什么功能”，而不管“怎么实现的”。

接口：表示一种约定

接口：表示一种能力

JAVA和C#接口区别：

Ø JAVA中接口通过extends继承父接口，类通过implement 实现接口，C#中通过“：”号来实现这两个功能。

Ø JAVA接口中的成员变量(属性)一律是常量，自动用public static final 修饰，C#接口中不允许存在成员变量，但可以有属性。

Ø JAVA接口中属性和方法都可以使用public修饰，C#中默认public，但不允许显式使用public修饰。

Ø JAVA接口中可以定义静态常量和方法，但是C#接口中不允许包含任何静态成员。

含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。

下面比较一下两者的语法区别：

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有普通成员变量，接口中没有普通成员变量

3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

5. 抽象类中可以包含静态方法，接口中不能包含静态方法

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

7. 一个类可以实现多个接口，但只能继承一个抽象类。

     下面接着再说说两者在应用上的区别：

    接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。

    而抽象类在代码实现方面发挥作用，可以实现代码的重用，例如，模板方法设计模式是抽象类的一个典型应用，假设某个项目的所有 Servlet类都要用相同的方式进行权限判断、记录访问日志和处理异常，那么就可以定义一个抽象的基类，让所有的 Servlet都继承这个抽象基类，在抽象基类的 service方法中完成权限判断、记录访问日志和处理异常的代码，在各个子类中只是完成各自的业务逻辑代码，伪代码如下：

import java.io.IOException; import javax.servlet.ServletException; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public abstract class BaseServlet extends HttpServlet {     public final void service(HttpServletRequest request, HttpServletResponse response) throws IOException,ServletException     {         //记录访问日志         //进行权限判断         if(具有权限)         {             try             {                 doService(request,response);             }             catch(Exception e)             {                 记录异常信息             }         }     }     // 注意访问权限定义成protected，显得既专业，又严谨，因为它是专门给子类用的     protected abstract void doService(HttpServletRequest request,HttpServletResponse response) throws IOException,ServletException; }

子类:

public class MyServlet1 extends BaseServlet {     protected void doService(HttpServletRequest request, HttpServletResponse response) throws IOException,ServletException     {         本Servlet只处理的具体业务逻辑代码     }  }

父类方法中间的某段代码不确定，留给子类干，就用模板方法设计模式。

备注：这道题的思路是先从总体解释抽象类和接口的基本概念，然后再比较两者的语法细节，最后再说两者的应用区别。比较两者语法细节区别的条理是：先从一个类中的构造方法、普通成员变量和方法（包括抽象方法），静态变量和方法，继承性等6个方面逐一去比较回答，接着从第三者继承的角度的回答，特别是最后用了一个典型的例子来展现自己深厚的技术功底。

总结：

JAVA中，abstract class和interface是支持抽象类定义的两种机制，JAVA强大的面向对象能力就是通过这两种机制赋予的。

相同点
  1. 两者都是抽象类，都不能实例化。
  2. interface实现类及abstrct class的子类都必须要实现已经声明的抽象方法。

不同点
  1. interface需要实现，要用implements，而abstract class需要继承，要用extends。
  2. 一个类可以实现多个interface，但一个类只能继承一个abstract class。
  3. interface强调特定功能的实现，而abstract class强调所属关系。 
  4. 尽管interface实现类及abstrct class的子类都必须要实现相应的抽象方法，但实现的形式不同。interface中的每一个方法都是抽象方法，都只是声明的 (declaration, 没有方法体)，实现类必须要实现。而abstract class的子类可以有选择地实现。

  5.abstract class是interface与Class的中介。

（abstract class在interface及Class中起到了承上启下的作用。

一方面，abstract class是抽象的，可以声明抽象方法，以规范子类必须实现的功能；

另一方面，它又可以定义缺省的方法体，供子类直接使用或覆盖。另外，它还可以定义自己 的实例变量，以供子类通过继承来使用。）

interface的应用场合
  1. 类与类之前需要特定的接口进行协调，而不在乎其如何实现。
  2. 作为能够实现特定功能的标识存在，也可以是什么接口方法都没有的纯粹标识。
  3. 需要将一组类视为单一的类，而调用者只通过接口来与这组类发生联系。
  4. 需要实现特定的多项功能，而这些功能之间可能完全没有任何联系。

  5.接口更多的实在系统架构方面发挥作用，主要用于定义模块之间的通信契约。

abstract class的应用场合

  一句话，在既需要统一的接口，又需要实例变量或缺省的方法的情况下，就可以使用它。最常见的有：
  1. 定义了一组接口，但又不想强迫每个实现类都必须实现所有的接口。可以用abstract class定义一组方法体，甚至可以是空方法体，然后由子类选择自己所感兴趣的方法来覆盖。
  2. 某些场合下，只靠纯粹的接口不能满足类与类之间的协调，还必需类中表示状态的变量来区别不同的关系。abstract的中介作用可以很好地满足这一点。
  3. 规范了一组相互协调的方法，其中一些方法是共同的，与状态无关的，可以共享的，无需子类分别实现；而另一些方法却需要各个子类根据自己特定的状态来实现特定的功能。

  4.抽象类在代码实现方面发挥作用，用于实现代码的重用。