Java接口

接口介绍

接口（Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常用关键字interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口中包含的成员，最常见的有全局常量、抽象方法。

接口中有抽象方法，说明接口不可以实例化。接口的子类必须实现了接口中所有的抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

接口和类不一样的地方，就是接口可以被多实现，这就是多继承改良后的结果。java将多继承机制通过多现实来体现。

一个类在继承另一个类的同时，还可以实现多个接口。所以接口的出现避免了单继承的局限性。还可以将类进行功能的扩展。其实java中是有多继承的，接口与接口之间存在着继承关系，接口可以多继承接口。

 

接口都用于设计上，设计上的特点：（可以理解主板上提供的接口）

1）接口是对外提供的规则。

2）接口是功能的扩展。

3）接口的出现降低了耦合性。

 

接口的特性

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

JDK1.8之前，接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。从JDK1.8开始，允许给接口添加两种非抽象的方法实现：默认方法和静态方法。

 

接口与类的相似点：

1）一个接口可以有多个方法。

2）接口文件保存在 .java 结尾的文件中，文件名使用接口名。

3）接口的字节码文件保存在 .class 结尾的文件中。

4）接口相应的字节码文件必须在与包名称相匹配的目录结构中。

 

接口与类的区别：

1）接口不能用于实例化对象。

2）接口没有构造方法。

3）接口中所有的方法必须是抽象方法（JDK1.8之前）。

4）接口不能包含成员变量，除了 static 和 final 变量。

5）接口不是被类继承了，而是要被类实现。

6）接口支持多继承。

 

抽象类与接口

抽象类：一般用于描述一个体系单元，将一组共性内容进行抽取，特点：可以在类中定义抽象内容让子类实现，可以定义非抽象内容让子类直接使用。它里面定义的都是一些体系中的基本内容。

接口：一般用于定义对象的扩展功能，是在继承之外还需这个对象具备的一些功能。

 

抽象类和接口的共性：

都是不断向上抽取的结果。

 

抽象类和接口的区别：

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

2）接口中所有的方法隐含的都是抽象的，而抽象类则可以同时包含抽象和非抽象的方法。

3）类如果要实现一个接口，它必须要实现接口声明的所有方法。但是，类可以不实现抽象类声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。

4）抽象类可以在不提供接口方法实现的情况下实现接口。

5）Java接口中声明的变量默认都是 final 的。抽象类可以包含非 final 的变量。

6）Java接口中的成员函数默认是public的。抽象类的成员函数可以是private，protected或者是public。

7）接口是绝对抽象的，不可以被实例化。抽象类也不可以被实例化，但是，如果它包含 main方法的话是可以被调用的。

8）抽象类使用的是  is a 关系。  接口使用的 like a 关系。

9） 接口中不能含有静态代码块，而抽象类是可以有静态代码块。

 

什么时候使用抽象类和接口?

如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。

如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。

如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。

 

接口的声明

接口的声明语法格式如下：

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

Interface关键字用来声明一个接口。下面是接口声明的一个简单例子：

/**
 * 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
 * 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
 * 接口中的方法都是公有的。
 */
public interface Animal {
    public void eat(); 
    public void run();
}

在 JDK1.8之前，接口里面不能包含方法具体实现。从JDK1.8开始，允许我们给接口添加两种非抽象的方法实现：

1）默认方法，添加 default 修饰即可；

2）静态方法，使用 static 修饰；

在以下示例中，静态方法只能通过接口名调用，不可以通过实现类的类名或者实现类的对象调用，default 方法只能通过接口实现类的对象来调用。

interface Test{
    //这个是默认方法
    default String defaultMethod(String aa){
        System.out.println("我是jdk1.8默认实现方法...");
        return "";
    }   
    //这个是静态方法    
    static void staticMethod(){
        System.out.println("我是静态方法");
    }
}

 

接口的实现

类与类之间存在着继承关系，类与接口中间存在的是实现关系。当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。实现一个接口的语法，可以使用这个公式：

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

下面举例实现上面声明的Animal接口：

public class Lion implements Animal{ // 一个类可以同时实现多个接口
   // 重写接口Animal中的eat方法
   public void eat(){
      System.out.println("Lion eats");
   }
   // 重写接口Animal中的run方法
   public void run(){
      System.out.println("Lion runs");
   }  
   // Lion自己声明的方法
   public int numOfLegs(){
      return 4;
   } 
   public static void main(String args[]){
      Lion lion = new Lion();
      lion.eat();  // Lion eats
      lion.run();  // Lion runs
   }
}

重写接口中声明的方法时，需要注意以下规则：

1）类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。

2）类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。

3）如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

 

接口的继承

一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。下面的Sports接口被Hockey和Football接口继承：

// 文件名: Sports.java
public interface Sports {
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}
 
// 文件名: Football.java
public interface Football extends Sports {
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}
 
// 文件名: Hockey.java
public interface Hockey extends Sports {
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

以上示例中，Hockey接口自己声明了四个方法，从Sports接口继承了两个方法，这样，实现Hockey接口的类需要实现六个方法。相似的，实现Football接口的类需要实现五个方法，其中两个来自于Sports接口。

 

接口的多继承

在Java中，类的多继承是不合法，但接口允许多继承。在接口的多继承中extends关键字只需要使用一次，在其后跟着继承接口。 如下所示：

public interface Hockey extends Sports, Event

以上的程序片段是合法定义的子接口，与类不同的是，接口允许多继承，而 Sports及 Event 可能定义或是继承相同的方法。

 

标记接口（标识接口）

最常用的继承接口是没有包含任何方法的接口。标记接口是没有任何方法和属性的接口，它仅仅表明它的类属于一个特定的类型，供其他代码来测试允许做一些事情。

标记接口作用：简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。

例如：java.util.EventListener 接口定义如下：

package java.util;
public interface EventListener {
}

标记接口主要用于以下两种目的：

1）建立一个公共的父接口：

正如EventListener接口，这是由几十个其他接口扩展的Java API，我们可以使用一个标记接口来建立一组接口的父接口。例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。

2）向一个类添加数据类型：

这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，但是该类通过多态性变成一个接口类型。

 

使用标记接口使得可以用 instanceof 进行类型查询，例如：

if(obj instanceof Cloneable) {………} 

一些容器例如 Ejb 容器、servlet 容器或运行时环境依赖标记接口识别类是否需要进行某种处理，比如 serialialbe 接口标记类需要进行序列化操作。

 java.io.Serializable：未实现此接口的类将无法使其任何状态序列化或反序列化。为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。

java.lang.Cloneable：表明 Object.clone() 方法可以合法地对该类实例进行按字段复制.实现此接口的类应该使用公共方法重写 Object.clone（它是受保护的）。如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法，则会导致抛出 CloneNotSupportedException 异常。

 java.util.RandomAccess：用来表明其支持快速（通常是固定时间）随机访问。此接口的主要目的是允许一般的算法更改其行为，从而在将其应用到随机或连续访问列表时能提供良好的性能。

java.rmi.Remote：Remote 接口用于标识其方法可以从非本地虚拟机上调用的接口。任何远程对象都必须直接或间接实现此接口。只有在“远程接口”（扩展 java.rmi.Remote 的接口）中指定的这些方法才可远程使用。