Java-面向对象（高级篇）--接口的基本概念

接口的基本概念
接口在Java中是最重要的概念之一，它可以被理解为一种特殊的类，是由全局常量和公共的抽象方法所组成。
需要注意的是，在接口中的抽象方法必须定义为public访问权限，这是不可更改的。
【接口的定义】

interface A
{
    public static final String NAME="张三";//定义全局常量
    public abstract void print();//定义抽象方法
    public abstract String getInfo();//定义抽象方法
}

以上程序定义了一个接口，这里要提醒读者的是，在接口的基本概念中已经明确的声明了接口是由全局常量和公共的抽象方法组成，所以此处的接口定义可以进行简化：

interface A
{
     String NAME="张三";//定义全局常量
     void print();//定义抽象方法
     String getInfo();//定义抽象方法
}

与抽象方法一样，接口若要使用也必须通过子类，子类通过implements关键字实现接口。
【实现接口】

class 子类 implements 接口A，接口B,接口C,.....
{
}

从格式可以看出，一个子类可以同时实现多个接口，这就解决了Java单继承的局限性。
【实现接口】

interface A
{
     String NAME="张三";//定义全局常量
     void print();//定义抽象方法
     String getInfo();//定义抽象方法
}
interface B
{
    int age=22;
    void say();
}
class Student implements A,B
{
    //覆写接口中的抽象方法
    public void print(){
        System.out.println("姓名："+NAME);
    }
    public String getInfo(){
        return "学校：ZZU";
    }
    public void say(){
        System.out.println("年龄："+age);
    }
}
public class InterfaceDemo03
{
    public static void main(String args[]){
        Student a=new Student();
        a.print();
        System.out.println(a.getInfo());
        a.say();
    }
}

运行结果为:

姓名：张三
学校：ZZU
年龄：22

以上程序中，一个子类同时实现了两个接口，这样在子类中就必须同时覆写两个接口中的全部抽象方法。
如果要同时继承和实现接口，则可以按一下格式进行：

class 子类 extends 抽象类 implements 接口A，接口B,接口C,.....
{
}

另外在Java中，允许一个抽象类实现多个接口：
【抽象类实现接口】

interface A
{
     String NAME="张三";//定义全局常量
     void print();//定义抽象方法
     String getInfo();//定义抽象方法
}
abstract class B implements
{
     public int age=22;
     public abstract void say();
}
class Student extdens B
{
    //覆写接口中的抽象方法
    public void print(){
        System.out.println("姓名："+NAME);
    }
    public String getInfo(){
        return "学校：ZZU";
    }
    public void say(){
        System.out.println("年龄："+age);
    }
}
public class InterfaceDemo03
{
    public static void main(String args[]){
        Student a=new Student();
        a.print();
        System.out.println(a.getInfo());
        a.say();
    }
}

运行结果同上。在以上程序中，因为抽象类实现了接口，所以抽象类就包含了三个抽象方法，这样抽象类的子类就必须覆写三个抽象方法。在Java中一个接口不可以继承抽象类，但是可以继承多个接口：
【接口的继承】

interface A
{
     String NAME="张三";//定义全局常量
     void printA();//定义抽象方法
}
interface B
{
     public void printB();
}
interface C extends A,B
{
     public void printC();//定义抽象方法
}


class X implements C
{
    //覆写接口中的抽象方法
    public void printA(){
        System.out.println("A姓名："+NAME);
    }
    public void printB(){
        System.out.println("B姓名："+NAME);
    }
    public void printC(){
        System.out.println("C姓名："+NAME);
    }
}
public class InterfaceDemo03
{
    public static void main(String args[]){
        X a=new X();
        a.printA();
        a.printB();
        a.printC();
    }
}

运行结果：

A姓名：张三
B姓名：张三
C姓名：张三