Java接口

最新推荐文章于 2024-10-10 09:56:47 发布

主修python

最新推荐文章于 2024-10-10 09:56:47 发布

阅读量81

点赞数

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_55987353/article/details/128491725

版权

Java 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

接口在Java中是一种抽象类型，包含抽象方法的集合，用于类的继承和多继承。接口不能实例化，但可以被实现。一个类可以实现多个接口，但只能继承一个类。接口中的方法默认是publicabstract的，且不允许有方法体。接口支持多继承，可以扩展多个父接口。类实现接口时必须实现所有接口方法，否则需声明为抽象类。

摘要由CSDN通过智能技术生成

接口的基本概念

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

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，狗则就必须声明为抽象类。另外，在Java中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类相似点：

一个接口可以有多个方法。
接口文件保存在java结尾的文件中，文件名使用接口名。
接口的字节码文件保存在class结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

接口不能用于实例化对象
接口没有构造方法
接口中所有的方法必须是抽象方法，Java8以后接口中可以使用default关键字修饰的非抽象方法
接口不能包含成员变量，除了static和final变量
接口不是被类继承了，而是要被类实现
接口支持多继承

接口特性：

接口中每一个方法也是隐式抽象的，接口中的方法会被隐式的指定为public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为public static final变量（并且只能是public，用private修饰会编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别：

抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的。
接口中不能含有静态代码块以及静态方法（用static修饰的方法），而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类。而一个类却可以实现多个接口。

例：接口的定义格式

intereface 接口名称 {

全局常量；

抽象方法；

}

注意： 在接口中的抽象方法必须定义成public访问权限，这是绝对不可改变的。

例：接口的定义

interface A {

public static final String AUTHOR = "李华"; // 定义全局常量

public abstrct void print(); // 定义抽象方法

public abstract String getInfo(); // 定义抽象方法

注意：接口中的基本概念里已经明确地声明了接口时由全局常量和抽象方法组成，所以此处的接口定义可以简化成如下的形式：

interface A {

String AUTHOR ="李华"; // 等价于：public static final String AUTHOR = "李华"

void print(); // 等价于：public abstract void print()

String getInfo(); // 等价于：public abstract String getInfo()

接口有以下特性：

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
接口中的方法都是共有的。

接口的实现

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

类使用implements关键字实现接口。在类声明中，implements关键字放在class声明后面。

例：实现接口

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

}

例：实例

package charjava;

interface T { // 定义接口T
    public String AUTHOR = "李华"; // 定义全局变量
    public void print(); // 定义抽象方法
    public String getInfo(); // 定义抽象方法
}
interface Y { // 定义接口Y
    public void say(); // 定义抽象方法
}
class U implements T,Y { // 子类同时实现两个接口
    public void say() { // 覆写Y接口中的抽象方法
        System.out.println("Hello World!");
    }
    public String getInfo() { // 覆写T接口中的抽象方法
        return "Hello";
    }
    public void print() { // 覆写T接口中的抽象方法
        System.out.println("作者：" + AUTHOR);
    }
}
public class java19 {
    public static void main(String[] args) {
        U u = new U(); // 实例化子类对象
        u.say(); // 调用被覆写过的方法
        u.print(); // 调用被覆写过的方法
    }
}

例：继承抽象类实现接口

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

}

例：实例

package charjava;

interface I { // 定义接口I
    public String AUTHOR = "李华"; // 定义全局变量
    public void print(); // 定义抽象方法
    public String getInfo(); // 定义抽象方法
}
abstract class O { // 定义抽象类O
    public abstract void say(); 
}
class P extends O implements I { // 子类同时实现接口
    public void say() {
        System.out.println("Hello World!"); // 覆写抽象类O中的抽象方法
    }
    public String getInfo() { // 覆写I接口中的抽象方法
        return "Hello!";
    }
    public void print() { // 覆写I接口中的抽象方法
        System.out.println("作者：" + AUTHOR);
    }
}
public class java20 {
    public static void main(String[] args) {
       P p = new P(); // 实例化子类对象
        p.say(); // 调用被覆写过的方法
        p.print(); // 调用被覆写过的方法
    }
}

例：抽象类实现接口

package charjava;

interface G { // 定义接口G
    public String AUTHOR = "李华"; // 定义全局变量
    public void print(); // 定义抽象方法
    public String getInfo(); // 定义抽象方法
}
abstract class H implements G { // 定义抽象类,实现接口
    public abstract void say(); // 此时抽象类中存在三个抽象方法
}
class J extends H { // 子类继承抽象类
    public void say() {
        System.out.println("Hello World!"); // 覆写抽象类H中的抽象方法
    }
    public String getInfo() { // 覆写G接口中的抽象方法
        return "Hello!";
    }
    public void print() { // 覆写G接口中的抽象方法
        System.out.println("作者：" + AUTHOR);
    }
}
public class java21 {
    public static void main(String[] args) {
        J j = new J(); // 实例化子类对象
        j.say(); // 调用被覆写过的方法
        j.print(); // 调用被覆写过的方法
    }
}

注意：重写接口中声明的方法时，需要注意以下规则：

类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的放回值类型。
如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

在实现接口的时候，也要注意一些规则：

一个类可以同时实现多个接口
一个类只能继承一个类，但是能实现多个接口
一个接口能继承另一个接口，这和类之间的继承比较相似

例：接口的多继承

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

}

例：实例

package charjava;

interface Z { // 定义接口Z
    public String AUTHOR = "李华"; // 定义全局变量
    public void printA(); // 定义抽象方法
}
interface X { // 定义接口X
    public void printB(); // 定义抽象方法
}
interface V extends Z, X { // 定义接口V，同时继承接口Z，X
    public void printC(); // 定义抽象方法
}
class N implements V { // 子类实现接口V
    public void printA() { // 覆写接口Z中的printA()方法
        System.out.println("A, Hello World!");
    }
    public void printB() { // 覆写接口X中的printB()方法
        System.out.println("B, Hello World!");
    }
    public void printC() { // 覆写接口V中的printC()方法
        System.out.println("C, Hello World!");
    }
}
public class java22 {
    public static void main(String[] args) {
    N n = new N(); // 实例化子类对象
    n.printA(); // 调用方法
    n.printB(); // 调用方法
    n.printC(); // 调用方法
    }
}

例：标记接口

最常用的继承接口是没有包含任何方法的接口。

标记接口是没有任何方法和属性的接口，它仅仅表明它的类属于一个特定的类型，供其他代码来测试允许做一些事情。

标记接口的作用：简单形象的说就是给某个对象打个标签，是对象拥有某个或某些特权。

例如：java.awt.event 包中MouseListener接口继承的java.util.EventListener接口定义如下：