1.接口的概念

　　在Java中，接口不是类，而是对类的一组需求描述，这些类要遵从接口描述。

　　例如：Array类中的sort方法可以对对象数组进行排序，但要求满足下列前提：对象所属的类必须实现了Comparable接口。

　　Comparable接口的代码：任何实现了Comparable接口的类都必须包含compareTo方法。

public interface Comparable
     
       {    /**     * Compares this object with the specified object for order.  Returns a     * negative integer, zero, or a positive integer as this object is less     * than, equal to, or greater than the specified object.     *     * @param   o the object to be compared.     * @return  a negative integer, zero, or a positive integer as this object     *          is less than, equal to, or greater than the specified object.     *     * @throws NullPointerException if the specified object is null     * @throws ClassCastException if the specified object's type prevents it     *         from being compared to this object.     */    public int compareTo(T o);}
     

　　接口中的所有方法自动地属于public，因此，在接口中声明方法时，不必提供关键字public。在实现接口时，必须把方法声明为public。

　　接口没有实例，在接口中可以定义常量，也可以定义简单方法，但是这些方法不能引用实例域。

　　提供实例域和方法实现的任务应该由实现接口的那个类来完成，因此，可以将接口看成是没有实例域的抽象类。

　　如果希望用Array类的sort方法对Employee对象数组进行排序，那么Employee类就必须实现Comparable接口。

public class Employee implements Comparable
     
      {...   public int compareTo(Employee other)   {      return Double.compare(salary, other.salary);　　// 使用静态的compare方法，大于等于小于时分别返回1，-1,0   }}
     

　　为什么不可以直接在Employee类中直接提供compareTo方法而不实现Comparable接口呢：这是因为Java是一种强类型（strongly typed）语言。在调用方法的时候，编译器会检查这个方法是否存在。

　　Array类中的sort方法中的ComparableTimSort限制了必须有compareTo方法，从而限制了必须实现Comparable接口。

public static void sort(Object[] a) {        if (LegacyMergeSort.userRequested)            legacyMergeSort(a);        else            ComparableTimSort.sort(a, 0, a.length, null, 0, 0);    }

 

　　2.接口的特性

　　（1）接口不是类，不能使用new实例化一个接口

　　（2）尽管不能构造接口的对象，但能声明接口的变量，接口变量必须引用实现了接口的类对象。也可以使用instanceof检查一个对象是否实现了某个特定的接口。

Comparable x;x = new Employee(...); if (x instanceOf Comparable) ...

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

　　例如：首先建立一个称为Moveable的接口

package test;public interface Moveable {    void move(double x, double y);}

　　然后建立一个称为Powered的接口，使得这个接口继承Moveable接口：这里注意的是，虽然接口中不能包含实例域，但是却可以包含常量，与接口中的方法自动地被设置成public一样，接口中的域将被自动地设置为public static final。任何实现Powered接口的类都自动地继承了这些常量，并且可在方法中直接引用SPEED_LIMIT这个常量，而不用写成Powered.SPEED_LIMIT这种形式。

package test;public interface Powered extends Moveable{    double SPEED_LIMIT = 95;    double milesPerGallon();}

　　任何实现了Powered 接口的类都必须实现move方法和milesPerGallon方法：

package test;public class Imp implements Powered{    @Override    public void move(double x, double y) {        // TODO Auto-generated method stub            }    @Override    public double milesPerGallon() {        // TODO Auto-generated method stub        return 0;    }}

 

　　3.接口的好处

　　前面提到过的Comparable接口也可以用抽象类来表示，接口实现关系也可以用继承来实现，例如：

package test;public abstract class Comparable
     
       {        public abstract int compareTo(T o);}
     

　　Employee类来继承Comparable抽象方法后必须也必须实现compareTo方法：

package test;public class Employee extends Comparable
     
      {    @Override    public int compareTo(Employee o) {        // TODO Auto-generated method stub        return 0;    }}
     

　　这看起来似乎没有什么问题，但是，使用抽象类表示通用属性的时候，每个类只能扩展于一个类，即每个类只能单继承。而接口的好处是，每个类可以同时实现很多个接口。接口可以提供多重继承的大多数好处，同时还能避免多重继承的复杂性和低效性。

 

　　4.在接口中增加静态方法和默认方法

　　（1）在接口中增加静态方法

　　Java SE 8 允许在接口中增加静态方法：例如，在Moveable接口中提供了静态方法move，

package test;public interface Moveable {    static void move(double x, double y) {        System.out.println(x*y);    };}

　　任何继承Moveable的类不用去实现move静态方法，并且可以直接调用move方法：

package test;public class Imp implements Moveable{    public static void main(String[] args) {        Moveable.move(10.0, 10.0);　　　　　　// 打印：100.0    }}

　　（2）在接口中增加默认方法

　　可以为接口中的方法提供一个默认实现，用default修饰符标记这样一个方法，例如，Moveable接口中有两个方法，其中move方法标记为默认方法并且实现：

package test;public interface Moveable {    int size();    default double move(double x, double y) {        return x*y;    }}

　　任何继承Moveable接口的方法，如果没有重写move方法，那么就默认该类具有接口中的默认方法。

package test;public class Imp implements Moveable{    @Override    public int size() {        // TODO Auto-generated method stub        return 0;    }    public static void main(String[] args) {        Imp test = new Imp();        System.out.println(test.move(10.0, 10.0));　　// 打印：100.0    }}

　　如果在继承Moveable接口的方法中重写了默认方法，则以重写的方法为准：

package test;public class Imp implements Moveable{    @Override    public int size() {        // TODO Auto-generated method stub        return 0;    }        @Override    public double move(double x, double y) {        // TODO Auto-generated method stub        return x + y;    }    public static void main(String[] args) {        Imp test = new Imp();        System.out.println(test.move(10.0, 10.0));　　// 打印：20.0    }}

　　默认方法还可以调用任何其他方法，例如，调用同一个接口中的其他方法：

package test;public interface Moveable {    int size();    default boolean move(double x, double y) {        return size() == 0;    }}

　　任何实现Moveable接口的方法都必须实现size方法，并且还拥有move方法的默认实现：

package test;public class Imp implements Moveable{    @Override    public int size() {        // TODO Auto-generated method stub        return 0;    }    public static void main(String[] args) {        Imp test = new Imp();        System.out.println(test.move(0.0, 100.0));　　// 打印：true    }}

 

　　5.默认方法冲突的解决方法

　　如果先在一个接口中将一个方法定义为默认方法，然后又在父类或者另一个接口中定义了同样的方法，那么该如何选择：

　　（1）父类优先。如果父类提供了一个具体方法，同时接口中提供了相同的默认方法，则接口中的默认方法会被忽略。

　　（2）接口冲突时要重写。如果两个接口都提供一个相同的默认方法，则同时实现这两个接口的类必须重写这个方法。