AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java基础接口详解

2023-08-08 98
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 RDS MySQL，集群系列 2核4GB
推荐场景：
搭建个人博客
RDS MySQL Serverless 基础系列，0.5-2RCU 50GB
推荐场景：
学生管理系统数据库设计 搭建个人博客
RDS MySQL Serverless 高可用系列，价值2615元额度，1个月
简介： Java基础接口详解

Java基础接口详解

文末附上下载详解pdf链接

实现java代码中接口详细分析

Java基础接口是一种定义了一组方法签名但没有提供实际实现的抽象类似的结构。它们允许类通过实现接口来声明自己拥有某些特定的行为。接口在Java中扮演了重要的角色，以下是一些关键点：

定义

当使用`interface`关键字来定义接口时，可以像下面这样创建一个简单的接口示例：
// 定义一个接口
interface MyInterface {
    void doSomething(); // 声明一个抽象方法
    int calculate(int x, int y); // 声明另一个抽象方法
}
// 实现接口
class MyClass implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("MyClass is not doing something.");
    }
    @Override
    public int calculate(int x, int y) {
        return x + y;
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.doSomething();
        int result = myClass.calculate(5, 3);
        System.out.println("Calculation result: " + result);
    }
}

上例中，我们首先定义了一个名为MyInterface的接口，它包含两个抽象方法：doSomething和calculate。然后，我们创建了一个实现了MyInterface接口的MyClass类，提供了这两个方法的具体实现。最后，在Main类中，我们实例化了MyClass对象，并调用了接口中声明的方法。

方法签名

接口中的方法没有方法体，只有方法签名，即方法名和参数列表，例如：void someMethod(int param);。

当创建接口方法时，您只需要提供方法的签名，而不需要方法体。以下是一个示例，展示了如何在接口中定义方法签名：

// 定义一个接口
interface MyInterface {
    void doSomething(int x, double y); // 方法签名，没有方法体
    String formatData(String data); // 另一个方法签名
}
// 实现接口
class MyClass implements MyInterface {
    @Override
    public void doSomething(int x, double y) {
        System.out.println("MyClass is doing something with x = " + x + " and y = " + y);
    }
    @Override
    public String formatData(String data) {
        return "Formatted: " + data;
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.doSomething(10, 3.14);
        String formatted = myClass.formatData("Hello, World!");
        System.out.println(formatted);
    }
}

在上述的代码中，我们在MyInterface接口中定义了两个方法签名：doSomething和formatData。然后，我们创建了一个实现了MyInterface接口的MyClass类，为这两个方法提供了具体的实现。在Main类中，我们实例化了MyClass对象，并调用了这些方法，但接口中的方法体并没有实现。

实现

类通过使用implements关键字来实现接口，从而承诺实现接口中声明的所有方法。

当类需要实现一个接口时，可以使用 `implements` 关键字来表示该类承诺要实现接口中声明的所有方法。以下是一个示例，展示了如何使用 `implements` 关键字来实现接口：
// 定义一个接口
interface MyInterface {
    void doSomething(); // 声明一个抽象方法
    int calculate(int x, int y); // 声明另一个抽象方法
}
// 实现接口的类
class MyClass implements MyInterface {
    @Override
    public void doSomething() {
        System.out.println("MyClass is doing something.");
    }
    @Override
    public int calculate(int x, int y) {
        return x + y;
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.doSomething();
        int result = myClass.calculate(5, 3);
        System.out.println("Calculation result: " + result);
    }
}

在上述示例中，我们定义了一个名为 MyInterface 的接口，并在 MyClass 类中使用 implements 关键字来实现该接口。因此，MyClass 承诺实现了 MyInterface 中声明的所有方法。在 Main 类中，我们实例化了 MyClass 对象，并调用了接口中声明的方法。

多继承

Java支持多继承接口，一个类可以实现多个接口，但只能继承一个父类。

当一个类需要实现多个接口时，可以使用逗号将这些接口名称分开，以实现多继承的效果。然而，Java中并不支持直接的多继承（继承多个类），但可以通过实现多个接口来达到类似的目的。以下是一个示例，展示了如何实现多个接口：

// 定义多个接口
interface Walkable {
    void walk();
}
interface Swimmable {
    void swim();
}
// 实现多个接口的类
class Human implements Walkable, Swimmable {
    @Override
    public void walk() {
        System.out.println("Human is walking.");
    }
    @Override
    public void swim() {
        System.out.println("Human is swimming.");
    }
}
public class Main {
    public static void main(String[] args) {
        Human person = new Human();
        person.walk();
        person.swim();
    }
}

在上述示例中，我们定义了两个接口 Walkable 和 Swimmable，分别包含了 walk 和 swim 方法的声明。然后，我们创建了一个名为 Human 的类，通过使用 implements 关键字来实现这两个接口。由于 Java 不支持多继承（即继承多个类），我们可以通过实现多个接口来实现类似的效果。

在 Main 类中，我们实例化了 Human 对象，并调用了 walk 和 swim 方法，这些方法分别来自于两个不同的接口。

默认方法（Java 8+）

接口可以包含默认方法，这些方法有默认实现，可以在实现类中直接继承或覆盖。

当接口引入了默认方法（Java 8+），可以在接口中提供默认实现，而不再要求每个实现类都必须提供相同的代码。同时，接口还可以定义静态方法，这些方法可以直接在接口上调用，与接口的实例无关。以下是这两个概念的示例代码：

默认方法示例：

// 定义接口
interface MyInterface {
    // 抽象方法
    void someMethod();
    // 默认方法
    default void defaultMethod() {
        System.out.println("This is a default method in MyInterface.");
    }
}
// 实现接口
class MyClass implements MyInterface {
    @Override
    public void someMethod() {
        System.out.println("MyClass is implementing someMethod.");
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.someMethod();
        myClass.defaultMethod(); // 可以调用默认方法
    }
}

静态方法（Java 8+）

接口还可以定义静态方法，这些方法在接口上调用，与接口的实例无关。

静态方法示例：

// 定义接口
interface MyInterface {
    // 静态方法
    static void staticMethod() {
        System.out.println("This is a static method in MyInterface.");
    }
}
public class Main {
    public static void main(String[] args) {
        MyInterface.staticMethod(); // 直接在接口上调用静态方法
    }
}

在默认方法示例中，我们在 MyInterface 接口中定义了一个抽象方法 someMethod 和一个默认方法 defaultMethod。在实现类 MyClass 中，我们只需要实现抽象方法，而默认方法会被继承。

在静态方法示例中，我们在 MyInterface 接口中定义了一个静态方法 staticMethod，可以直接在接口上调用，无需实例化接口。

上述这两个示例展示了默认方法和静态方法在接口中的用法。

常量

接口中可以定义常量，默认为public static final，因此在实现类中可以直接使用。

在接口中定义常量非常简单，只需声明一个字段，并使用 public static final 修饰，然后在实现类中可以直接使用这些常量。以下是一个示例代码，展示了如何在接口中定义常量以及如何在实现类中使用：

// 定义接口
interface MyInterface {
    // 声明常量
    public static final int CONSTANT_VALUE = 42;
}
// 实现接口
class MyClass implements MyInterface {
    void printConstant() {
        System.out.println("Constant value: " + CONSTANT_VALUE); // 直接使用接口中的常量
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.printConstant();
    }
}

在上述示例中，我们在 MyInterface 接口中定义了一个常量 CONSTANT_VALUE，使用了 public static final 修饰。在 MyClass 实现类中，我们可以直接使用接口中定义的常量，无需任何其他操作。

在 Main 类中，我们实例化了 MyClass 对象并调用了 printConstant 方法，该方法输出了接口中定义的常量值。

用途

接口用于实现多态性、代码组织、解耦和共享代码等，常用于定义通用行为，如Comparable和Runnable。

接口在实现多态性、代码组织、解耦和共享代码等方面非常有用。以下是一些示例代码，展示了接口的这些用途：

  1. 实现多态性：
// 定义接口
interface Shape {
    double calculateArea();
}
// 实现接口
class Circle implements Shape {
    double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}
class Rectangle implements Shape {
    double width, height;
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    @Override
    public double calculateArea() {
        return width * height;
    }
}
public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);
        System.out.println("Circle area: " + circle.calculateArea());
        System.out.println("Rectangle area: " + rectangle.calculateArea());
    }
}
  1. 代码组织和解耦：
// 定义接口
interface DatabaseConnection {
    void connect();
    void disconnect();
}
// 实现接口
class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connected to MySQL database.");
    }
    @Override
    public void disconnect() {
        System.out.println("Disconnected from MySQL database.");
    }
}
class OracleConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connected to Oracle database.");
    }
    @Override
    public void disconnect() {
        System.out.println("Disconnected from Oracle database.");
    }
}
public class Main {
    public static void main(String[] args) {
        DatabaseConnection mysql = new MySQLConnection();
        DatabaseConnection oracle = new OracleConnection();
        mysql.connect();
        mysql.disconnect();
        oracle.connect();
        oracle.disconnect();
    }
}
  1. 共享代码：
// 定义接口
interface Logger {
    void log(String message);
}
// 实现接口
class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Logging to console: " + message);
    }
}
class FileLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Logging to file: " + message);
    }
}
public class Main {
    public static void main(String[] args) {
        Logger consoleLogger = new ConsoleLogger();
        Logger fileLogger = new FileLogger();
        consoleLogger.log("This is a console log.");
        fileLogger.log("This is a file log.");
    }
}

上述示例演示了接口在实现多态性、代码组织、解耦和共享代码方面的用途。接口可以帮助您创建灵活、可扩展和可维护的代码。

接口继承

一个接口可以继承另一个接口，通过extends关键字。

继承的接口将继承父接口的方法声明。以下是一个示例代码，展示了接口继承的用法：

// 定义父接口
interface ParentInterface {
    void parentMethod();
}
// 定义子接口，继承父接口
interface ChildInterface extends ParentInterface {
    void childMethod();
}
// 实现子接口
class MyClass implements ChildInterface {
    @Override
    public void parentMethod() {
        System.out.println("Parent method implemented.");
    }
    @Override
    public void childMethod() {
        System.out.println("Child method implemented.");
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.parentMethod();
        myClass.childMethod();
    }
}

在上述示例中，我们首先定义了一个父接口 ParentInterface，其中包含一个抽象方法 parentMethod。然后，我们定义了一个子接口 ChildInterface，通过 extends 关键字继承了父接口，并且添加了一个抽象方法 childMethod。

最后，我们创建了一个实现了 ChildInterface 接口的 MyClass 类，该类需要实现父接口的方法 parentMethod 和子接口的方法 childMethod。

在 Main 类中，我们实例化了 MyClass 对象，并调用了父接口和子接口中的方法。这个示例展示了接口继承的概念。

抽象类 vs. 接口

抽象类可以提供部分实现，而接口只能声明方法，类可以继承一个抽象类但实现多个接口。

当比较抽象类和接口时，可以通过实例代码来突显它们的不同之处。

抽象类示例：

// 定义抽象类
abstract class AbstractShape {
    abstract double calculateArea(); // 抽象方法，需要子类实现
    void displayInfo() {
        System.out.println("This is a shape.");
    }
}
// 继承抽象类
class Circle extends AbstractShape {
    double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    double calculateArea() {
        return Math.PI * radius * radius;
    }
}
public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        circle.displayInfo();
        System.out.println("Circle area: " + circle.calculateArea());
    }
}

接口示例：

// 定义接口
interface Shape {
    double calculateArea(); // 抽象方法
    default void displayInfo() {
        System.out.println("This is a shape.");
    }
}
// 实现多个接口
class Circle implements Shape {
    double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}
class Rectangle implements Shape {
    double width, height;
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    @Override
    public double calculateArea() {
        return width * height;
    }
}
public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        circle.displayInfo();
        System.out.println("Circle area: " + circle.calculateArea());
        Rectangle rectangle = new Rectangle(4, 6);
        rectangle.displayInfo();
        System.out.println("Rectangle area: " + rectangle.calculateArea());
    }
}

在抽象类示例中，我们定义了一个抽象类 AbstractShape，其中包含一个抽象方法 calculateArea 和一个具体方法 displayInfo。然后，我们创建了一个 Circle 类，继承了抽象类并实现了抽象方法。

在接口示例中，我们定义了一个接口 Shape，其中包含一个抽象方法 calculateArea 和一个默认方法 displayInfo。然后，我们创建了 Circle 和 Rectangle 类，都实现了接口，并提供了抽象方法的实现。

这两个示例展示了抽象类和接口的不同用法，以及类继承抽象类和实现多个接口的情况。

下载

下载链接：https://llzai.lanzoum.com/iXmqc14podle

文章标签：
DDoS防护
云数据库 RDS MySQL 版
Java
关键词：
Java接口
诗句藏于尽头
目录
相关文章
艾利克斯冰
|
1月前
|
JSON Java Apache
非常实用的Http应用框架，杜绝Java Http 接口对接繁琐编程
UniHttp 是一个声明式的 HTTP 接口对接框架，帮助开发者快速对接第三方 HTTP 接口。通过 @HttpApi 注解定义接口，使用 @GetHttpInterface 和 @PostHttpInterface 等注解配置请求方法和参数。支持自定义代理逻辑、全局请求参数、错误处理和连接池配置，提高代码的内聚性和可读性。
艾利克斯冰
130 3
龙大吉
|
2月前
|
存储 Java 数据处理
Java Set接口凭借其独特的“不重复”特性，在集合框架中占据重要地位
【10月更文挑战第16天】Java Set接口凭借其独特的“不重复”特性，在集合框架中占据重要地位。本文通过快速去重和高效查找两个案例，展示了Set如何简化数据处理流程，提升代码效率。使用HashSet可轻松实现数据去重，而contains方法则提供了快速查找的功能，彰显了Set在处理大量数据时的优势。
龙大吉
36 2
蓝易云
|
6天前
|
安全 Java API
java如何请求接口然后终止某个线程
通过本文的介绍，您应该能够理解如何在Java中请求接口并根据返回结果终止某个线程。合理使用标志位或 `interrupt`方法可以确保线程的安全终止，而处理好网络请求中的各种异常情况，可以提高程序的稳定性和可靠性。
蓝易云
35 6
兴化
|
22天前
|
Java API
Java中内置的函数式接口
Java中内置的函数式接口
兴化
23 2
john散漫
|
27天前
|
Java
在Java中如何实现接口？
实现接口是 Java 编程中的一个重要环节，它有助于提高代码的规范性、可扩展性和复用性。通过正确地实现接口，可以使代码更加灵活、易于维护和扩展。
john散漫
47 3
dufadayang
|
26天前
|
Java
在Java中，接口之间可以继承吗？
接口继承是一种重要的机制，它允许一个接口从另一个或多个接口继承方法和常量。
dufadayang
75 1
dufadayang
|
26天前
|
Java 开发者
在 Java 中，一个类可以实现多个接口吗？
这是 Java 面向对象编程的一个重要特性，它提供了极大的灵活性和扩展性。
dufadayang
59 1
dufadayang
|
26天前
|
Java
在Java中实现接口的具体代码示例
可以根据具体的需求，创建更多的类来实现这个接口，以满足不同形状的计算需求。希望这个示例对你理解在 Java 中如何实现接口有所帮助。
dufadayang
41 1
听白
|
1月前
|
Java Android开发
Eclipse 创建 Java 接口
Eclipse 创建 Java 接口
听白
27 1
Skyund
|
1月前
|
Java
java线程接口
Thread的构造方法创建对象的时候传入了Runnable接口的对象 ，Runnable接口对象重写run方法相当于指定线程任务，创建线程的时候绑定了该线程对象要干的任务。 Runnable的对象称之为：线程任务对象 不是线程对象 必须要交给Thread线程对象。 通过Thread的构造方法, 就可以把任务对象Runnable,绑定到Thread对象中, 将来执行start方法,就会自动执行Runable实现类对象中的run里面的内容。
Skyund
39 1

热门文章

最新文章

  • 1
    【Java多数据源实现教程】实现动态数据源、多数据源切换方式（上）
  • 2
    Java-学习笔记-8-接口
  • 3
    java中的工厂模式
  • 4
    超简单的java爬虫
  • 5
    Java 学习路线 2024 最新版！
  • 6
    从零搭建Web所需服务（四）Java连接ES进行分词并获取结果
  • 7
    迅速了解多例模式竞争者-枚举 | 带你学《Java面向对象编程》之七十四
  • 8
    带你读《Java程序设计与计算思维》之三：流程控制
  • 9
    Java Poi 创建与读取Excel
  • 10
    关于《Java数字图像处理-编程技巧与应用实践》一书 源代码
  • 1
    【Java开发指南 | 第三十一篇】Java 包(package)
    71
  • 2
    【Java开发指南 | 第二十九篇】Java接口
    46
  • 3
    【Java开发指南 | 第二十八篇】Java封装
    53
  • 4
    【Java开发指南 | 第二十六篇】Java多态
    40
  • 5
    【Java开发指南 | 第二十四篇】Java继承
    58
  • 6
    【Java开发指南 | 第九篇】访问实例变量和方法、继承、接口
    53
  • 7
    【Java开发指南 | 第八篇】Java变量、构造方法、创建对象
    92
  • 8
    Java Stream API详解与使用
    93
  • 9
    Java医院绩效考核系统源码B/S+avue+MySQL助力医院实现精细化管理
    80
  • 10
    《手把手教你》系列技巧篇（四十三）-java+ selenium自动化测试-处理https 安全问题或者非信任站点-上篇（详解教程）
    131

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    DataWorks