Interface 接口详解

简介

接口主要用来描述类具有哪些功能，并不给出每个功能的具体实现方式。一个类可以实现一个或多个接口，并在需要接口的地方，随时使用实现了响应接口的对象。

在 Java 程序设计语言中，接口不是类，而是对类的一组需求描述，这些类要遵循接口描述的统一格式进行定义。

接口中的所有方法自动属于 public，所以在接口中声明方法可以不用提供关键字 public 。

类实现接口，通常有两个步骤：

1. 将类声明为实现指定的接口
2. 对接口中的所有方法进行定义

要将类声明为实现某个接口，需要使用关键字 implements :

public interface Comparable{ int compareTo(Object other);}
class Employee implements Comparable{}

接口特性

接口不是类，尤其不能使用 new 运算符实例化一个接口。但是可以声明接口的变量，接口变量必须引用实现该接口的类对象。

X = new Comparable(...); //Error

Comparable x; // OK
x = new Employee(); // OK

与可以建立类的继承关系一样，接口也可以被扩展。这里允许存在多条从较高通用性的接口道较高专用型的忌口的链。

public interface Moveable{ void move(double x,double y);}
public interface Powerd extends Moveable{ double milesPerGallon();}

虽然在接口中不能包含实例域或静态方法，但可以包含常量。

public interface Powerd extends Moveable{ 
    double milesPerGallon();
    double SPEED_LIMIT = 95;
    }

与接口中的方法都自动地被设置为 public 一样，接口中的域将自动设为 public static final 。

接口与抽象类

使用抽象类表示通用属性存在一个问题 ：每个类只能扩展一个类。但是每个类可以实现多个接口。

静态方法

在 Java SE 8 中，允许在接口中增加静态方法。理论上，没有任何理由认为这是不合适的，只是这有违于将接口最为抽象规范的初衷。

public interface Path{
    public static Path get(String first,String... more){
        return FileSystems.getDefault().getPath(first,more);
    }
    ...
}

默认方法

可以为接口方法提供一个默认实现。必须用 default 修饰符标记这样的方法。

public interface Comparable<T>{
    default int compareTo(T other){ 
        return 0; // 默认情况下，所有的数据都相等
    }
}

这样可能没有什么用，因为 Comparable 的每一个实现都要覆盖这个方法。但是在某些情况下，默认方法可能很有用。例如：

public interface Collection{
    int size();
    default boolean isEmpty(){
        return size() == 0;
    }
    ...
}

这样在实现 Collection 的程序员就不用操心实现 isEmpty 方法了。

默认方法的一个重要用法是 “接口演化”。例， Collection 接口作为 Java 的一部分已经很多年了，在 Java SE 8中，为这个接口添加了一个 stream 方法。假设 stream 不是默认方法，那么引用 Collection 接口的类将不能编译，因为没有实现这个新方法。为接口增加一个非默认方法不能保证 “源代码兼容”。

不过，假设不重新编译这个类，而只是使用原先的一个包含这个类的 JAR 文件。这个类仍可以正常加载，尽管没有这个新方法。但是，如果程序在一个该类的实例上调用 stream 方法，就会出现一个 AbstractMethodError。

默认方法可以解决这些问题。如果没有重新编译而直接加载这个类，并在一个实例上调用 stream 方法，将调用 Collection stream 方法。

解决默认方法冲突

如果现在一个接口中将一个方法定义为默认方法，然后又在超类或者另一个接口中定义了同样的方法。会发生什么？Java对应的规则比较简单：

1. 超类优先。如果超类提供了一个具体方法，接口中同名并且有相同参数类型的默认方法会被忽略。
2. 接口冲突。如果一个超接口提供了一个某人方法，另一个接口提供了一个同名而且参数类型相同的方法，必须覆盖这个方法来解决冲突。

public interface Named{
    default String getName(){
        return getClass().getName()+"_"+hashCode();
    }
}

Class Student implements Person,Named{
    ...
}

类会继承 Person 和 Named 接口提供的两个不一致的 getName 方法。并不是从中选择一个，Java 编译器会报告一个错误，让程序员来解决这个二义性。只需要在 Student 类中提供一个 getName 方法，在这个方法中，可以选择两个冲突方法中的一个。

Class Student implements Person,Named{
    public String getName(){ return Person.super.getName();}
    ...
}

接口示例

接口与回调

回调是一种常见的程序设计模式。在这种模式中，可以指出某个特定事件发生时应该采取的行动。

例如：程序中有一个时钟，每隔十秒钟报一次时。

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Date;
import javax.swing.*;

public class TimerTest {
    public static void main(String[] args) {
        ActionListener listener = new TimePrinter();

        Timer t = new Timer(10000, listener);
        t.start();
        JOptionPane.showMessageDialog(null, "Quit program?");
        System.exit(0);
    }
}

class TimePrinter implements ActionListener {

    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("At the tone, the time is " + new Date());
        Toolkit.getDefaultToolkit().beep();
    }
}

对象克隆

Cloneable 接口指示一个类提供了一个安全的 clone 方法。clone 产生的对象是一个新对象，它的初始状态与源对象相同，但是之后他们各自会有自己不同的状态。

不过， clone 方法是 Object 的一个 protected 方法，这说明你的代码不能直接调用这个方法。只有 Employee 类可以克隆 Employee 对象。

默认的克隆操作是“浅拷贝”，并没有克隆对象中引用的的其他对象。如果源对象和浅克隆对象共享的子对象是不可变的，这种共享就是安全的。如果子对象属于一个不可变的类，如 String ，这种共享是安全的。或者在对象的声明周期中，子对象一只包含不变的常量，没有更改器方法会改变它，也没有方法会生成它的引用，这种情况下同样是安全的。


不过，通常子对象都是可变的，必须重新定义 clone 方法来建立一个深拷贝，同时克隆所有子对象。

对于每一个类，需要确定：

1. 默认的 clone 方法是否满足要求
2. 是否可以在可变的子对象上调用 clone 来修补默认的 clone 方法
3. 是否不改使用 clone

实际上第 3 个选项是默认选项。如果选择第 1 项或第 2 项，类必须:

1. 实现 Cloneable 接口
2. 重新定义 clone 方法,并指定 public 访问修饰符

Tips:

Object 类中的 clone 方法声明为 protected,子类只能调用受保护的 clone 方法来克隆自己的对象。必须重新定义 clone 为 public 才能允许所有方法克隆对象。

Cloneable 接口没有指定 clone 方法，这个方法是从 Object 类继承的。这个接口指示作为一个标记，指示类设计者了解克隆过程。标记接口不包含任何方法，它的唯一作用就是允许在类型查询中使用 instanceof。

即使 clone 的默认（浅拷贝）实现能满足要求，还是需要实现 Cloneable 接口，将 clone 重新定义为 public，再调用 super.clone()。

class Employee implements Cloneable{
    public Employee clone() throws CloneNotSupportedException{
        return (Employee) super.clone();
    }
    ...
}

与 Object.clone 提供的浅拷贝相比，这个 clone 方法并没有为它添加任何工嗯呢该。只是让这个方法是公有的。要建立深拷贝，还需要做很多工作，克隆对象中可变的实例域。

class Employee implements Cloneable{
    public Employee clone() throws CloneNotSupportedException{
        Employee cloned =  (Employee) super.clone();
        cloned.hireDay = (Date) hireDay.clone();
        return cloned;
    }
    ...
}

如果在一个对象上调用 clone，但这个对象的类并没有实现 Cloneable 接口，Object 类的 clone 方法就会抛出一个 CloneNotSupportedException。

捕捉这个异常是不是更好一些？这非常适合 final 类。否则，还是保留 throws 说明符。这样就允许子类在不支持克隆时选择抛出一个 CloneNotSupportedException。

要不要在自己的类中实现 clone 呢？如果你的客户端需要建立深拷贝，可能就需要实现这个方法。

Tips：

所有数组类型都有一个 public 的 clone 方法，而不是 protected。可以用这个方法建立一个新数据，包含原数组所有元素的副本。