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

抽象类（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() {
    
    
    
    

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

     
     		
    
    
    
    

     
     	}
    
    
    
    

     
      
    
    
    
    

     
     }
    
    
   
   

编译通过。

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

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

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