抽象类（Abstract） && 接口（Interface）区别比较

第一个区别（变量&常量&修饰符）

 

新建抽象类AbstractTest：

publicabstractclassAbstractTest{

      

       String name;

       publicString pub_name;

       protectedString prot_name;

       privateString pri_name;

      

       staticString sName;

       publicstaticString sPub_name;

       protectedstaticString sProt_name;

       privatestaticString sPri_name;

      

       finalString FNAME="fname";

       publicfinalString FPUB_NAME="fpub_name";

       protectedfinalString FPROT_NAME="fprot_name";

       privatefinalString FPRI_NAME="fpri_name";

      

       staticfinalString sFNAME="fname";

       publicstaticfinalString sFPUB_NAME="fpub_name";

       protectedstaticfinalString sFPROT_NAME="fprot_name";

       privatestaticfinalString sFPRI_NAME="fpri_name";

      

}

 

新建接口InterfaceTest：

publicinterfaceInterfaceTest{

 

       String name;

       publicString pub_name;

       protectedStringprot_name;

       privateStringpri_name;

      

       staticString sName;

       publicstaticString sPub_name;

       protectedstaticStringsProt_name;

       privatestaticStringsPri_name;

      

       finalString FNAME="fname";

       publicfinalString FPUB_NAME="fpub_name";

       protectedfinalString FPROT_NAME="fprot_name";

       privatefinalString FPRI_NAME="fpri_name";

      

       staticfinalString sFNAME="fname";

       publicstaticfinalString sFPUB_NAME="fpub_name";

       protectedstaticfinalString sFPROT_NAME="fprot_name";

       privatestaticfinalString sFPRI_NAME="fpri_name";

}

 

下划线表示该处编译器提示报错，下面不再说明。

 

接口InterfaceTest中的错误处编译器都提示：InterfaceTest接口有非法修饰的字段;只有public、static&final被允许作为修饰符。

 

修改接口InterfaceTest代码如下：

publicinterfaceInterfaceTest{

 

       Stringname;

       publicStringpub_name;

/*     protected String prot_name;

       private String pri_name;*/

      

       staticStringsName;

       publicstaticStringsPub_name;

/*     protected static StringsProt_name;

       private static StringsPri_name;*/

      

       finalString FNAME="fname";

       publicfinalString FPUB_NAME="fpub_name";

/*     protected final StringFPROT_NAME = "fprot_name";

       private final String FPRI_NAME= "fpri_name";*/

      

       staticfinalString sFNAME="fname";

       publicstaticfinalString sFPUB_NAME="fpub_name";

       /*protected static final String sFPROT_NAME= "fprot_name";

       private static final StringsFPRI_NAME = "fpri_name";*/

      

}

 

可以看到，注释了上面编译器报错的代码，但还是有提示报错：空白final字段 pub_name 尚未初始化。

 

由此可知，接口的成员变量默认是final修饰的常量，是必须要初始化的。换句话说，接口不能有普通成员变量。

 

由以上代码的比较可以看出，抽象类与接口的第一个区别：

 

抽象类可以有成员变量、静态成员变量、常量和静态常量（常量必须被初始化），而且无访问权限限制；

接口不能有成员变量、静态成员变量，可以有由public、static&final修饰的常量。

 

第二个区别（构造方法）

 

抽象类AbstractTest添加如下代码;

       publicAbstractTest(){

             

       }

 

接口也添加构造方法：

       publicInterfaceTest(){

             

       }

 

编译器提示接口不能有构造方法。

 

由此得出抽象类与接口的第二个区别：

 

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

 

第三个区别（方法名&方法体&修饰符）

 

抽象类AbstractTest添加如下代码;

       protectedAbstractTest(){

             

       }

      

       protectedvoidAbstractTest(){

                   

       }

 

 

可以看到，方法名与抽象类名相同，编译器没有报错，另外无论修改构造方法的访问级别为private还是默认级别都没报错。

 

接口InterfaceTest添加如下代码：

       publicvoidInterfaceTest(){

              int a;

              int b;

              int c= a+ b;

       }

 

编译器提示：抽象方法不用指定一个方法体。

 

修改后如下：

publicvoidInterfaceTest();

 

这时编译器不报错了。而且方法名与接口名相同。

 

修改InterfaceTest方法的访问权限：

protectedvoidInterfaceTest();

 

编译器报错，提示：非法的修饰符，接口方法的修饰符仅允许public和abstract。

 

由此得出，抽象类与接口的第三个区别：

 

抽象类和接口的方法名可以和类名可以相同，但抽象方法的访问权限没有限制，而接口方法的访问权限修饰符仅允许public和abstract，默认为public。

且抽象类中的方法可以有方法体（没有方法体的方法需要abstract修饰），而接口中的方法不能有方法体。

 

第四个区别（静态方法）

 

抽象类AbstractTest添加静态方法：

protectedstaticvoid staticAbstractTest(){

             

}

 

接口也添加静态方法：

publicstaticvoidInterfaceTest();

 

编译器报错，提示：接口中的方法有非法修饰符，仅允许public&abstract。

 

由此得出，抽象类和接口的第四个区别：

 

抽象类中可以包含静态方法，而接口中不可以包含静态方法。

 

第五个区别（final方法）

 

抽象类AbstractTest添加final方法：

       protectedfinalvoid fAbstractTest(){

             

       }

 

接口也添加final方法：

       publicfinalvoidInterfaceTest();

 

编译器报错，提示：接口中的方法有非法修饰符，仅允许public&abstract。

 

与第四个区别综合得出，抽象类和接口的第五个区别：

抽象类中的普通方法可以被static和final修饰，而接口中的方法则不能被static和final修饰。

 

第六个区别(抽象方法）

 

由第二个到第五个区别可以得出如下结论：

 

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

第七个区别（继承性）

 

分别copy抽象类和接口，粘贴其副本分别为AbstractTest2、InterfaceTest2，新建类InheritanceTest：

 

publicclassInheritanceTestextendsAbstractTest,AbstractTest2{

 

       @Override

       publicvoidAbstract(){

              //继承自抽象类中的抽象方法

             

       }

 

}

 

编译器报错，提示：语法错误。

 

修改如下：

publicclassInheritanceTestextendsAbstractTestimplementsInterfaceTest,InterfaceTest2{

 

       @Override

       publicvoidAbstract(){

              //继承自抽象类中的抽象方法

             

       }

 

}

 

编译通过。

 

由此得出抽象类和接口的第六个区别：

 

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