Java学习之抽象类和接口区别比较

布满荆棘的人生 2022-08-04 14:49 166阅读 0赞

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

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

新建抽象类AbstractTest：

public abstract class AbstractTest { 
        
         
        
         String name; 
        
         public String pub_name; 
        
         protected String prot_name; 
        
         private String pri_name; 
        
         
        
         static String sName; 
        
         public static String sPub_name; 
        
         protected static String sProt_name; 
        
         private static String sPri_name; 
        
         
        
         final String FNAME = "fname"; 
        
         public final String FPUB_NAME = "fpub_name"; 
        
         protected final String FPROT_NAME = "fprot_name"; 
        
         private final String FPRI_NAME = "fpri_name"; 
        
         
        
         static final String sFNAME = "fname"; 
        
         public static final String sFPUB_NAME = "fpub_name"; 
        
         protected static final String sFPROT_NAME = "fprot_name"; 
        
         private static final String sFPRI_NAME = "fpri_name"; 
        
         
        
         }

新建接口InterfaceTest：

public interface InterfaceTest { 
        
           
        
         String name; 
        
         public String pub_name; 
        
         protected String prot_name; 
        
         private String pri_name; 
        
         
        
         static String sName; 
        
         public static String sPub_name; 
        
         protected static String sProt_name; 
        
         private static String sPri_name; 
        
         
        
         final String FNAME = "fname"; 
        
         public final String FPUB_NAME = "fpub_name"; 
        
         protected final String FPROT_NAME = "fprot_name"; 
        
         private final String FPRI_NAME = "fpri_name"; 
        
         
        
         static final String sFNAME = "fname"; 
        
         public static final String sFPUB_NAME = "fpub_name"; 
        
         protected static final String sFPROT_NAME = "fprot_name"; 
        
         private static final String sFPRI_NAME = "fpri_name"; 
        
         }

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

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

修改接口InterfaceTest代码如下：

public interface InterfaceTest { 
        
           
        
         String name; 
        
         public String pub_name; 
        
         /* protected String prot_name; 
        
         private String pri_name;*/ 
        
         
        
         static String sName; 
        
         public static String sPub_name; 
        
         /* protected static String sProt_name; 
        
         private static String sPri_name;*/ 
        
         
        
         final String FNAME = "fname"; 
        
         public final String FPUB_NAME = "fpub_name"; 
        
         /* protected final String FPROT_NAME = "fprot_name"; 
        
         private final String FPRI_NAME = "fpri_name";*/ 
        
         
        
         static final String sFNAME = "fname"; 
        
         public static final String sFPUB_NAME = "fpub_name"; 
        
         /*protected static final String sFPROT_NAME = "fprot_name"; 
        
         private static final String sFPRI_NAME = "fpri_name";*/ 
        
         
        
         }

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

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

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

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

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

## **第二个区别（构造方法）** ##

抽象类AbstractTest添加如下代码;

public AbstractTest() { 
        
         
        
         }

接口也添加构造方法：

public InterfaceTest() { 
        
         
        
         }

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

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

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

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

抽象类AbstractTest添加如下代码;

protected AbstractTest() { 
        
         
        
         } 
        
         
        
         protected void AbstractTest() { 
        
         
        
         }

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

接口InterfaceTest添加如下代码：

public void InterfaceTest() { 
         
          int a; 
         
          int b; 
         
          int c = a + b; 
         
          }

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

修改后如下：

public void InterfaceTest();

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

修改InterfaceTest方法的访问权限：

protected void InterfaceTest();

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

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

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

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

## **第四个区别（静态方法）** ##

抽象类AbstractTest添加静态方法：

protected static void staticAbstractTest() { 
        
         
        
         }

接口也添加静态方法：

public static void InterfaceTest();

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

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

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

## **第五个区别（final方法）** ##

抽象类AbstractTest添加final方法：

protected final void fAbstractTest() { 
        
         
        
         }

接口也添加final方法：

public final void InterfaceTest();

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

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

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

## **第六个区别(抽象方法）** ##

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

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

## **第七个区别（继承性）** ##

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

public class InheritanceTest extends AbstractTest, AbstractTest2 { 
        
           
        
         @Override 
        
         public void Abstract() { 
        
         // 继承自抽象类中的抽象方法 
        
         
        
         } 
        
           
        
         }

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

修改如下：

public class InheritanceTest extends AbstractTest implements InterfaceTest, InterfaceTest2 { 
        
           
        
         @Override 
        
         public void Abstract() { 
        
         // 继承自抽象类中的抽象方法 
        
         
        
         } 
        
           
        
         }

编译通过。

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

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

如有疏漏或其他问题，欢迎指出互相交流，谢谢！