【Java】接口详解

最新推荐文章于 2024-09-13 21:40:38 发布
最新推荐文章于 2024-09-13 21:40:38 发布
阅读量3.3k 收藏 94
点赞数 128
分类专栏： JavaSE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yican2580/article/details/139421981
版权

接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量。

一个简单的接口代码示例

interface IShape {
void draw();
}
class Cycle implements IShape {
@Override
public void draw() {
System.out.println("○");
}
}
public class Data {
public static void main(String[] args) {
IShape shape = new Rect();
shape.draw();
}
}

定义接口的注意事项：

  • 使用 interface 定义一个接口
  • 接口中的方法一定是抽象方法, 因此可以省略 abstract
  • 接口中的方法一定是 public, 因此可以省略 public
  • Cycle 使用 implements 继承接口. 此时表达的含义不再是 "扩展", 而是 "实现"
  • 在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例.
  • 接口不能单独被实例化

定义一个完整的接口是这样的：

interface Ishape{

        public static final int num = 10;

        public abstruct void draw();

}

 但是严格来说我们在定义一个接口的时候通常会省略  public static final 和 public abstruct ，在我们定义接口的时候里面的变量和方法会自动加上。

省略之后的写法：

interface Ishape{

         int num = 10;

         void draw();

}

实现多个接口

 有的时候我们需要让一个类同时继承自多个父类. 这件事情在有些编程语言通过 多继承 的方式来实现的.然而 Java 中只支持单继承, 一个类只能 extends 一个父类. 但是可以同时实现多个接口, 也能达到多继承类似的效果。

代码示例：

interface Ifly{
    void fly();
}
interface Irunning{
    void running();
}
interface Iswimming{
    void swimming();
}
abstract class Animal{
    public String name;
    public int age;
    public Animal(String name,int age){
        this.name = name;
        this.age = age;
    }
    abstract public void eat();
}
class Dog extends Animal implements Iswimming , Irunning{

    public Dog(String name,int age){
        super(name,age);
    }

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

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

    @Override
    public void eat() {
        System.out.println(this.name + "正在吃狗粮");
    }
}

public class Data{
    public static void test1(Animal animal){
        animal.eat();
    }
    public static void test2(Ifly ifly){
        ifly.fly();
    }
    public static void test3(Iswimming iswimming){
        iswimming.swimming();
    }
    public static void test4(Irunning irunning){
        irunning.running();
    }

    public static void main(String[] args) {
        test1(new Dog("小黄" ,20));
        test3(new Dog("小黄" ,20));
        test4(new Dog("小黄" ,20));
    }
}

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

在这个代码中我们定义了三个接口：Ifly 、Irunning 、Iswimming 。一个抽象类：Animal 。然后定义了一个类来继承这个抽象类并且实现了两个接口。

上述代码运行结果：

接口的常见使用案例

Comparable接口

 给对象数组排序

代码示例：

class Student implements Comparable<Student>{
    private String name;
    private int score;
    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
    @Override
    public String toString() {
        return "[" + this.name + ":" + this.score + "]";
    }

    @Override
    public int compareTo(Student o) {
        return this.score - o.score;
    }
}
public class Data{
    public static void main(String[] args) {
        Student[] student = {
                new Student("小明",87),
                new Student("小黄",94),
                new Student("小李",89)};
        Arrays.sort(student);
        System.out.println(Arrays.toString(student));
    }
}

在这个代码中我们定义了一个 Student 类：

class Student {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "[" + this.name + ":" + this.score + "]";
}
}

 然后用这个类创建了一个数组：

Student[] student = {
        new Student("小明",87),
        new Student("小黄",94),
        new Student("小李",89)};

接着我们给 Student 类实现接口 Comparable<Student> ，这样我们就可以给该类实例化的成员进行比较大小。

上述代码的运行结果：

 注意事项: 对于 sort 方法来说, 需要传入的数组的每个对象都是 "可比较" 的, 需要具备 compareTo 这样的能力. 通过重写 compareTo 方法的方式, 就可以定义比较规则。

Comparator接口

另外一种比较一个类的两个实例的方法：

代码示例：

class Person implements Comparable<Person>{
    public String name;
    public int age;

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

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

    @Override
    public int compareTo(Person o) {
        return this.age - o.age;
    }
}
class AgeComparator implements Comparator<Person>{

    @Override
    public int compare(Person o1, Person o2) {
        return o1.age - o2.age;
    }
}
class NameComparator implements Comparator<Person>{

    @Override
    public int compare(Person o1, Person o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class Data{
    public static void main(String[] args) {
        Person p1 = new Person("小明",20);
        Person p2 = new Person("小黄",30);
        System.out.println(p1.compareTo(p2));
        AgeComparator agecomparator = new AgeComparator();
        System.out.println(agecomparator.compare(p1,p2));
        NameComparator namecomparator = new NameComparator();
        namecomparator.compare(p1,p2);
    }
}

在这个代码中我们为了进行比较，额外创建了一个类来实现 Comparator 接口并且在该类里面重写 compare 方法。

Clonable 接口

浅拷贝 VS 深拷贝

浅拷贝示例

代码示例：

class Person implements Cloneable{
    public int age;
    public Person(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Data{
    public static void main(String[] args) throws CloneNotSupportedException {
        Person p1 = new Person(20);
        Person p2 = (Person)p1.clone();
        System.out.println(p1);
        System.out.println(p2);
    }
}

这里我们定义了一个类 Person 并且实现了接口 Cloneable 重写了方法 clone 。在测试类中我们将 p1 里面的内容拷贝到了 p2 里面。

代码运行结果：

接着我们再定义一个 Money 类：

class Money{
    public double money = 19.9;
}

并且在 Person 类中使用这个类：

 

class Person implements Cloneable{
    public int age;
    public Money m = new Money();
    public Person(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }

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

 接着我们再进行拷贝，将 p1 里面的内容拷贝到 p2 里面，然后我们改变 p2 里面的内容，并且将其输出：

很快我们就能看出一个问题：改变 p2 里面的内容，而 p1 里面的内容也跟着改变了呢？

接着我们引入深拷贝的理念：

深拷贝示例

代码示例：

class Money implements Cloneable{
    public double money = 19.9;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable{
    public int age;
    public Money m = new Money();
    public Person(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person)super.clone();
        tmp.m = (Money)this.m.clone();
        return tmp;
    }
}
public class Data{
    public static void main(String[] args) throws CloneNotSupportedException {
        Person p1 = new Person(20);
        Person p2 = (Person)p1.clone();
        System.out.println(p1.m.money);
        System.out.println(p2.m.money);
        p2.m.money = 99.9;
        System.out.println(p1.m.money);
        System.out.println(p2.m.money);
    }
}

运行结果：

我们发现我们刚刚提出的问题被解决了。

这里我们改变了两个地方：

1、 将 Money 类也实现 Clonable 接口重写 clone 方法，将其具备能被拷贝的能力。

class Money implements Cloneable{
    public double money = 19.9;

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

2、重写 Person 类里面的 clone 方法。

 

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

接口间的继承

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字。

interface IRunning {
    void run();
}
interface ISwimming {
    void swim();
}
interface IAmphibious extends IRunning, ISwimming {
    void eat();
}

接口间的继承相当于把多个接口合并在一起。这里我们定义接口 Iamphibious 来继承了接口 IRunning 和接口 ISwimming 。这样该接口就有了另外两个接口里面的抽象方法，并且该接口也可以定义另外的抽象方法。

总结

抽象类与接口的区别：

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

一只淡水鱼66
关注
专栏目录
Java接口详解
流楚丶格念的博客
06-10 2846
文章目录第一章 接口1.1 概述1.2 定义格式含有抽象方法含有默认方法和静态方法含有私有方法和私有静态方法1.3 基本的实现抽象方法的使用 第一章 接口 1.1 概述 接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。 接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确
详解java接口interface
06-17
Java 接口详解 Java 接口是 Java 语言中的一种特殊的抽象类，它定义了一组抽象方法和默认方法，用于规范多个类之间的公共行为。在本文中，我们将详细介绍 Java 接口的定义、抽象方法、默认方法、实现类和使用方法。...
Java 接口详解
80后大叔爱学习
08-12 5778
Java的接口很重要，是以后和别人联调时候用接口对接数据的
java 接口 详解
Cyan_RA9的博客
02-24 2万+
java 接口 内容分享，本篇博文为java 面向对象三大特性——多态篇的补充。
java接口详解
weixin_38568503的博客
01-05 5662
Java基础——接口 一、接口的概述： 官方解释：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。 我的解释：接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，既接口中的方法必须全部是抽象方法。（JDK1.8之前可以这样理解） 二、接
java接口的详解
weixin_55079859的博客
06-24 2374
java接口详解
java 接口 代码_Java接口 详解（一）
weixin_39916681的博客
02-15 2896
Java接口 详解(一)一、基本概念接口(Interface)，在JAVA编程语言中是一个抽象类型，是抽象方法的集合。接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。如果一个类只由抽象方法和全局常量组成，那么这种情况下不会将其定义为一个抽象类。只会定义为一个接口，所以接口严格的来讲属于一个特殊的类，而这个类里面只有抽象方法和全局常量，就连构造方法也没有。范例...
【Java】接口的详解
weixin_60719453的博客
10-30 3万+
一、前言 前面我们说了抽象类的概述，我们对抽象类也有个认识和理解了，现在我们学习 十分重要的内容接口，接口这个词比较的抽象，但其实也是十分好理解的。 二、接口 简单的说，接口就是一种被规范的标准，只要符合这个标准都可以通用，接口的表现 在于对行为的抽象。 ...
Java接口（详解）
m0_52896041的博客
10-19 2048
Java接口（详解）
java集合超详解
热门推荐
feiyan的博客
08-03 45万+
一、集合大纲 1.集合和数组的区别： 2.Collection集合的方法： 3.常用集合的分类： Collection 接口的接口 对象的集合（单列集合） ├——-List 接口：元素按进入先后有序保存，可重复 │—————-├ LinkedList 接口实现类， 链表， 插入删除， 没有同步， 线程不安全 │—————-├ ArrayList 接口...
java接口自动化测试框架及断言详解
08-25
"java接口自动化测试框架及断言详解" 本篇文章主要介绍了Java接口自动化测试框架及断言详解，通过示例代码详细地介绍了Java接口自动化测试框架及断言详解，对大家的学习或者工作具有一定的参考学习价值。 一、Java...
面向对象的java接口详解
07-08
2. **Java接口的定义**：接口使用`interface`关键字定义，可以包含抽象方法（无方法体的方法）和常量。例如： ```java public interface IShape { double area = 100.0; void draw(); double getArea(); } ``...
spring事务详细讲解-深入浅出
小电玩
09-08 533
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1517
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
自动生成不重复的订单id
ClaireCheney的博客
09-13 193
【代码】自动生成不重复的订单id。
Java集合：Stack详解
yang_brother的博客
09-10 580
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 613
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于SpringBoot的考研资讯平台设计与实现
最新发布
linzhongshu的专栏
09-13 571
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
java的Comparator 接口详解
04-16
Comparator接口是用来进行对象之间的比较的，可以用来排序等场合。实现Comparator接口可以自定义排序规则，实现compare()方法来定义比较规则。此外，Comparator接口还可以作为参数传递给Collections.sort()方法。一般来说，如果一个类本身没有实现Comparable接口，但需要进行排序，可以使用Comparator接口。
评论 84
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值