Java 抽象类(abstract)、接口(Interface)

概述:在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
    接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
    除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
    接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
   
抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。以JDK中的GenericServlet为例：

在使用抽象类时需要注意几点：
1.抽象类不能被实例化，实例化的工作应该交由它的子类来完成，它只需要有一个引用即可。
2.抽象方法必须由子类来进行重写。
3.只要包含一个抽象方法的抽象类，该方法必须要定义成抽象类，不管是否还包含有其他方法。
4.抽象类中可以包含具体的方法，当然也可以不包含抽象方法。
5.子类中的抽象方法不能与父类的抽象方法同名。
6.abstract不能与final并列修饰同一个类。
7.abstract 不能与private、static、final或native并列修饰同一个方法。

public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {
    // abstract method
    abstract void service(ServletRequest req, ServletResponse res);
 
    void init() {
        // Its implementation
    }
    // other method related to Servlet
}

当HttpServlet类继承GenericServlet时，它提供了service方法的实现：
 
public class HttpServlet extends GenericServlet {
    void service(ServletRequest req, ServletResponse res) {
        // implementation
    }
 
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
        // Implementation
    }
 
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
        // Implementation
    }
 
    // some other methods related to HttpServlet

接口特性
接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。


接口的声明

接口的声明语法格式如下：
[可见度] interface 接口名称 [extends 其他的类名] {
        // 声明变量
        // 抽象方法
}

Interface关键字用来声明一个接口。下面是接口声明的一个简单例子。
NameOfInterface.java 文件代码：
/* 文件名 : NameOfInterface.java */
import java.lang.*;
//引入包
 
public interface NameOfInterface
{
   //任何类型 final, static 字段
   //抽象方法
}

接口中的方法都是抽象方法。
一个接口可以继承其他接口；一个类通过关键字implements声明要实现一个接口，并具体实现接口的方法。
           例如：有一个接口InterfaceA，

Java代码
public   interface  InterfaceA {  
         void  methodA();  
} 
 
           类ClassA实现接口InterfaceA。

Java代码
public   class  ClassA  implements InterfaceA {  
          public   void  methodA() {  
               System.out.println( "methodA of ClassA implements InterfaceA" );  
         }  
} 
 
如果是抽象类实现一个接口，那么抽象类中可以不具体实现接口的方法（保持其抽象性），而由其子类去实现。
           抽象类ClassB实现接口InterfaceA，但是没有具体实现方法methodA()，

Java代码
public   abstract   class  ClassBS  implements InterfaceA{           } 
 
           子类ClassBSub实现接口InterfaceA，但是没有具体实现方法methodA()，

Java代码
public   class  ClassBSub implements InterfaceA{  
         public   void  methodA() {  
              System.out.println( "methodA of ClassBSub the subclass of ClassB" );  
        }  
} 

 

接口和抽象类显著的共同点是接口和抽象类都可以有抽象方法。
接口和抽象类的不同点有：
           (1)抽象类可以有实例变量，而接口不能拥有实例变量，接口中的变量都是静态（static）的常量（final）。
           (2)抽象类可以有非抽象方法，而接口只能有抽象方法。

 

java允许一个接口继承多个父接口，也允许一个类实现多个接口，而这样的多继承有上面提到的缺点马？
答案是没有，这是由接口的抽象性决定的。
正如前面介绍的，在接口中不能有实例变量，只能有静态的常量，不能有具体的方法（包含方法体），只能有抽象方法，因此也就摒弃了多继承的缺点。
对于一个类实现多个接口的情况，因为接口只有抽象方法，具体方法只能由实现接口的类实现，在调用的时候始终只会调用实现类的方法（不存在歧义）， 因此不存在多继承的第二个缺点；而又因为接口只有静态的常量，但是由于静态变量是在编译期决定调用关系的，即使存在一定的冲突也会在编译时提示出错；而引 用静态变量一般直接使用类名或接口名，从而避免产生歧义，因此也不存在多继承的第一个缺点。
对于一个接口继承多个父接口的情况也一样不存在这些缺点。
请看以下示例。
            接口A：

Java代码
public   interface  InterfaceA {  
         int  len =  1 ;  
         void  output();  
} 
 
            接口B：

Java代码
public   interface  InterfaceB {  
           int  len =  2 ;  
           void  output();  
} 
 
            接口InterfaceSub继承接口A和接口B：

Java代码
public   interface  InterfaceSub  extends  InterfaceA, interfaceB {            } 
 
            类Xyz实现接口InterfaceSub：

Java代码
public   class  Xyz  implements  InterfaceSub {  
         public   void  output() {  
                System.out.println( "output in class Xyz." );  
        }  
          public   void  outputLen( int  type) {  
                  switch (type) {  
                          case  InterfaceA.len:  
                                 System.out.println( "len of InterfaceA=." +type);  
                                  break ;  
                          case  InterfaceB.len:  
                                 System.out.println( "len of InterfaceB=." +type);  
                                  break ;  
                 }  
        }  
        public   static   void  main(String[] args) {  
               Xyz xyz=  new  Xyz ();  
               xyz .output();  
               xyz .outputLen();  
       }  
 http://www.itemperor.com/a/JAVA/261.html
原文链接：http://www.jxszl.com/biancheng/JAVA/446613.html