Java-接口

原创 已于 2025-06-16 07:37:21 修改 · 927 阅读 · 21 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
Java

当前文章被收录于：

Java
5 篇文章 0 人学习

Java博客

订阅专栏 查看详情
于 2025-06-15 22:09:57 首次发布

文章目录

  • 接口
    • 1.1 接口概述
    • 1.2 接口的语法
    • 1.3 接口的使用
    • 1.4 多接口
    • 1.5 接口中的比较接口
    • 1.5.2 Comparable 接口
      • 1.5.3 Comparable 接口语法
      • 1.5.4 Comparable 接口的使用
    • 1.5.5 Comparator接口
      • 1.5.6 Comparator接口语法
      • 1.5.7 Comparator接口的使用
      • 1.5.8 Comparator接口中String类型的比较
    • 1.6 Cloneable接口和深拷贝
      • 1.6.2 Cloneable接口的语法
      • 1.6.3 Cloneable接口的使用
        • 1.6.3.2 调用克隆方法

接口

1.1 接口概述

在Java中不支持多继承，而接口可以。

接口生活中到处可见，如USB接口，电脑的电源接口等，只要符合UBS接口的要求就可以使用USB接口，由此接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以
通用。

在Java中，接口可以看成是：多个类的公共规范，是⼀种引⽤数据类型

1.2 接口的语法

public interface 接口名 {

}

和类的定义差不多，只是将class变成了interface

接口定义需要注意的几点：

  1. 接口名的定义以 I 为开头
  2. 接口名的定义使用形容词词性的单词来定义

接口中成员变量默认定义：public static final
接口中成员方法默认定义：public ababstract

在这里插入图片描述

默认定义可写可不写

注意： 接口不能被实例化

在这里插入图片描述

1.3 接口的使用

接口不能直接拿来使用，接口的使用，需要依附于类，必须要一个“实现类”实现接口，才能使用接口

要实现接口则需要使用 implements 关键字

子类和父类之间用的是extends关键字，而类和接口之间则是用 implements 来实现

类和接口之间的实现分为以下几步：

  1. 实现类和接口使用implements连接
  2. 重写接口当中的成员方法

在这里插入图片描述

public interface IRaced {

    void run();
}

public class Test implements IRaced{

    @Override
    public void run() {

    }
}

注意：

  1. 接口中被default修饰的方法，可以在接口中实现，可以不被重写，如果要重写这个方法也可以实现重写
    在这里插入图片描述

  2. 在接口中，子类重写接口的方法，重写方法的访问修饰符一定要大于等于父类的访问修饰符
    此时接口为父类，类为子类，所以这里指的是，类中重写的方法要大于接口中的抽象方法

  3. 接口中不能有静态代码块和构造方法
    在这里插入图片描述

1.4 多接口

Java中不支持多继承，但接口可以实现多接口，所以当类需要“多继承”时，可以使用多接口去实现

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

实现多接口的接口当中也可以定义方法
在这里插入图片描述

1.5 接口中的比较接口

public class Test {

    public static void main(String[] args) {
        int a = 2;
        int b = 1;

        if (a > b) {
            System.out.println("a > b");
        }
    }
}

上述代码是常见的比较大小的方法，还有一种方法也是使用 引用 来比较大小

public class Test {

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

       	 if (student1.scores > student2.scores) {
          System.out.println("student1 > student2");
        	}
   		}
    }

在Java中也有Java官方提供的比较大小的接口

1.5.2 Comparable 接口

1.5.3 Comparable 接口语法

public class 类名 implements Comparable<o> {

}

<>的 o 即代表存放要比较的类

注意：重写后的compareTo方法就不能更改

1.5.4 Comparable 接口的使用

分为两步：

  1. 在实现类中使用 implements 实现Comparable 接口
  2. 重写Comparable 接口中的compareTo方法

在这里插入图片描述

public class Student implements Comparable<Student>{
    public String name;
    public int age;
    public double scores;

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

    @Override
    public int compareTo(Student o) {
        return this.age - o.age;
    }
}

public class Test {

    public static void main(String[] args) {
        Student student1 = new Student("zhangsan",18,60);
        Student student2 = new Student("lisi",17,59);

        if (student1.compareTo(student2) > 0) {
            System.out.println("student1 > student2");
        }
    }
}

1.5.5 Comparator接口

1.5.6 Comparator接口语法

public class 类名 implements Comparator<o> {

}

和Comparable 接口一样

  1. <>中存放要比较的类
  2. 重写compare方法

1.5.7 Comparator接口的使用

  1. 在实现类中使用 implements 实现Comparator接口
  2. 重写Comparator接口中的compare方法

和Comparable 接口不同的是，Comparator更灵活一些，可以根据不同的比较对象，来创建不同的类，进行不同的比较。

Comparable 一般是Java默认的比较方式

public class Student implements Comparator<Student> {
    public String name;
    public int age;
    public double scores;

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


    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}


public class Test {

    public static void main(String[] args) {
        Student student1 = new Student("zhangsan",18,60);
        Student student2 = new Student("lisi",17,59);

        int set =  student1.compare(student1, student2);
        if (set > 0) {
            System.out.println("student1 > student2");
        }
    }
}

上述提到Comparator接口，可以根据不同的比较对象，创建不同的类来进行比较，我们把这种类叫做比较器

public class ScoresComparator implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        return (int)(o1.scores - o2.scores);
    }
}

注意：(int)(o1.scores - o2.scores)这里进行了强转，因为scores是double类型的，但重写的compare方法是int的类型，这里强转的int会导致double类型的变量精度丢失，所以这里的写法不推荐，也不要使用

1.5.8 Comparator接口中String类型的比较

compare方法不能比较String类型，String是引用类型，在Java中引用类型不能直接用大于小于等于比较运算符进行比较

而在String类下存在 Comparable接口，所以一定存在compareTo方法，虽然compare方法不能比较String类型，但可以通过compareTo方法进行比较

public class NameComparator implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}

public class Test {

    public static void main(String[] args) {
        Student student1 = new Student("zhangsan",18,60);
        Student student2 = new Student("lisi",17,59);

        NameComparator nameComparator = new NameComparator();
        int set =  nameComparator.compare(student1, student2);
        if (set > 0) {
            System.out.println("student1 > student2");
        }
    }
}

1.6 Cloneable接口和深拷贝

Cloneable接口是一个空接口，也叫标记接口

标记接口：如果一个类实现了这个接口，表示当前这个类可以被克隆

Cloneable接口分为浅拷贝和深拷贝

在这里插入图片描述

1.6.2 Cloneable接口的语法

public class Student implements Cloneable{

}

Cloneable接口特殊的它是一个空接口，想要实现克隆功能，必须要调用它的克隆方法，而克隆方法在Object类中

1.6.3 Cloneable接口的使用

使用Cloneable接口分为3步：

  1. 实现 Cloneable接口
  2. 调用克隆方法

在这里插入图片描述

1.6.3.2 调用克隆方法

快捷键：Ctrl + o 可以直接到第3步
在这里插入图片描述

浅拷贝：

public class Student implements Cloneable {

    public String name;
    public int age;
    public double scores;

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

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

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

public class Test {

    public static void main(String[] args) throws CloneNotSupportedException{
        Student s1 = new Student("zhangsan", 18, 80);
        Student s2 = (Student) s1.clone();
        System.out.println(s1);
        System.out.println(s2);
    }
}
//结果：
//Student{name='zhangsan', age=18, scores=80.0}
//Student{name='zhangsan', age=18, scores=80.0}

下面这个例子可以更好理解浅拷贝
浅拷贝只拷贝当前对象的内容，而深拷贝，对象当中的对象都要完成克隆

class Money implements Cloneable{
    double money = 9.9;

}
public class Student implements Cloneable {

    public String name;
    public int age;
    public double scores;

    public Money m = new Money();
    public Student(String name, int age, double scores) {
        this.name = name;
        this.age = age;
        this.scores = scores;
    }

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

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

public class Test {

    public static void main(String[] args) throws CloneNotSupportedException{
        Student s1 = new Student("zhangsan", 18, 80);
        Student s2 = (Student) s1.clone();
        System.out.println(s1.m.money);
        System.out.println(s2.m.money);

        System.out.println("====================");

        s2.m.money = 19.9;
        System.out.println(s1.m.money);
        System.out.println(s2.m.money);
    }
}
//结果
//9.9
//9.9
//====================
//19.9
//19.9

深拷贝
还是以上述例子为例进行深拷贝

class Money implements Cloneable{
    double money = 9.9;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Student implements Cloneable {

    public String name;
    public int age;
    public double scores;

    public Money m = new Money();
    public Student(String name, int age, double scores) {
        this.name = name;
        this.age = age;
        this.scores = scores;
    }

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

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

public class Test {

    public static void main(String[] args) throws CloneNotSupportedException{
        Student s1 = new Student("zhangsan", 18, 80);
        Student s2 = (Student) s1.clone();
        System.out.println(s1.m.money);
        System.out.println(s2.m.money);

        System.out.println("====================");

        s2.m.money = 19.9;
        System.out.println(s1.m.money);
        System.out.println(s2.m.money);
    }
}

//结果：
//9.9
//9.9
//====================
//9.9
//19.9

注意：
在Test类中的main方面后面还有一段代码 —>throws CloneNotSupportedException，多这一段代码的原因是因为，如果没有这一段代码会报运行时异常，关于异常这里暂且不表
在这里插入图片描述
而加上这一段代码则解决了编译时异常这个问题

标签
#java #开发语言
[java][接口]Java接口的介绍和使用
一名不太专业的程序员
10-02 9050
常量抽象方法默认方法(Java 8)静态方法(Java 8)私有方法(Java 9)
Java——接口
Stewie Lee的博客
11-11 6999
/ 常量// 默认有修饰符 public static final// 抽象方法// 默认有修饰符 public abstractvoid eat();// 默认有修饰符 public abstract。
java接口
2202_75357702的博客
12-16 1549
介绍java接口
关于Java中接口继承接口
u013591605的博客
06-26 3541
嘿,你好啊!
java接口_Java接口
cxu0262的博客
06-30 203
java接口 Java接口不同于类，因此重要的是要知道如何在Java程序中使用它们的特殊属性。 本教程介绍了类和接口之间的区别，然后通过示例演示如何声明，实现和扩展Java接口。 您还将通过添加默认和静态方法，以及在Java 9中使用新的私有方法，来学习接口在Java 8中的演变。 这些新增功能使界面对经验丰富的开发人员更加有用。 不幸的是，它们也模糊了类和接口之间的界线，使接口编程对Jav...
Java全栈面试宝典：从P6到P8-10
_abab的专栏
08-16 58
答案： CAP定理说一个分布式系统最多只能同时满足一致性（Consistency）、可用性（Availability）、分区容错性（Partition Tolerance）中的两个。C：所有节点在同一时刻看到的数据一样。你写了一个值，立刻读，不管从哪个节点读，都能读到最新值。A：每个请求都能得到非错误的响应，即使某些节点挂了。系统一直能对外服务，不会返回超时或拒绝。P：网络分区发生时，系统仍能继续工作。网络分区就是节点之间网络不通了，但节点本身还活着。CAP不是"三选二"，而是当网络分区发生时，你必须在C和
简单讲解Java--queue--三组成对出现的方法的区别
HDZW_ZQBX___的博客
08-15 376
操作类型异常派（失败抛异常）特殊值派（失败返null/false）核心选型原则插入add(e)offer(e)生产者：优先用offer做流控；初始化填充用add做断言取出remove()poll()消费者：永远用pollnull判断；原子操作且确定非空时才用remove查看element()peek()只读场景：99%情况用peek；需要强制非空前置条件时用element终极避坑指南不要用remove()element()做轮询——异常栈生成代价极高（填充StackTrace），比if。
Micrometer 系列【66】上下文传播工具库 | 案例演示
记录知识、锤炼自我
08-16 440
context-propagation 是 Micrometer 生态的跨线程上下文搬运协议层，本身零运行时依赖、不依赖 Spring、Micrometer 其他组件。
Java大厂面试实录：Spring Boot与微服务、Redis缓存、JWT安全、Prometheus监控全解析——记谢飞机的一次硬核面试
2602_95996092的博客
08-16 252
周六下午，互联网大厂“星河科技”的会议室里，阳光透过落地窗洒在长桌上。面试官李总眉头微蹙，翻看着眼前这位候选人的简历——谢飞机，三年Java开发经验，自我评价“精通全家桶”。对面，谢飞机正襟危坐，嘴角带着一丝自信到发光的微笑。李总推了推眼镜，语气平淡：“谢飞机先生，我们开始吧。今天聊电商后端场景，你平时写代码用什么Java版本？
【Spring Cloud Alibaba】Sentinel（三）
Blue_Pepsi_Cola的博客
08-15 249
这里有个关键点：不是 “前 10 秒”，是。
Java 数据结构详解：从栈、队列、链表到红黑树、B-Tree 与位图
qq_29029209的博客
08-14 814
本文摘要：数据结构解决的是如何高效组织数据以优化常见操作的问题。文章以Java为例，讲解了8种核心数据结构（栈、队列、链表、散列表、二叉搜索树、红黑树、B树、位图）的实现与应用。重点分析了复杂度概念（O(1)到O(n²)）和数据结构选择标准（查询/插入效率、有序性等）。通过括号匹配和BFS等典型示例，展示了栈和队列的实际应用场景。文中推荐优先使用ArrayDeque实现栈/队列，并对比了不同数据结构的适用场景和Java标准库实现（如HashMap、TreeMap等）。全文基于Java 8+，强调理解数据结构
[Java]-微服务面试题
.
08-19 162
服务降级是服务自我保护的一种方式，或者保护下游服务的一种方式，用于确保服务不会受请求突增影响变得不可用，确保服务不会崩溃。微服务的负载均衡主要使用了一个组件Ribbon，比如，我们在使用feign远程调用的过程中，底层的负载均衡就是。2，我们还在skywalking设置了告警规则，特别是在项目上线以后，如果报错，我们分别设置了可以给相关负责人。简历上写的微服务，只要是发生了多个服务之间的写操作，都需要进行分布式事务控制。2，在客户端的配置文件中，可以配置某一个服务调用的负载均衡策略(局部)
49. 【Java】JDK 21的虚拟线程（上）：革命性的并发模型
gugucoding的博客
08-17 496
本文深入解析JDK 21引入的虚拟线程（Virtual Threads）技术，从传统平台线程的资源瓶颈出发，阐述虚拟线程的轻量级特性、M:N调度模型及其工作原理。详细介绍了两种创建虚拟线程的方法，并通过性能对比实验展示其在I/O密集型场景下的显著优势。总结了虚拟线程的适用场景、使用注意事项以及与平台线程的核心差异，帮助开发者掌握这一革命性的并发编程工具。
Java Spring 批量修改
最新发布
LYBWWP
08-19 16
本文描述了一个批量更新车辆类型的接口实现。该功能通过Controller层接收包含出库单ID列表和车辆类型的请求参数，调用Service层进行处理。实现层采用事务管理，首先验证参数有效性，然后查询对应出库单数据并批量更新车辆类型字段，最后返回操作结果（成功更新记录数或错误信息）。该接口主要用于快递业务中其他出库单的车辆类型批量修改操作，包含完整的参数校验、异常处理和事务管理机制。
Spring AI Alibaba 入门开发2-提示词功能、提示词模板、格式化输出
geminigoth的博客
08-15 406
Prompt基础：详细讲解了Prompt的设计原理、结构化角色（SYSTEM/USER/ASSISTANT/TOOL）及其在对话中的作用，通过Java代码示例展示了不同角色的使用方式。 Prompt模板：介绍了PromptTemplate类的动态内容插入功能，演示了从字符串模板和文件模板生成提示的方法，以及多角色设定的实现。 结构化输出：阐述了如何通过Converter将模型响应转换为JSON/Java对象等结构化数据，提供了BeanOutputConverter的实际应用示例。
零信任架构实战：基于天远企业年报信息核验构建自动化供应商准入网关
2501_94042197的博客
08-19 164
破解供应商准入核查痛点：从传统人工资质初筛到自动化数据穿透 在大型 B2B 供应链采购平台的微服务架构中，供应商准入尽职调查（KYC）是保障平台交易生态健康的核心防线。传统的准入流程往往依赖业务人员手工收取企业营业执照、年度审计报告等纸质或电子扫描件，并登录多平台逐一核对。这种模式不仅流程繁琐、效率极低，而且难以实时防范非存续异常主体或信息不匹配资质的问题，
家政派单系统开发实战：架构设计与派单算法指南
zww8949111的博客
08-18 285
家政派单系统是连接用户需求与上门服务人员的核心调度平台，其开发难点并不在于简单的CRUD，而是在于如何设计一套能支撑“多角色、多任务类型、高并发抢单”的架构，以及一套能让订单和师傅效率化的派单算法。一旦师傅手动拒绝系统派单，近1小时的接单权重下降50%，防止师傅只接高价单而忽略普通单，导致用户体验受损。建议优先搭建一个可配置化的规则引擎，将派单距离、服务类目、师傅等级做成后台可调整的配置项，这样后期运营调整策略时，无需修改代码。师傅接单后的轨迹追踪，是提升用户体验的关键，也是开发的难点。
Helm Chart依赖管理实战
m0_52572472的博客
08-17 222
在kind: Podmetadata:spec:关键注解说明：标记为测试 Hook：测试成功后自动删除 Pod。
华为OD机试真题精讲：求幸存数之和（Python/Java/C++多语言实现）
bkspiderx的博客
08-17 23
华为OD机试真题：求幸存数之和 问题概述 给定一个整数序列和淘汰步长k，按照约瑟夫环规则淘汰数字，直到剩余m个元素（m为原序列长度的一半，向下取整），计算剩余元素的和。 核心解法 约瑟夫环变种：循环计数并淘汰第k个元素，直到剩余元素数量达标 关键公式：(current_idx + k - 1) % len(arr)计算待淘汰元素索引 复杂度：O(n^2)，符合题目要求 实现要点 Python：利用列表和取模运算简洁实现 Java：使用ArrayList处理元素删除 C++：通过vector高效操作序列 示例
Task.Run 和 Thread.Start区别
日月清心
08-14 232
Task.Run是现代 .NET 中推荐的并发方式，基于线程池，高效且易于异步编程。是更底层的线程控制方式，适合需要长期运行或精细控制线程属性的场景。在大多数情况下，优先考虑Task.Run或；只有在确实需要专用线程时才使用Thread。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值