Java之——“接口”

Hi_Lyn

已于 2025-04-08 21:07:51 修改

阅读量1.8k

点赞数 54

分类专栏： Java 文章标签： java 开发语言学习方法笔记经验分享

于 2025-02-15 13:00:32 首次发布

本文链接：https://blog.youkuaiyun.com/Hi_Lyn/article/details/145646476

版权

Java 专栏收录该内容

7 篇文章

订阅专栏

前言

学习 Java 接口前，需注意以下几点。首先要扎实掌握 Java 基础语法，如类、对象、方法等概念，这是理解接口的基石。熟悉继承机制，接口与继承关联紧密，继承知识能助你更好理解接口的多实现特性。清楚访问修饰符的使用，接口对方法和变量的访问权限有特定要求。另外，要明白抽象类的概念，对比抽象类与接口的差异，能让你更精准把握接口的独特作用和适用场景。

一、接口的概念

在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口可以插U盘、鼠标、键盘、以及所有符合USB协议的设备；电源插座可以插电脑、电视机、电饭煲、以及所有符合规范的设备
通过上述例子可以看出：接口就是公共的行为规范，大家在实现时，只要符合规范标准，就可以通用，在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型

二、语法规则

接口的定义格式与定义类的格式基本相同，将class关键字换成interface关键字，就定义了一个接口，代码如下

interface 接口名称{

}

2.1几点注意

接口当中成员变量默认为public static final；成员方法默认为public abstract
阿里编码规范中规定，接口的方法和属性不要加任何修饰符号，保持代码的简洁性（如下述age4和method4()的写法）

interface Animal{
    public static final int age1 = 10;
    static final int age2 = 10;
    final int age3 = 10;
    int age4 = 10;
    
    //注意：在接口中，上述成员变量写法都正确，更推荐age4的写法，代码更简洁
    public abstract void method1();
    abstract void method2();
    public void method3();
    void method4();
    
    //注意：在接口中，上述写法都是抽象方法，更推荐方法4，代码更简洁

接口中不可以有普通的方法
从Java8开始，允许在接口当中定义一个default方法，可以有具体实现的

public interface Animal1 {
    default void eat(){
        System.out.println("在吃饭！");
    }
}

接口当中的方法如果是static修饰的方法，那么也可以有具体的实现

public interface Animal1 {
    static void eat(){
        System.out.println("在吃饭！");
    }
}

接口不能通过new关键字来进行实例化
类和接口之间可以通过关键字implements来实现接口,在类中需要重写接口中所有的抽象方法

public class Animal2 implements Running{
    String name;
    int age;

    @Override
    public void run() {
        System.out.println(name+"正在跑");
    }
}

接口也可以发生向上转型和动态绑定
当一个类实现接口当中的方法之后，当前类的方法不能不加public
接口当中不能有构造方法和代码块
接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
如果类没有实现接口中所有的抽象方法，则类必须设置为抽象类

2.2实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java不支持多继承，但是一个类可以实现多个接口

下面通过类来表示一组动物

public class Animal3 {
    public String name;
    public Animal3(String name){
        this.name = name;
    }
}

我们再提供一组接口，分别表示”会飞的“，”会跑的“，”会游泳的”

public interface IFlying {
    void fly();
}

public interface IRunning {
    void run();
}

public interface ISwimming {
    void swim();
}

接下来我们创建几个具体的动物

猫是会跑的

public class Cat extends Animal3 implements IRunning{
    public Cat(String name){
        super(name);
    }
    @Override
    public void run() {
        System.out.println(name + "正在用四条腿跑");
    }
}

鱼是会游的

public class Fish extends Animal3 implements ISwimming{
    public Fish(String name) {
        super(name);
    }

    @Override
    public void swim() {
        System.out.println(name + "正在用尾巴游泳");
    }
}

青蛙既能跑也能游泳

public class Frog extends Animal3 implements IRunning,ISwimming{
    public Frog(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(name + "正在往前跳");
    }

    @Override
    public void swim() {
        System.out.println(name + "正在蹬腿游泳");
    }
}

还有一种水陆空三栖动物，鸭子

public class Duck extends Animal3 implements IRunning,ISwimming,IFlying{
    public Duck(String name) {
        super(name);
    }

    @Override
    public void fly() {
        System.out.println(name + "正在用翅膀飞");
    }

    @Override
    public void run() {
        System.out.println(name + "正在用两条腿跑");
    }

    @Override
    public void swim() {
        System.out.println(name + "正在飘在水上");
    }
}

上面的代码展示了Java面向对象编程中最常见的用法：一个类继承一个父类，实现多个接口
继承表示的含义是is-a，而接口表达的含义是具有xxx特性

猫是一种动物，具有会跑的特性
青蛙是一种动物，既能跑也能游泳
鸭子也是一种动物，既能跑，也能游，还能飞

这样设计的好处就是让程序员忘记类型，有了接口之后，类的使用者就不必关注具体类型，而只关注某个类是否具备某种能力

例如，现在实现一个方法，叫散步，在这个walk方法内部，我们并不关注到底是哪种动物，只要参数是会跑的，都行

public class walk {
    public static void walk(IRunning iRunning){
    System.out.println("我带着伙伴去散步");
    iRunning.run();
}
    public static void main(String[] args) {
        Cat cat = new Cat("小猫");
        Frog frog = new Frog("小青蛙");
        walk(cat);
        walk(frog);
    }
}
//运行结果
我带着伙伴去散步
小猫正在用四条腿跑
我带着伙伴去散步
小青蛙正在往前跳

Process finished with exit code 0

2.3接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。
接口可以继承一个接口，达到复用的效果，使用extends关键字

public interface IAmphibious extends IRunning,ISwimming{
    
}

青蛙是两栖动物

public class Frog extends Animal3 implements IAmphibious{
    public Frog(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(name + "正在往前跳");
    }

    @Override
    public void swim() {
        System.out.println(name + "正在蹬腿游泳");
    }
}

通过接口继承创建一个新的接口IAmphibious表示两栖的，此时实现接口创建的的Frog类，就要继续实现run方法，也要实现swim方法

接口间的继承相当于把多个接口合并在一起

三、接口使用实例

3.1给对象数组排序

让我们的Student类实现Comparable接口，并且实现其中的compareTo方法，CompareTo的参数是Object，其实传入的就是Student类型的对象，然后比较当前对象和参数对象的大小关系

如果当前对象的分数大于参数对象，返回-1；
如果当前对象的分数小于参数对象，返回1；

package demoStuden;

public class Student implements Comparable{
    private String name;
    private  int score;
    public Student(String name,int score){
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Object o) {
        Student s = (Student) o;
        if(this.score > s.score){
            return -1;
        }
        else return 1;
    }

    public static void main(String[] args) {
        Student student1 = new Student("张三",90);
        Student student2 = new Student("李四",99);
        System.out.println(student1.compareTo(student2));
    }
}
//输出结果
1

Process finished with exit code 0

3.2 `Clonable` 接口

Java中内置了一些很有用的接口，Clonable就是其中之一
Object类中存在一个clone接口，调用这个方法可以创建一个对象的“拷贝”，但是要想合法调用clone方法，必须要先实现Clonable接口，否则就会抛出异常
Clonable拷贝出的对象是一份浅拷贝

观察以下代码，定义一个Money类，实现Clonable接口

public class Money {
    public double m = 99.99;
}
class Person implements Cloneable{
    public Money money = new Money();

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class demo3 {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person person1 = new Person();
        Person person2 = (Person) person1.clone();
        System.out.println("通过person2修改前的结果");
        System.out.println(person1.money.m);
        System.out.println(person2.money.m);
        person2.money.m = 13.6;
        System.out.println("通过person2修改后的结果");
        System.out.println(person1.money.m);
        System.out.println(person2.money.m);
    }
}
//输出结果
通过person2修改前的结果
99.99
99.99
通过person2修改后的结果
13.6
13.6

Process finished with exit code 0