接口的基本概念

最新推荐文章于 2024-08-24 13:21:15 发布

Rachel_pan

最新推荐文章于 2024-08-24 13:21:15 发布

阅读量1.5k

点赞数

分类专栏： Java学习笔记 # 面向对象（进阶篇）文章标签： Java interface implements extends 接口

本文链接：https://blog.csdn.net/Rachel_pan/article/details/100997942

版权

Java学习笔记同时被 2 个专栏收录

65 篇文章 5 订阅

订阅专栏

面向对象（进阶篇）

14 篇文章 0 订阅

订阅专栏

一、接口的基本概念

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

【接口的定义格式】

interface 接口名称 {

全局常量；

抽象方法；

}

注意：在接口中定义的抽象方法访问权限必须为public

二、接口的定义

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

在接口的基本概念中已经明确声明接口是由全局常量和抽象方法组成，所以在开发中可以简化为如下格式：

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

三、接口的实现

与抽象类一样，接口的使用也必须通过子类，子类通过 implements 关键字实现接口

【实现接口格式】

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

}

从定义格式可以发现，一个子类可以同时实现多个接口，这就摆脱了Java的单继承局限

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

interface B {  //接口B
    public void say();  //定义抽象方法
}

class C implements A,B {  //子类C实现接口A，接口B
    public void print(){   //覆写接口A的抽象方法
        System.out.println("Hello World");
    }
    public String getInfo(){  //覆写接口A的抽象方法
        return "info";
    }
    public void say(){   //覆写接口B的抽象方法
        System.out.println("author:" + AUTHOR);
    }
}

public class InterfaceDemo01 {
    public static void main(String[] args) {
        C c = new C();  //实例化子类对象
        c.print();   //调用被覆写过的方法
        System.out.println(c.getInfo()); //调用被覆写过的方法
        c.say();     //调用被覆写过的方法
    }
}

程序运行结果：

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

四、继承抽象类实现接口

【继承抽象类实现接口格式】

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

}

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

abstract class B {  //抽象类B
    public abstract void say();  //定义抽象方法,必须使用 abstract 关键字声明
}

class C extends B implements A {  //子类继承抽象类B实现接口A
    public void print(){   //覆写接口A的抽象方法
        System.out.println("Hello World");
    }
    public String getInfo(){  //覆写接口A的抽象方法
        return "info";
    }
    public void say(){   //覆写抽象类B的抽象方法
        System.out.println("author:" + AUTHOR);
    }
}

public class InterfaceDemo02 {
    public static void main(String[] args) {
        C c = new C();  //实例化子类对象
        c.print();   //调用被覆写过的方法
        System.out.println(c.getInfo()); //调用被覆写过的方法
        c.say();     //调用被覆写过的方法
    }
}

程序执行结果：

五、抽象类实现接口

在Java中，允许一个抽象类实现多个接口

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

interface B {  //接口B
    void say();
}

abstract class C implements A,B {  //抽象类实现多个接口
    public abstract void echo();  //定义抽象方法,必须使用 abstract 关键字声明
}

class D extends C {
    public void print(){   //覆写接口A的抽象方法
        System.out.println("Hello World");
    }
    public String getInfo(){  //覆写接口A的抽象方法
        return "flag";
    }
    public void say(){   //覆写接口B的抽象方法
        System.out.println("author:" + AUTHOR);
    }
    public void echo(){  //覆写抽象类C的抽象方法
        System.out.println("echo");
    }
}

public class InterfaceDemo03 {
    public static void main(String[] args) {
        D d = new D();  //实例化子类对象
        d.print();   //调用被覆写过的方法
        System.out.println(d.getInfo()); //调用被覆写过的方法
        d.say();     //调用被覆写过的方法
        d.echo();    //调用被覆写过的方法
    }
}

程序运行结果：

六、接口继承接口

在Java中，一个接口是不允许继承抽象类的，但是允许一个接口继承多个接口

【接口的继承格式】

interface 子接口 extends 父接口A，父接口B，...{

}

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

interface B {  //接口B
    void say();
}

interface C extends A,B{
    void echo();
}

class D implements C {
    public void print(){   //覆写接口A的抽象方法
        System.out.println("Hello World");
    }
    public String getInfo(){  //覆写接口A的抽象方法
        return "interface";
    }
    public void say(){   //覆写接口B的抽象方法
        System.out.println("author:" + AUTHOR);
    }
    public void echo(){  //覆写接口C的抽象方法
        System.out.println("many interface");
    }
}

public class InterfaceDemo03 {
    public static void main(String[] args) {
        D d = new D();  //实例化子类对象
        d.print();   //调用被覆写过的方法
        System.out.println(d.getInfo()); //调用被覆写过的方法
        d.say();     //调用被覆写过的方法
        d.echo();    //调用被覆写过的方法
    }
}

程序运行结果：