java的接口

最新推荐文章于 2024-08-28 20:58:28 发布
最新推荐文章于 2024-08-28 20:58:28 发布
阅读量259 收藏
点赞数
分类专栏： JavaEE 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44119864/article/details/123077471
版权

接口

定义

接口相当于特殊的抽象类，定义方式、组成部分与抽象类类似。没有构造方法，不能创建对象.只能定义：公开静态常量、公开抽象方法

特点

  1. 使用interface关键字定义接口
    • interface 接口名{}
    • 接口中abstract关键字可以省略
  2. 类实现接口使用implements表示
    • class 类名 implements 接口名 {}
  3. 接口不能实例化
    • 接口按照多态的形式实例化
  4. 接口的子类
    • 可以是接口，使用extends继承
    • 可以是抽象类，但是意义不大
    • 可以是实体类，需要重写接口中所有的抽象方法（使用最多）
  5. 接口中的成员变量必须是静态的、最终、公共的，也就是常量
    • public、static、final关键字可以省略
public interface MyInterface {
    //公开的静态常量
    String num = "vadv";
    //公开的抽象方法
    void method();
}

通过implements实现接口,并且重写所以接口中的方法

public class TestInterface {
    public static void main(String[] args) {
        //接口 变量=new 实现接口的类
        MyInterface myInterface = new Impl();
        //调用方法
        myInterface.method();
    }
}

class Impl implements MyInterface {
//覆盖接口method方法
    @Override
    public void method() {
        System.out.println("实现接口");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dgfrB8Qh-1645535351940)(F:\笔记文件\JavaSE\10、接口\接口.assets\image-20210921012121319.png)]

//接⼝1
public interface MyInterface {
    //定义了静态常量 static final 可以省略
    static final String NAME = "⼩红";
    //定义了抽象⽅法
    public void method();
    //定义了抽象⽅法
    public void method2();
}
//接⼝2 继承了接⼝1
public interface MyInterface2 extends MyInterface {
    //定义了抽象⽅法
    public void method2();
}
//定义实现类实现接⼝
public class MyInterfaceSon implements MyInterface2{
    //重写抽象⽅法
    @Override
    public void method() {
    	System.out.println("重写method抽象⽅法");
    }
    //重写抽象⽅法
    @Override
    public void method2() {
    	System.out.println("重写method2抽象⽅法");
    }
}

好处

  • 降低程序的耦合度
  • 更自然的使用多态
  • 设计和实现完全分离
  • 更加容易搭建程序框架
  • 更加容易更换具体实现

接口与类的异同

类与类

  • 继承关系只能单继承，不能多继承，但是可以多层继承
  • 多继承：子类继承父类，父类继承祖父类
  • 如果多个父类出现相同的方法，无法区分

类与接口

  • 实现关系可以单实现，也可以多实现，在继承的同时可以多实现
  • 多个接口出现了名称、参数列表相同的方法，但是返回值不同，会报错

接口与接口

  • 继承关系，可以单继承，也可以多继承
  • 如果多个父类出现了相同的，子类用谁都可以

接口与抽象类

相同：

  • 可编译成字节码文件。
  • ​ 不能创建对象。
  • ​ 可以作为引用类型。
  • ​ 具备Object类中所定义的方法。

不同：

  • 所有属性都是公开静态常量，隐式使用public static final修饰。
  • 所有方法都是公开抽象方法，隐式使用public abstract修饰。
  • 没有构造方法、动态代码块、静态代码块。
  • 一个类只能继承一个抽象类，但是一个类可以实现多个接口
  • 抽象类有实例变量，接口只有类变量

为解决多继承关系，Java8提供了下⾯三条规则：

  • 类中的⽅法优先级最⾼，类或⽗类中声明的⽅法的优先级⾼于任何声明为默认⽅法的优先
    级。
  • 如果第⼀条⽆法判断，那么⼦接⼝的优先级更⾼：⽅法名相同时，优先选择拥有最具体实现的默认⽅法的接⼝， 即如果B继承了A，那么B就⽐A更加具体。
  • 如果还是⽆法判断，继承了多个接⼝的类必须通过显式覆盖和调⽤期望的⽅法， 显式地选择使⽤哪⼀个默认⽅法的实现。
public interface A {
    default void hello() {
	System.out.println("hello from A");
	}
}
public interface B extends A {
    default void hello() {
    	System.out.println("hello from B");
    }
}
public class C implements A, B {
    public static void main(String[] args) {
    	new C().hello();
    }
}

因为B继承了A，所以B⽐A更具体，所以应该选择B的hello()⽅法。所以，程序会打印输
出"hello from B"。

public interface A {
    default void hello() {
    	System.out.println("hello from A");
    }
}
public interface B extends A {
    default void hello() {
    	System.out.println("hello from B");
    }
}
public class D implements A {
}
public class C extends D implements A, B {
    public static void main(String[] args) {
    	new C().hello();
    }
}

C虽然继承了D，但D中未覆盖A的默认⽅法，接着，编译器会在A和B中做选择，由于B更具体，所以，程序会打印输出"hello from B"。

public interface A {
    default void hello() {
    	System.out.println("hello from A");
    }
}
public interface B extends A {
    default void hello() {
    	System.out.println("hello from B");
    }
}
public class D implements A {
    public void hello() {
    	System.out.println("hello from D");
    }
}
public class C extends D implements A, B {
    public static void main(String[] args) {
    	new C().hello();
    }
}

⽗类中声明的⽅法具有更⾼的优先级，所以程序会打印输出"hello from D"。

public interface A {
    default void hello() {
    	System.out.println("hello from A");
    }
}
public interface B {
    default void hello() {
    	System.out.println("hello from B");
    }
}
public class C extends D implements A, B {
    public static void main(String[] args) {
    	new C().hello();
    }
}

由于编译器⽆法识别A还是B的实现更加具体，所以会抛出编译错误：”C inherits unrelateddefaults for hello() from types A and B“。

像这种场景要解决冲突，可以在C中覆盖hello()⽅法并在⽅法内显示的选择调⽤A还是B的⽅法。

public class C extends D implements A, B {
    public void hello() {
        // 显式地选择调⽤接⼝B中的⽅法
        // 同理，要调⽤接⼝A中的⽅法，可以这样：A.super.hello()
        B.super.hello();
}
    public static void main(String[] args) {
        // 输出 hello from B
        new C().hello();
    }
}

public interface A {
    default void hello() {
        System.out.println("hello from A");
    }
}
public interface B extends A{
}
public interface C extends A{
}
public class D implements B, C {
    public void hello() {
    	new D().hello();
    }
}

只有⼀个⽅法申明可以选择，所以程序会输出"hello from A"。

默认方法

在1.8以后，接口中存在默认的方法

public interface Sized {
    // 普通抽象⽅法，默认是public abstract修饰的，没有⽅法体
    int size();
    /*
    * 默认⽅法，有⽅法体
    * 任何⼀个实现了Sized接⼝的类都会向动继承isEmpty的实现
    */
    default boolean isEmpty() {
    return this.size() == 0;
    }
}

应用

//飞翔接口
public interface MyInterface {
 void fly();
}

public class TestInterface {
    public static void main(String[] args) {
        Impl impl = new Impl("jack");
        impl.fly();
        System.out.println("*****使用多态********");
        MyInterface myInterface = new Impl("mkie");
        myInterface.fly();
    }
}

class Impl implements MyInterface {
    String name;
    //带参构造方法
    public Impl(String name) {
        this.name = name;
    }

    //覆盖原来fly方法，实现方法体
    @Override
    public void fly() {
        System.out.println(name + "在飞翔");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NTWxOz2e-1645535351942)(F:\笔记文件\JavaSE\10、接口\接口.assets\image-20210921090759851.png)]

规范

  • 任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类。
  • 实现接口中的抽象方法时，访问修饰符必须是public。

引用

  • 同父类一样，接口也可声明为引用，并指向实现类对象。interface 对象名 = new 实现类()
  • 仅可调用接口中所声明的方法，不可调用实现类中独有的方法。
  • 可强转回实现类本身类型，进行独有方法调用。
  • 特殊：通过接口可调用0bject中的公开方法]

接口的多态

//飞翔接口
interface MyInterface {
    void fly();
}

//父类：抽象类
abstract class Animal {
    public void eat() {
        System.out.println("吃......");
    }
}

//子类继承父类，并且时间接口
class Dog extends Animal implements MyInterface {

    @Override
    public void fly() {
        System.out.println("飞翔....");
    }
    //子类特有方法
    public void run() {
        System.out.println("跑.....");
    }
}

class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.run();
        System.out.println("****以下是多态****");
        Animal animal = new Dog();
        animal.eat();
        MyInterface myInterface = new Dog();
        myInterface.fly();
    }
}

常见关系

  1. 类与类
    • 单继承 extends 父类名称
  2. 类与接口
    • ​ 多实现 implements 接口名称1，接口名称2，接口名称n
  3. 接口与接口：
    • 多继承 extends父接口1，父接口2，父接口n

常量接口、标记接口

常量接口将多个常用于表示状态或固定值的变量，以静态常量的形式定义在接口中统一管理；提高代码可读性。

//常量接口
public interface ConstInterface {
   String CONST="AAA";
}
class TestConstInterface{
    public static void main(String[] args) {
        if (ConstInterface.CONST.equals("AAA")){
            System.out.println(ConstInterface.CONST);
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JdIp9WyD-1645535351942)(F:\笔记文件\JavaSE\10、接口\接口.assets\image-20210921093658501.png)]

标记接口中没有包含任意成员，仅仅用作标记。
Serializable：序列化
Cloneable：克隆

接口回调

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bIgdijLQ-1645535351943)(F:\笔记文件\JavaSE\10、接口\接口.assets\20210813165040879_28759.png)]

class TestUsb {
    public static void main(String[] args) {
        //实例化
        Computer computer = new Computer();
        Usb mouse = new Mouse();
        Usb fan = new Fan();
        Usb Upan = new Upan();
        //将usb1、2、3赋值，在run方法在判断，只要不为空，就会根据数据类型调用service()
        computer.usb1 = Upan;
        computer.usb2 = fan;
        computer.usb3 = mouse;
        computer.run();

    }
}

public interface Usb {
    void service();
}

class Upan implements Usb {
    @Override
    public void service() {
        System.out.println("U盘连接电脑成功，开始工作。。。");
    }
}

class Fan implements Usb {
    @Override
    public void service() {
        System.out.println("风扇连接电脑成功，开始工作。。。");
    }
}

class Mouse implements Usb {
    @Override
    public void service() {
        System.out.println("鼠标连接电脑成功，开始工作。。。");
    }
}

class Computer {
    Usb usb1;
    Usb usb2;
    Usb usb3;

    public void run() {
        System.out.println("电脑开始工作......");
        if (usb1 != null) {
            usb1.service();
        }
        if (usb2 != null) {
            usb2.service();
        }
        if (usb3 != null) {
            usb3.service();
        }
    }
}

总结

什么是接口

微观：接口是一种能力和约定。
宏观；接口是一种标准。

接口与类的异同

没有构避方法，仅可定义公开静态常量与公开抽象方法。

接口的应用

Java为单继承，当父类的方法种类无法满足子类需求时，可实现接口扩充子类能力。

接口的规范

任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类。
实现接口中的抽象方法时，访问修饰符必须是public。

什么是常量接口

将多个常用于表示状态或固定值的变量，以静态常量的形式定义在接口中统一管理。

什么是接口回调

先有接口的使用者，后有接口的实现者。

接口的好处

程序的耦合度降低。
更自然的使用多态。
设计与实现完全分离。
更容易搭建程序框架。

93800797.png" alt="image-20210921093800797" style="zoom:67%;" />

总结

什么是接口

微观：接口是一种能力和约定。
宏观；接口是一种标准。

接口与类的异同

没有构避方法，仅可定义公开静态常量与公开抽象方法。

接口的应用

Java为单继承，当父类的方法种类无法满足子类需求时，可实现接口扩充子类能力。

接口的规范

任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类。
实现接口中的抽象方法时，访问修饰符必须是public。

什么是常量接口

将多个常用于表示状态或固定值的变量，以静态常量的形式定义在接口中统一管理。

什么是接口回调

先有接口的使用者，后有接口的实现者。

接口的好处

程序的耦合度降低。
更自然的使用多态。
设计与实现完全分离。
更容易搭建程序框架。
更容易更换具体实现。
night_du
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 接口
05-25
Java接口是Java编程语言中的一个重要概念，它是定义行为规范的蓝图，允许类之间进行多态性的实现。在Java中，接口是一种完全抽象的类型，它只包含常量定义和抽象方法，不包含任何实例变量。接口是Java实现面向接口...
java接口方法不实现可以用_关于Java：为什么接口不能实现另一个接口？
weixin_31200621的博客
02-26 1841
我的意思是：interface B {...}interface A extends B {...} // allowedinterface A implements B {...} // not allowed我在谷歌上找到了这个：implements denotes defining an implementation for the methods of an interface. Howe...
详解java接口interface
06-17
Java 接口详解 Java 接口是 Java 语言中的一种特殊的抽象类，它定义了一组抽象方法和默认方法，用于规范多个类之间的公共行为。在本文中，我们将详细介绍 Java 接口的定义、抽象方法、默认方法、实现类和使用方法。...
C#调用Java接口演示
09-21
本示例主要探讨的是如何使用C#调用Java接口，实现不同编程语言之间的交互。C#和Java都是广泛应用的编程语言，它们各自拥有丰富的库和生态系统，但有时需要在两者之间建立桥梁，以利用各自的优点。本文将详细介绍这一...
Java接口教程
04-10
本教程将深入探讨Java接口的各个方面，包括其重要性、使用场景、语法特点以及与类的关联。 1. **接口的概念**： Java接口是定义一组方法签名的蓝图，这些方法没有具体实现。它们用于定义类必须遵循的行为协议，...
Vue调用后端java接口的实例代码
10-16
在了解Vue如何调用后端Java接口的过程中，我们首先需要明确几个关键点：前端技术栈的构成、后端Java服务的设计、以及前后端数据交互的方式。本实例将围绕Vue前端框架和Java后端服务之间如何进行通信展开，重点介绍...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 2152
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 2506
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 2763
linux上datax 安装以及使用
操作系统原子操作
zzt_is_me的博客
08-28 894
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
最新发布
weixin_39996520的博客
08-28 708
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 473
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 1289
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
C++的内存模型
qhu1600417010的博客
08-28 744
C++ 的内存模型包含了程序运行时如何分配、访问、管理内存的规则，涵盖了多线程环境下的数据一致性、内存对齐、以及虚拟内存管理等内容。掌握这些概念对于编写高效、安全的 C++ 程序至关重要。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 1464
@Transactional中使用线程锁导致了锁失效与解决方案
SpringBoot日常：扩展接口之CommandLineRunner和ApplicationRunner
qq_32590535的博客
08-28 370
日常开发中我们可能经常会遇到这样的场景，像启动容器完成后需要去执行一些业务逻辑，SpringBoot给我们提供了两个接口来帮助我们实现这种需求，两个启动加载接口分别是CommandLineRunner和ApplicationRunner。本文简单介绍如何使用该扩展点实现业务。
Java学习_18_Stream流
qq_41136689的博客
08-23 1878
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV17F411T7Ao流的出现让数据处理从几十行代码缩减到一两行就能实现，简化了很多集合数组的操作。
JavaScript 错误 - Throw 和 Try to Catch的使用
逆风优雅的博客
08-23 873
trycatchthrow上面的代码 因为 try中 没有adddlert这个方法，或者这个方法有误，这时，代码会执行catch部分。JavaScript 实际上会创建带有两个属性的Error 对象name和message。
Java面试宝典-java基础02
杜盟恩的博客
08-27 622
机器语言是一种指令集的体系，是最早出现的计算机语言。机器语言从属于硬件设备。不同的计算机设备有不同的机器语言．所以机器语言是一种面向机器的语言。计算机指令系统中的指令是由“0”和“1”两种符号组成的代码，并且能被机器直接理解执行，它们被称为机器指令。一个计算机的机器指令的集，就构成了该计算机的机器语言，即计算机可以直接接受、理解的语言。机器语言能利用机器指令精准地描述算法、且编程质量高、所占存储空间小，执行速度快。但是这种程序直观性很差，容易出错，阅读检查和修改调试非常困难。
Java接口
06-02
Java 接口是一种特殊的抽象类，它只包含了常量和抽象方法的定义，没有实现。Java 接口定义了一组方法签名，但是并不提供实现细节。这些方法由实现接口的类来提供实现细节，从而实现多态性和灵活性。 Java 接口使用 `interface` 关键字来声明，接口中的方法默认为 `public` 和 `abstract`，可以省略这两个关键字。接口中只能定义常量和抽象方法，不能定义变量和实例方法。实现接口的类需要实现接口中所有的抽象方法，否则需要将这个类也声明为抽象类。 以下是一个简单的 Java 接口定义示例： ```java public interface Drawable { int DEFAULT_COLOR = 0xffffff; // 定义一个常量 void draw(); // 定义一个抽象方法 } ``` 以上示例定义了一个名为 `Drawable` 的接口，包含了一个常量 `DEFAULT_COLOR` 和一个抽象方法 `draw()`。实现这个接口的类需要提供 `draw()` 方法的实现细节，并可以使用常量 `DEFAULT_COLOR` 来进行绘制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值