Java接口（精解）

已于 2023-10-20 08:45:07 修改
阅读量43 收藏
点赞数 1
分类专栏： javaSE 文章标签： java 开发语言
于 2023-08-27 21:40:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75367406/article/details/132526922
版权

一句话概括就是：在Java中，接口可以看成是多个类的公共规范，是一种引用数据类型。

1.语法规则

        接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。简单来说就是使用interface修饰的类就是接口。

public interface 接口名称{
// 抽象方法
    public abstract void method1(); // public abstract 是固定搭配，可以不写
    void method4();//不写的情况下，编译器会自动带上public abstract，这样显得简洁
    // 在接口中方法都是抽象方法，
}
  1. 创建接口时, 接口的命名一般以大写字母 I 开头.
  2. 接口的命名一般使用 "形容词" 词性的单词.
  3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性

2.接口的实现

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

//实现接口需要用到关键字implements

public class 类名称 implements 接口名称{
        // ...
}

下面是一个接口的使用举例：

这里要注意初学者容易犯的错误：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系！ 

public interface Iusb {
    void openDevice();
    void closeDevice();
}

public class KeyBoard implements Iusb{

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

    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }
    public void rapKeyBoard(){
        System.out.println("敲击键盘");
    }
}
public class Mouse implements Iusb{

    @Override
    public void openDevice() {

        System.out.println("打开鼠标");
    }

    @Override
    public void closeDevice() {

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

        System.out.println("使用鼠标");
    }
}
public class Computer{

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

    public void closeComputer() {
        System.out.println("关闭电脑");
    }
    public void useDevice(Iusb iusb){
        iusb.openDevice();
        if(iusb instanceof Mouse){
            Mouse mouse = (Mouse) iusb;
            mouse.useMouse();
        } else if (iusb instanceof KeyBoard) {
            KeyBoard keyBoard = (KeyBoard) iusb;
            keyBoard.rapKeyBoard();
        }
        iusb.closeDevice();
    }
}
public class Exercise {
    public static void main(String[] args) {
        Computer computer = new Computer();
        KeyBoard keyBoard = new KeyBoard();
        Mouse mouse = new Mouse();
        computer.openComputer();
        computer.useDevice(mouse);
        computer.useDevice(keyBoard);
        computer.closeComputer();
    }
}

3.接口的特性

  1. 接口类型是一种引用类型，但是不能直接new接口的对象
  2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错)
  3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现
  4. 重写接口中方法时，不能使用默认的访问权限
  5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
  6. 接口中不能有静态代码块和构造方法
  7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
  8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
  9. jdk8中：接口中还可以包含default方法。
public class Test {
    public static void main(String[] args) {
    IUSB usb = new IUSB();
    }
}
//会报错IUSB是抽象的，无法实例化
public interface USB {
    // Error:(4, 18) java: 此处不允许使用修饰符private
    private void openDevice();
    void closeDevice();
}
public interface USB {
    void openDevice();
    // 编译失败：因为接口中的方式默认为抽象方法
    // Error:(5, 23) java: 接口抽象方法不能带有主体
    void closeDevice(){
    System.out.println("关闭USB设备");
    }
}
public interface USB {
    void openDevice(); // 默认是public的
    void closeDevice(); // 默认是public的
}
public class Mouse implements USB {
    @Override
    void openDevice() {
        System.out.println("打开鼠标");
    } // ...
}
public interface USB {
    double brand = 3.0; // 默认被：final public static修饰
    void openDevice();
    void closeDevice();
}
public class TestUSB {
    public static void main(String[] args) {
    System.out.println(USB.brand); // 可以直接通过接口名访问，说明是静态的
    // 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值
    USB.brand = 2.0; // 说明brand具有final属性
    }
}

public interface USB {
// 编译失败
    public USB(){

    } 
{} // 编译失败
    void openDevice();
    void closeDevice();
}

4.多接口的实现

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

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

下面用一个通过类来表示动物的例子说明：

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

public interface IFly {
    void fly();
}

public interface IRun {
    void run();
}

public interface IWming {
    void wming();
}

class Dog extends Animal implements IRun{
    public Dog(String name){
        super(name);
    }
    @Override
    public void run() {
        System.out.println(name+"在用两条狗腿跑");
    }
}
class Fish extends Animal implements IWming{
    public Fish(String name){
        super(name);
    }

    @Override
    public void wming() {
        System.out.println(name+"在水里游");
    }
}
class Bord extends Animal implements IFly{
    public Bord(String name){
        super(name);
    }

    @Override
    public void fly() {
        System.out.println(name+"在用翅膀飞");
    }
}
class Duck extends Animal implements IFly,IRun,IWming{
    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 wming() {
        System.out.println(name+"在水面上游");
    }
}
public class Exercise1 {
    public static void walk1(IRun iRun){
        iRun.run();
    }
    public static void walk2(IFly iFly){
        iFly.fly();
    }
    public static void walk3(IWming iWming){
        iWming.wming();
    }

    public static void main(String[] args) {
        walk1(new Dog("旺财"));
        walk1(new Duck("唐老鸭"));
        System.out.println("==============");
        walk2(new Bord("隼"));
        walk2(new Duck("唐老鸭"));
        System.out.println("==============");
        walk3(new Fish("小鲤鱼"));
        walk3(new Duck("唐老鸭"));
    }
}

        上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口。这样设计可以使你时刻牢记多态的好处，让程序猿忘记类型，有了接口之后，类的使用者就不必关注具体类型，而只关注某个类是否具备某种能力。

5.接口间的继承

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

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

}
class Frog implements IAmphibious {
    ...
}

        此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法。接口间的继承相当于把多个接口合并在一起。

6.抽象类和接口的区别

        抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别(重要!!! 常见面试题).
        核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.
        如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口。

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

再次提醒:
        抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类.万一不小心创建了 Animal 的实例, 编译器会及时提醒我们.

这里引用一张图来说明二者的主要区别：

7.Object类

        Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收。

        可以说它是所有类的超类。在Java中，每个类都直接或间接地继承自Object类。

        Object类提供了一些通用的方法，这些方法可以在任何类中使用。以下是Object类的一些常用方法：

  1. equals(Object obj)：用于比较两个对象是否相等。默认情况下，它比较的是两个对象的引用是否相等，但可以在子类中重写该方法以实现自定义的相等比较逻辑。
  2. hashCode()：返回对象的哈希码值。默认情况下，它返回对象的内存地址的整数表示，但可以在子类中重写该方法以提供自定义的哈希码逻辑。
  3. toString()：返回对象的字符串表示。默认情况下，它返回类名和对象的哈希码，但可以在子类中重写该方法以提供自定义的字符串表示。
  4. getClass()：返回对象的运行时类。它返回一个Class对象，该对象包含了对象的类的元数据信息。
  5. clone()：创建并返回对象的一个副本。默认情况下，它会抛出CloneNotSupportedException异常，但可以在子类中实现Cloneable接口并重写该方法以支持对象的克隆。
  6. finalize()：在对象被垃圾回收器回收之前调用。默认情况下，它不执行任何操作，但可以在子类中重写该方法以实现资源释放等清理操作。

Object类还提供了wait()、notify()和notifyAll()等方法，用于线程间的通信和同步。

        总的来说，Object类是Java中最基础和通用的类，提供了一些常用的方法，可以在所有类中使用。

        以上就是本期全部内容，希望看完后能够对你有所帮助。希望小伙伴们可以点赞收藏加关注，学习知识不迷路，你的三连是前进的动力源泉！

「已注销」
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java网络编程精解_Java网络编程精解之ServerSocket用法详解二(4)
weixin_39604189的博客
02-22 93
如例程3-8所示，EchoServer利用线程池ThreadPool来完成与客户的通信任务。例程3-8 EchoServer.java(使用线程池ThreadPool类)package multithread2;import java.io.*;import java.net.*;public class EchoServer {private int port=8000;private Ser...
【Java】类与对象——精解版
Dong_duan的博客
05-11 68
定义一个类，就相当于在计算机中定义了一种新的类型，用类类型创造对象的过程，称为类的实例化，在Java中通常采用new关键字，配合类来实例化对象。面向过程是以过程为中心的编程思想，其原理就是将问题分解成一个一个详细的步骤，然后通过函数实现每一个步骤，并依次调用。类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象）具体有哪些属性，哪些功能，描述完成之后计算机就可以识别了。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情，面向对象住一套看重解决问题的过程。1.什么是面向对象？
java网络编程精解pdf_Java网络编程精解笔记3:ServerSocket详解
weixin_39642687的博客
02-17 111
ServerSocket用法详解1.C/S模式中,Server需要创建特定端口的ServerSocket.->其负责接收client连接请求.2.线程池->包括一个工作队列和若干工作线程->工作线程不断的从工作队列中取出任务并执行.-->java.util.concurrent->线程池3.server可利用多线程来处理与多个客户的通信任务.1.构造ServerSoc...
java集合精解
Mar.三月
11-17 322
面试常见问题  ArrayList和LinkedList的联系和区别                  1. ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。                  2. 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。                   
Java - 泛型基础 - 精解
chuli0327的博客
10-09 288
泛型 一，什么是泛型 Java泛型设计原则，只要在编译期没有出现警告，那么运行期间就不会出现ClassCastException异常 1.背景: JAVA推出泛型以前，程序员可以构建一个元素类型为Object的集合，该集合能够存储任意的数据对象，而在使用该集合的过程中，需要程序员明确的知道存储每个元素的数据类型，否则很容易引发ClassCastException ，类型转换异常 2.泛型的概念： Java泛...
java基础-java泛型精解
阿猫爱吃鱼
01-07 77
<转载> 1. 概述 在引入范型之前，Java类型分为原始类型、复杂类型，其中复杂类型分为数组和类。引入范型后，一个复杂类型就可以在细分成更多的类型。例如原先的类型List，现在在细分成List<Object>, List<String>等更多的类型。注意，现在List<Object>, List<String>是两种不同的类型，...
Java 8文件操作全攻略：高效读写TXT文件与并发管理精解
Catastrophe的博客
04-14 1272
在本文中，我们深入探讨了使用JDK 8进行TXT文件读写操作的多个方面。通过一系列的示例和解释，我们了解了如何有效地读取、写入、复制、移动、删除文件，以及如何查询和修改文件属性。我们还讨论了在并发环境中处理文件时需要注意的问题，并展示了如何使用语句来自动管理资源。读取文件我们学习了如何使用和方法来读取文件内容。这些方法提供了简单和内存高效的方式来处理文件数据。写入文件我们探索了如何使用和方法来写入文件。这些方法允许我们以原子方式写入内容，确保数据的完整性。文件操作文件的复制、移动和删除操作通过。
Java网络编程精解
CSDN流星追月专属频道--吃的苦中苦，方为人上人！
09-13 2600
资料来源：北软教育 www.softedu.org|专业的java 培训、网络培训、网络安全培训基地 在客户/服务器通信模式中，服务器端需要创建监听特定端口的ServerSocket， ServerSocket 负责接收客户连接请求。本章首先介绍ServerSocket 类的各个构 造方法，以及成员方法的用法，接着介绍服务器如何用多线程来处理与多个客户 的通信任务。 本章提供线程池的一种
OpenFeign源码精解
li350328320的专栏
05-20 981
SpringCloud框架的OpenFeign源码精解，带你走进OpenFeign的实现世界，更好的理解其原理
java网络精解源码
04-23
java网络精解源码 不错值得学习 java网络精解源码
Java知识体系精解
08-10
Java知识体系精解，总结的好。希望能帮到大家，也感谢未名的原作者。
Java网络编程精解PPT课件.ppt
11-23
Java网络编程精解PPT课件.ppt
Java网络编程精解之ServerSocket用法详解
09-02
在客户/ 服务器通信模式中， 服务器端需要创建监听特定端口的 ServerSocket ， ServerSocket 负责接收客户连接请求。...章还介绍了 java.util.concurrent 包中的线程池类的用法，在服务器程序中可以直接使用它们。
JAVA EE WEB开发实例精解
12-29
JAVA EE WEB开发实例精解
Spring 事务传播行为之Propagation.NESTED REQUIRES_NEW等探讨
最新发布
chengmin123456789的博客
06-17 76
当一个事务方法（标记为@Transactional(propagation = Propagation.NESTED))被另一个活动事务调用时，它会创建一个“保存点”（Savepoint）作为新的事务开始点。这意味着，如果这个嵌套事务方法内部发生异常并导致回滚，事务会回滚到这个保存点，而不会影响到外部事务的其他操作。如果一切正常，嵌套事务会在外部事务结束时一起提交。
【仿真建模-anylogic】FlowchartPort原理解析
zhaoyaxuan001的博客
06-14 312
FlowchartPort是流图组件端口的基类，一般不会直接使用；如果需要自行封装组件库时会用到；FlowchartPort继承Port类，并定义了一系列抽象函数；用于输入端口判定此刻是否不能接收Agent。用于输出端口判定是否有Agent准备离开。判定端口是否发生错误。
盲盒App开发时有哪些技术框架可以借鉴
bytekj的博客
06-14 533
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 399
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
opencv算法精解
09-06
下面我将介绍两个常用的OpenCV算法精解。 第一个是位运算算法，其中包括了位与（bitwise_and）和位或（bitwise_or）运算。位与运算将两个图像的对应像素进行逐位比较，如果两个像素的对应位都为1，则结果图像对应...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值