1. Toy模板网首页
  2. > Toy博客

Java接口详解

9月前 作者：灰灰快醒醒 分类：Toy博客 阅读(23) 违法举报

这篇具有很好参考价值的文章主要介绍了Java接口详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

接口

接口的概念

在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，电源插座等。

电脑的USB口上，可以插：U盘，鼠标，键盘等所有符合USB协议的设备

电源插座插孔上，可以插：电脑，电视机，电饭煲等所有符合规范的设备

通过上述例子可以看出：接口就是公共行为的规范标准，大家在实现时，只要符合规范标准，就可以通用。在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

语法规则

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

public interface 接口名称 {
    //抽象方法
    public abstract void method1();//public abstract是固定搭配，可以不写
    public void method2();
    abstract void method3();
    void method4();
    
    //注意：在接口中上述的写法虽然都是抽象方法，但是更推荐method4，更加简洁
}

提示：

1.创建接口时，接口的命名一般是以大写字母I开头

2.接口的命名一般使用“形容词”词性的单词

3.阿里编码规范中约定，接口中的方法和属性不要加任何修饰符号，保持代码的简洁性

接口使用

接口不能直接使用，必须要有一个“实现类”来“实现”该接口，实现接口中的所有抽象方法

//类和接口的关系：类 implements 接口
public class 类名称 implements 接口名称 {
    //...
}

注意：子类和父类之间是extends继承关系，类和接口之间是implements实现关系。

举个接口使用的小栗子：

请实现笔记本电脑使用USB鼠标，USB键盘的例子

1.USB接口：包含打开设备，关闭设备的功能

2.笔记本类：包含开机功能，关机功能，使用USB设备的功能

3.鼠标类：实现USB接口，并具备点击功能

4.键盘类：实现USB接口，并具备输入功能

//定义USB接口
interface USB {
    void openDevice();
    void closeDevice();
}

class Mouse implements USB {
    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }

    public void click() {
        System.out.println("鼠标点击");
    }
}

class KeyBoard implements USB {
    @Override
    public void openDevice() {
        System.out.println("打开键盘");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭键盘");
    }

    public void input() {
        System.out.println("键盘输入");
    }
}

class Computer {
    public void powerOn() {
        System.out.println("打开电脑");
    }

    public void powerOff() {
        System.out.println("关闭电脑");
    }

    //定义电脑使用USB设备的方法，通过多态性，根据传入的USB设备的不同完成不同操作
    public void useDevice(USB usb) {
        usb.openDevice();
        //instanceof:比较左右实例的等操作符
        if(usb instanceof Mouse) {
            //向下转型：将 USB 类型的参数 usb 转换为 Mouse 类型的引用 mouse。这样就可以在这个方法中使用 mouse 对象的特有方法
            Mouse mouse = (Mouse)usb;
            mouse.click();
        } else if (usb instanceof KeyBoard) {
            KeyBoard keyboard = (KeyBoard)usb;
            keyboard.input();
        }

        usb.closeDevice();
    }
}

public class TestUSB {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();

        Mouse mouse = new Mouse();
        KeyBoard keyboard = new KeyBoard();
        computer.useDevice(mouse);
        System.out.println("===============");
        computer.useDevice(keyboard);

        computer.powerOff();
    }
}

注：instanceof 是 Java 中的一个关键字，用于检查一个对象是否是指定类或其子类的实例。它的语法是：

object instanceof Class

其中，object 是要检查的对象，Class 是指定的类名。

instanceof 返回一个布尔值，如果对象是指定类的实例或其子类的实例，则返回 true，否则返回 false。

接口特性

1.接口类型是一种引用类型，但是不能直接new接口的对象

public class TestUSB {
    public static void main(String[] args) {
        USB usb = new USB();
    }
}

//Error:USB是抽象的，无法实例化

2.接口中的每一个方法的类型都是public的抽象方法，即接口中方法会被隐式的指定为public abstract(只能是public abstract,其他修饰符都会报错)

public interface USB {
    private void closeDevice();
}

//Error:此处不允许使用修饰符private

3.接口中的方法是不能在接口中实现的（两个方法除外：static 和 abstract修饰的方法），只能由实现接口中的类实现

public interface USB {
    void openDevice();
    void closeDevice() {
        System.out.println("关闭USB设备");
    }
}

//编译失败：因为接口中的方式默认为抽象方法
//Error:接口中的抽象方法不能带有主体

4.重写接口中的方法时，不能使用默认的访问权限

public interface USB {
    void openDevice();
    void closeDevice();
//这两个默认都是public修饰的
}

public class Mouse implements USB {
    @Override
    void openDevice() {
        System.out.println("打开鼠标");
    }//这里的方法是默认修饰符
    
    //...
}

//编译报错：Error:重写USB中的方法时，不能使用默认修饰符
//正在尝试分配更低的访问权限：以前为public

5.接口中可以含有变量，但是接口中的变量会被隐式指定为public static final变量

interface USB {
    double brand = 3.0;//默认被public static final修饰
    void openDevice();
    void closeDevice();
}

public class TestUSB {
    public static void main(String[] args) {
        System.out.println(USB.brand);//可以直接通过接口访问，说明是静态的
        //USB = 2.0;
        //编译报错：无法为最终变量brand分配值
        //说明brand具有final属性
    }
}

6.接口中不能有静态代码块和构造方法

7.接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

8.如果类中没有实现接口中的所有抽象方法，则必须设置为抽象类

9.jdk8中：接口中还可以包含default方法

实现多个接口

在Java中，类和类之间是可以单继承的。一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。下面通过类来表示一组动物

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

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

interface IFlying {
    void fly();
}

interface IRunning {
    void run();
}

interface ISwimming {
    void swim();
}

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

猫，是会跑的。

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

鱼，是会游的。

public class Fish extends Animal implements ISwimming{
    public Fish(String name) {
        super(name);
    }
    
    @Override
    public void swim() {
        System.out.println(this.name + "正在用鱼鳍游泳");
    }
}

青蛙，既能跑，又能游（两栖动物）

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

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

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

​

注意，一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

还有一种动物，水陆空三栖，叫做“鸭子”。

public class Duck extends Animal implements IRunning, ISwimming, IFlying {
    public Duck(String name) {
        super(name);
    }
    
    @Override
    public void fly() {
        System.out.println(this.name + "正在用翅膀飞");
    }

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

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

上面的代码展示了Java中面向对象编程最常见的用法：一个类继承一个父类，同时实现多个接口。

我们之前学过：继承具有is-a的语义，而接口表达的含义是：具有xxx特性。

猫是一种动物，具有会跑的特性

青蛙也是一种动物，既能跑，也能游泳

鸭子也是一种动物，既能跑，也能游，还能飞

这样设计有什么好处呢？时刻牢记多态的好处，让程序员忘记类型。有了接口之后，类的使用者就不用具体关注具体哪种类型，而只关注某个类是否有某种能力。

例如，现在实现一个方法，叫跑步

public static void walk(IRunning running) {
    System.out.println("我带着伙伴去跑步");
    running.run();
}

在这个walk方法内部，我们并不关注到底是哪种动物，只要是会跑的就行。

Cat cat = new Cat("小猫");
//这里只关注猫是否有跑步能力
walk(cat);

Frog frog = new Frog("小青蛙");
walk(frog);

//执行结果
我带着伙伴去散步
小猫正在用四条腿跑
我带着伙伴去散步
小青蛙正在向前跳

​

接口间的继承

在Java中，类和类是单继承的，而一个类可以实现多个接口，接口和接口之间可以多继承。即：用接口可以达到多继承的目的

注：

类和接口之间的关系 -> implements 实现

接口和接口之间的关系 -> extends 拓展

interface A {
    testA();
}

interface B extends A {
    testB();
}

//B中具有A的功能

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

接口的使用实例

对对象进行比较

public class Student {
    String name;
    int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

给定两个学生对象，对它们进行比较（年龄）

 Student student1 = new Student("zhangsan",12);
       Student student2 = new Student("lisi",18);

仔细思考，不难发现，和普通的整数不一样，两个整数是可以直接比较的，因为其大小关系明确。而两个学生对象的大小关系怎么确定？需要额外指定。

让我们的Student类实现Comparable接口，并实现其中的compareTo方法

//引入Comparable接口表明当前类可以比较，并实现其中的compareTo方法
//尖括号内写的是要比较的类型
public class Student implements Comparable<Student>{
    String name;
    int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

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

但上面的写法具有一定的缺点，比如更改了需求：不是比较年龄而是比较姓名，上面的方法显然是写死的，只能比较年龄，其他需求无法满足。

所以这时，我们可以另辟蹊径，在类外面实现比较器。

public class Student{
    String name;
    int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

  /*  @Override
    public int compareTo(Student o) {
        if(this.age > o.age) {
            return 1;
        } else if(this.age == o.age) {
            return 0;
        } else {
            return -1;
        }
    }*/
}

//比较器(年龄)
class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}

//比较器（姓名）
class NameComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}


======================
public class Test1 {
    public static void main(String[] args) {
       Student student1 = new Student("zhangsan",12);
       Student student2 = new Student("lisi",18);

       AgeComparator agecomparator = new AgeComparator();
       NameComparator namecomparator = new NameComparator();
        System.out.println(agecomparator.compare(student1, student2));
        System.out.println(namecomparator.compare(student1, student2));
    }
}

这样就可以同时比较年龄和姓名了。

那么回顾上述两种比较的方法，可以得出以下结论：

1.两种方法都可以适用于对象的比较

2.方法一侵入性较强：一旦写好了规定的比较方式，那么以后只能以这种方式比较了

3.方法二可以灵活比较，只需要传递需要比较的两个对象就可以了。

Cloneable接口和深拷贝

Java中内置了一些很有用的接口，Cloneable就是其中之一。

Object类中存在一个clone方法，调用这个方法可以创建一个对象的“拷贝”。但是要想合法调用clone方法，必须先实现Cloneable接口，否则就会抛出CloneNotSupportedException异常

public interface Cloneable {

}

//空接口/标记接口->表明当前类是可以被克隆的

如何使用 ？

1.首先，在你想要实现克隆功能的类中，实现 Cloneable 接口。例如：

public class MyClass implements Cloneable {
    // 类的成员和方法定义
}

2.然后，重写 Object 类中的 clone 方法，该方法在实现克隆时会被调用。在重写的方法中，调用 super.clone() 来创建一个对象的浅拷贝。

public class MyClass implements Cloneable {
    // 类的成员和方法定义
    
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

3.最后，当你需要克隆一个对象时，调用对象的 clone 方法即可。需要注意的是，clone 方法返回的是 Object 类型，所以你可能需要进行强制类型转换。例如：

MyClass original = new MyClass();
try {
    MyClass cloned = (MyClass) original.clone();
    // 对克隆对象进行操作
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}

需要注意的是，clone 方法默认进行的是浅拷贝，即只复制了对象的引用。如果你需要实现深拷贝（复制对象的内容），你可能需要在 clone 方法中自行实现复制对象内容的逻辑。

那么什么又是浅拷贝和深拷贝呢？

让我们来看以下代码，这是一个浅拷贝的举例：

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 TestDemo3 {
    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);
    }
}

执行结果如下：

Java接口详解,java,电脑,开发语言

如上代码，我们可以看到，通过clone，我们只是拷贝了Person对象。但是Person对象中的Money对象，并没有拷贝。通过person2这个引用修改了 m这个值后，person1这个引用访问m的值时，值也发生了改变。这里就是发生了浅拷贝。

举个栗子：这就相当于家里两个人看一个电视，一个人换了台，两个人就一起看另一个台。

那怎么实现深拷贝呢？

深拷贝是指在复制对象时，不仅复制对象本身，还要递归地复制对象内部的所有引用对象。

来看一下代码：

class Money implements Cloneable {
    public double m = 99.99;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // 这里进行浅拷贝，因为 'm' 是基本类型
    }
}

class Person implements Cloneable {
    public Money money = new Money();

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person)super.clone();
        tmp.money = (Money)this.money.clone();
        return tmp;
    }
}

public class TestDemo4 {
    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);
    }
}

运行结果：

Java接口详解,java,电脑,开发语言

显然深拷贝使得改动过后只有person2中的m发生了变化，这就是深拷贝。 

还是举个栗子：这就相当于两个人不同看两个电视，一个人换台，另一个人看的并没有变化

为了更容易理解，让我们看一下深拷贝和浅拷贝的内存情况吧：

浅拷贝：Java接口详解,java,电脑,开发语言

深拷贝：

Java接口详解,java,电脑,开发语言

抽象类和接口的区别

抽象类和接口都是Java中多态的最常见的使用方式。都需要重点掌握，同时必须认清两者的区别。

核心区别：抽象类中可以包含普通方法和普通字段，这样的普通方法和普通字段可以被子类直接使用（不必重写），而接口中不能包含普通方法，子类必须重写所有的抽象方法。 

再次提醒：抽象类存在的意义是为了让编译器更好的校验。

Java接口详解,java,电脑,开发语言

好了这一期就到这，这应该是作者字数最多的文章，敲得累死，下了。

 文章来源地址https://www.toymoban.com/news/detail-668084.html

 

到了这里，关于Java接口详解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • java 接口 详解

    java 接口 详解

    目录 一、概述         1.介绍 :          2.定义 :  二、特点          1.接口成员变量的特点 :          2.接口成员方法的特点 :         3.接口构造方法的特点 :          4.接口创建对象的特点 :          5.接口继承关系的特点 :  三、应用 :          1.情景 :     

    2024年02月05日
    浏览(40)

  • Java之接口的详解

    我们已经学完了抽象类，抽象类中可以用抽象方法，也可以有普通方法，构造方法，成员变量等。那么什么是接口呢？ 接口是更加彻底的抽象，JDK7之前，包括JDK7，接口中全部是抽象方法。接口同样是不能创建对象的 。 在JDK7，包括JDK7之前，接口中的 只有 包含：抽象方法和

    2024年02月11日
    浏览(22)
  • 【Java 基础篇】Java 自然排序：使用 Comparable 接口详解

    【Java 基础篇】Java 自然排序：使用 Comparable 接口详解

    在 Java 编程中，我们经常需要对对象进行排序。为了实现排序，Java 提供了 java.lang.Comparable 接口，它允许我们定义对象之间的自然顺序。本篇博客将深入探讨如何使用 Comparable 接口来进行自然排序，包括接口的基本概念、使用示例以及一些常见问题的解决方法。 自然排序是一

    2024年02月04日
    浏览(38)
  • JAVA开发（JAVA视频监控接口相关）

    JAVA开发（JAVA视频监控接口相关）

     一、背景 最近在做视频监控接口相关的开发，需要调用视频的接口获取直播地址，回放地址，然后集成到web里查看。 二、涉及的接口 1、获取卡口的id 2、通过卡口id获取通道（设备的id） 3、通过设备的id获取到直播地址 4、通过设备的id和时间范围获取回放视频文件 5、通过

    2024年02月12日
    浏览(38)

  • java集合之List接口实现类常用方法详解

    目录 一、List集合概述 二、ArrayList类 三、ArrayList常用方法实例 四、LinkedList类 五、Linkedist常用方法实例         java.util.List接口继承自Collection接口，是单列集合的一个分支，通常将实现了List接口的对象称为List集合，在List集合中允许出现重复的元素，所有的元素是以一种线

    2024年02月08日
    浏览(50)
  • mac电脑m1搭建java开发环境参考手册

    mac电脑m1搭建java开发环境参考手册

    开发人员经常会换电脑，或者换新电脑，意味着重新搭建开发环境，很麻烦。但新电脑到手里面了，不换又不好，此篇专门用来记录mac电脑m1搭建java开发环境的步骤。希望对读者有所帮助，一条龙服务。 后期有时间，会出关于win10环境的，目前介绍mac环境。 M1版MacBook安装Ar

    2024年02月09日
    浏览(54)
  • Java开发基础系列(十三)：集合对象(Set接口)

    Java开发基础系列(十三)：集合对象(Set接口)

    😊 @ 作者： 一恍过去 💖 @ 主页： https://blog.csdn.net/zhuocailing3390 🎊 @ 社区： Java技术栈交流 🎉 @ 主题： Java开发基础系列(十三)：集合对象(Set接口) ⏱️ @ 创作时间： 2023年07月27日 HashSet: 基于哈希表实现的集合，不保证元素的顺序。 LinkedHashSet: 基于哈希表和双向链表实现的

    2024年02月15日
    浏览(36)
  • 如何用chatGPT快速开发java后端功能接口

    如何用chatGPT快速开发java后端功能接口

      需求如图 常规无非是建表接口测试类，最后造数据进行自测。突发奇想，要不用GPT试一下快速写业务代码？ 第一步：建表，直接复制excel中内容到GPT中  第二步：要求转为下划线：    第三步：给出条件和想要的结果（下面第一幅图是自己写的，其它代码图都是GPT生成的）

    2024年02月06日
    浏览(37)

  • autojs与java开发的手机投屏，可在电脑操作手机

    手机上的aotujs代码，主要利用截图手机屏幕转换byte[]数据用tcpip传输到电脑配合java框架jframe显示手机实时界面等 电脑 代码实现接受图片进行显示，监听鼠标操作发送手机执行点击，滑动操作 主窗体类

    2024年02月15日
    浏览(41)
  • 【并发编程】Java的Future机制详解（Future接口和FutureTask类）

    【并发编程】Java的Future机制详解（Future接口和FutureTask类）

    目录 一、彻底理解Java的Future模式 二、为什么出现Future机制 2.1 Future 类有什么用？ 三、Future的相关类图 2.1 Future 接口 2.2 FutureTask 类 五、FutureTask源码分析 5.1 state字段 5.2 其他变量 5.3 CAS工具初始化 5.4 构造函数 5.5 jdk1.8和之前版本的区别 六、Callable 和 Future 有什么关系？ 七、

    2024年02月03日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包