Java-接口

基本概念

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

如果一个类只由抽象方法和全局常量组成，那么这种情况下不会将其定义为一个抽象类。只会定义为一个接口，所以接口严格的来讲属于一个特殊的类，而这个类里面只有抽象方法和全局常量，就连构造方法也没有。

例子，定义一个接口

interface C{//定义一个接口

public static final String MSG = "hello";//全局常量
public abstract void print();//抽象方法

}

接口的使用

1.由于接口里面存在抽象方法，所以接口对象不能直接使用关键字new进行实例化。接口的使用原则如下：
（1）接口必须要有子类，但此时一个子类可以使用implements关键字实现多个接口；
（2）接口的子类（如果不是抽象类），那么必须要覆写接口中的全部抽象方法
（3）接口的对象可以利用子类对象的向上转型进行实例化

举例：

interface C{//定义一个接口

    public static final String MSG = "hello";//全局常量

     public abstract void print();//抽象方法

}

interface D{
    public abstract void get();
}

class X implements C,D{

    @Override
    public void print() {
        System.out.println("接口C的抽象方法print()");
    }

    @Override
    public void get() {
        System.out.println("接口D的抽象方法get()");
    }
}

class TestDemo{
    public static void main(String[] args){
    
        X x = new X();//实例化子类对象
        C a = x;//向上转型
        D b = x;//向上转型
    
        a.print();
        b.get();
    }    
}

运行结果

接口C的抽象方法print()
接口D的抽象方法get()

以上的代码实例化了X类的对象，由于X类是A和B的子类，那么X类的对象可以变为A接口或者B接口对象。我们把测试主类代码改一下

class TestDemo{
    public static void main(String[] args){

       C a = new X();

       D b = (D) a;
       b.get();
    }
}

运行结果为

接口D的抽象方法get()

再做一个验证

class TestDemo{
    public static void main(String[] args){

       C a = new X();

       D b = (D) a;
       b.get();

       System.out.println(a instanceof C);
       System.out.println(a instanceof D);
    }
}

运行结果为

接口D的抽象方法get()
true
true

我们发现，从定义结构来讲，A和B两个接口没有任何直接联系，但这两个接口却拥有同一个子类。我们不要被类型和名称所迷惑，因为实例化的是X子类，而这个类对象属于B类对象，所以以上代码可行，只不过从代码的编写规范来讲，并不是很好。

2.对于子类而言，除了实现接口外，还可以继承抽象类。若既要继承抽象类，同时还要实现接口的话，使用一个语法格式

class 子类 [extends 父类][implements 接口1，接口2]{}

范例

interface E{
    public static String MSG = "hello";

    public abstract void print();//抽象方法
}

interface F{
    public abstract void get();
}

 abstract class G{
    public abstract void change();
}

class X extends G implements E,F{

@Override
public void print() {
    System.out.println("接口E的抽象方法");
    }

    @Override
    public void get() {
    System.out.println("接口F的抽象方法");
    }

    @Override
    public void change() {
        System.out.println("抽象类G的抽象方法");
        }
   }

对于接口，里面的组成只有抽象方法和全局常量，所以很多时候为了书写简单，可以不用写public abstract或者public static final。并且，接口中的访问权限只有一种：public ,即：定义接口方法和全局常量的时候就算没有写上public，那么最终的访问权限也是public，注意不是default，注意不是default。以下两种写法是完全等价的：

interface C{
    public static final String MSG = "hello";
    public abstract void print();
}

等价于

interface C{
     String MSG = "hello";
     void print();
}

但是，这样会不会带来什么问题呢？如果子类中的覆写方法也不是public，我们来看：

interface C{
     String MSG = "hello";
 
     void print();
}

class X implements C{
    void print(){
        System.out.println("接口C的抽象方法");
    }
}

public class TestDemo{
    public static void main(String[] args){
    
        C c = new X();
        c.print();
    }
}

这样运行，系统会报错，这是因为接口中默认是public修饰，若子类中没有public修饰，则访问权限变严格了，给子类分配的是更低的访问权限。所以，在定义接口的时候强烈建议在抽象方法前加上public，子类也加上

3.在Java中，一个抽象类只能继承一个抽象类，但一个接口却可以使用extends关键字同时继承多个接口（但接口不能继承抽象类）。
（1）一个抽象类只能继承一个抽象父类，而接口可以继承多个接口；
（2）一个子类只能继承一个抽象类，却可以实现多个接口（Java中，接口的主要功能时解决单继承局限问题）

4.从接口的概念来讲，接口只能由抽象方法和全局常量组成，但是内部结构时不受概念限制的，正如抽象类中可以定义抽象内部类一样，在接口中也可以定义普通内部类、抽象内部类和内部接口