接口的基本概念

接口是java中最重要的概念，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。

如果一个类中完全是由全局常量（static final）和抽象方法组成，就可以将其定义成一个接口。

接口定义格式：

interface 接口名称
{
      全局常量；
      抽象方法；    
}    

例子：

interface A{        // 定义接口A
    public static final String AUTHOR = "李兴华" ;    // 全局常量
    public abstract void print() ;    // 抽象方法
    public abstract String getInfo() ;    // 抽象方法
}

对于接口来讲，因为在其定义的时候已经定义了其组成就是全局常量和抽象方法，所以开发中往往可以简化定义。

interface A{        // 定义接口A
    String AUTHOR = "李兴华" ;    // 全局常量
    void print() ;    // 抽象方法
    String getInfo() ;    // 抽象方法
}

以上两种定义方式是完全一样的，没有任何区别（对于第二种，程序在编译的时候会自动加上 public abstract）。

接口的图形表示形式

接口图形表示既可以按照类图的形式表示，也可以使用一个“0”表示：

接口的使用中也必须要有子类，子类必须覆写全部抽象方法，子类通过“implements”关键字实现，一个子类可以实现多个接口，

则子类如果不是抽象类的话，肯定要覆写全部抽象方法。

interface A{        // 定义接口A
    public String AUTHOR = "李兴华" ;    // 全局常量
    public void print() ;    // 抽象方法
    public String getInfo() ;    // 抽象方法
}
interface B{    // 定义接口B
    public void say() ;    // 定义抽象方法，省略了abstract
}
class X implements A,B{    // X类同时实现A和B两个接口
    public void say(){
        System.out.println("Hello World!!!") ;
    }
    public String getInfo(){
        return "HELLO" ;
    }
    public void print(){
        System.out.println("作者：" + AUTHOR) ;
    }
};
public class InterfaceDemo03{
    public static void main(String args[]){
        X x = new X() ;    // 实例化子类对象
        x.say() ;
        x.print() ;
    }
};

以上程序，一个子类实现两个接口，这样在子类中必须同时覆写两个接口中全部抽象方法。

继承抽象类，实现接口

一个子类同时继承抽象类，和实现接口。

格式如下：class 子类 extends  抽象类  implements  接口A,接口B，，，，，{}；

interface A{        // 定义接口A
    public String AUTHOR = "李兴华" ;    // 全局常量
    public void print() ;    // 抽象方法
    public String getInfo() ;    // 抽象方法
}
abstract class B{    // 定义抽象类B
    public abstract void say() ;    // 定义抽象方法
}
class X extends B implements A{    // X类线继承B类，再实现A接口
    public void say(){
        System.out.println("Hello World!!!") ;
    }
    public String getInfo(){
        return "HELLO" ;
    }
    public void print(){
        System.out.println("作者：" + AUTHOR) ;
    }
};
public class InterfaceDemo04{
    public static void main(String args[]){
        X x = new X() ;    // 实例化子类对象
        x.say() ;
        x.print() ;
    }
};

在使用中，一个抽象类可以实现一个接口，那么对于抽象类的子类，则必须覆写抽象类和接口的全部（未实现的）抽象方法。（即如果接口中的某类方法在抽象类中实现了（覆写了），那么在抽象类的子类中就可以不用覆写了。因为继承，在父类中的方法，被子类继承了，相当于子类覆写了，子类照样可以调用，覆写该方法。）

interface A{        // 定义接口A
    public String AUTHOR = "李兴华" ;    // 全局常量
    public void print() ;    // 抽象方法
    public String getInfo() ;    // 抽象方法
}
abstract class B implements A{    // 定义抽象类B，实现接口A
    public abstract void say() ;    // 定义抽象方法
}
class X extends B{    // X类线继承B类
    public void say(){
        System.out.println("Hello World!!!") ;
    }
    public String getInfo(){
        return "HELLO" ;
    }
    public void print(){
        System.out.println("作者：" + AUTHOR) ;
    }
};
public class InterfaceDemo05{
    public static void main(String args[]){
        X x = new X() ;    // 实例化子类对象
        x.say() ;
        x.print() ;
    }
};

如果抽象类中实现了接口中的一些方法，那么，抽象类子类就可以不用覆写该方法。

package methoud;
interface A{        // 定义接口A
    public String AUTHOR = "李兴华" ;    // 全局常量
    public void print() ;    // 抽象方法
    public String getInfo() ;    // 抽象方法
}
abstract class B implements A{    // 定义抽象类B，实现接口A
    public abstract void say() ;    // 定义抽象方法
    public void print(){};
}
class X extends B{    // X类线继承B类
    public void say(){
        System.out.println("Hello World!!!") ;
    }
    public String getInfo(){
        return "HELLO" ;
    }
  
};
public class ThisDemo06{
    public static void main(String args[]){
        X x = new X() ;    // 实例化子类对象
        x.say() ;
        x.print() ;
    }
};

一个接口虽然不能继承抽象类，但是一个接口可以继承多个接口(使用的是extends)，实现接口的多继承。

interface A{        // 定义接口A
    public String AUTHOR = "李兴华" ;    // 全局常量
    public void printA() ;    // 抽象方法
}
interface B{
    public void printB() ;
}
interface C extends A,B{　　　　//注意，这里接口继承接口是extends，而不是implements
    public void printC() ;
}
class X implements C{    // X类线继承B类
    public void printA(){
        System.out.println("A、Hello World!!!") ;
    }
    public void printB(){
        System.out.println("B、Hello MLDN") ;
    }
    public void printC(){
        System.out.println("C、Hello LXH") ;
    }
};
public class InterfaceDemo06{
    public static void main(String args[]){
        X x = new X() ;    // 实例化子类对象
        x.printA() ;
        x.printB() ;
        x.printC() ;
    }
};

总结

一，接口只是一个特殊的类，只包含全局常量和抽象方法，

1）接口的抽象方法可以不加abstract。

2）抽象类的抽象方法必须有abstract关键字。

二，一个类只能继承一个父类，但是可以同时实现多个接口。

三，一个接口可以同时继承多个接口（extends），以实现接口的多继承。

四，接口和抽象类一样，都必须依靠子类。

五，一个抽象类可以实现多个接口，但是一个接口不能继承一个抽象类。