【Java基础】Java中的接口

一、前言

在 Java 编程的世界里，接口 是一个极为重要的概念，它如同连接不同模块和类的桥梁，为代码的设计和实现提供了强大的灵活性和扩展性。接口定义了一组行为规范，任何实现该接口的类都必须遵循这些规范，从而实现了代码的解耦和多态性。

二、接口的基本定义 （一）定义概念

接口是一种特殊的抽象类型，它只包含方法签名和常量的定义，而不包含方法的实现。接口使用 interface 关键字 来定义，它定义了一组行为的契约，任何实现该接口的类都必须实现接口中定义的所有方法。

（二）语法示例 // 定义一个接口 interface Shape { // 常量定义，默认是 public static final double PI = 3.14; // 抽象方法，默认是 public abstract double area(); double perimeter(); }

在上述示例中，Shape 是一个接口，它定义了两个抽象方法 area() 和 perimeter()，用于计算图形的面积和周长。同时，接口中还定义了一个常量 PI。

三、接口的特性 （一）接口中的成员特点 常量：接口中定义的常量默认是 public static final 修饰 的，因此在接口中定义常量时可以省略这些修饰符。常量一旦定义，其值不能被修改。 interface Constants { int MAX_VALUE = 100; String MESSAGE = "Hello, World!"; } 抽象方法：接口中的方法默认是 public abstract 修饰 的，同样可以省略这些修饰符。抽象方法只有方法签名，没有方法体，实现接口的类必须实现这些抽象方法。 interface Printable { void print(); } 默认方法（Java 8 及以后）：Java 8 引入了默认方法，使用 default 关键字 修饰。默认方法有方法体，实现接口的类可以选择是否重写默认方法。默认方法的引入是为了在不破坏现有实现类的情况下，向接口中添加新的方法。

默认方法通过他的实现类来调用

interface Vehicle { void move(); default void stop() { System.out.println("车辆停止"); } } 静态方法（Java 8 及以后）：Java 8 还支持在接口中定义静态方法，使用 static 关键字 修饰。静态方法可以直接通过接口名调用，不需要实现类的实例。

静态方法只能使用当前接口名来调用

interface MathUtils { static int add(int a, int b) { return a + b; } } 私有方法（Java 9 及以后）：Java 9 引入了私有方法，使用 private 关键字 修饰。私有方法可以有方法体，用于在接口内部复用代码，不能被实现类或外部访问。

私有方法使用接口中的其他实例方法来调用

interface MyInterface { default void doSomething() { privateMethod(); } private void privateMethod() { System.out.println("执行私有方法"); } } （二）接口的继承

接口可以继承其他接口，使用 extends 关键字。一个接口可以继承多个接口，从而实现接口的多继承。

接口与接口可以多继承：一个接口可以同时继承多个接口

interface A { void methodA(); } interface B { void methodB(); } interface C extends A, B { void methodC(); }

在上述示例中，接口 C 继承了接口 A 和 B，因此实现接口 C 的类必须实现 methodA()、methodB() 和 methodC() 三个方法。

（三）接口的实现

一个类可以实现一个或多个接口，使用 implements 关键字。实现接口的类必须实现接口中定义的所有抽象方法。

class Circle implements Shape { private double radius; public Circle(double radius) { this.radius = radius; } @Override public double area() { return Shape.PI * radius * radius; } @Override public double perimeter() { return 2 * Shape.PI * radius; } }

在上述示例中，Circle 类实现了 Shape 接口，并重写了 area() 和 perimeter() 方法。

四、接口的使用场景 （一）实现多态

接口是实现多态的重要手段之一。通过接口的引用变量可以指向不同的实现类对象，从而实现不同的行为。

interface Animal { void makeSound(); } class Dog implements Animal { @Override public void makeSound() { System.out.println("汪汪汪"); } } class Cat implements Animal { @Override public void makeSound() { System.out.println("喵喵喵"); } } public class Main { public static void main(String[] args) { Animal dog = new Dog(); Animal cat = new Cat(); dog.makeSound(); cat.makeSound(); } }

在上述示例中，Animal 是一个接口，Dog 和 Cat 是实现该接口的类。通过 Animal 接口的引用变量可以调用不同实现类的 makeSound() 方法，实现了多态。

（二）定义回调机制

接口可以用于定义回调机制，当某个事件发生时，调用实现该接口的类的方法。

interface OnClickListener { void onClick(); } class Button { private OnClickListener listener; public void setOnClickListener(OnClickListener listener) { this.listener = listener; } public void click() { if (listener != null) { listener.onClick(); } } } public class CallbackExample { public static void main(String[] args) { Button button = new Button(); button.setOnClickListener(() -> System.out.println("按钮被点击了")); button.click(); } }

在上述示例中，OnClickListener 是一个接口，Button 类中定义了一个 OnClickListener 类型的成员变量，通过 setOnClickListener() 方法设置点击事件的监听器。当按钮被点击时，调用监听器的 onClick() 方法。

（三）实现插件化架构

接口可以用于实现插件化架构，不同的插件实现同一个接口，主程序可以根据需要加载不同的插件。

interface Plugin { void execute(); } class PluginA implements Plugin { @Override public void execute() { System.out.println("插件 A 执行"); } } class PluginB implements Plugin { @Override public void execute() { System.out.println("插件 B 执行"); } } public class PluginSystem { public static void main(String[] args) { Plugin pluginA = new PluginA(); Plugin pluginB = new PluginB(); pluginA.execute(); pluginB.execute(); } }

在上述示例中，Plugin 是一个接口，PluginA 和 PluginB 是实现该接口的插件类。主程序可以根据需要创建不同的插件对象并调用其 execute() 方法。

五、接口与抽象类的比较 （一）语法层面 比较项接口抽象类定义关键字interfaceabstract class成员变量只能是 public static final 修饰的常量可以是各种类型的成员变量方法类型Java 8 之前只能有抽象方法，Java 8 及以后支持默认方法、静态方法和私有方法可以包含抽象方法和非抽象方法构造器没有构造器可以有构造器,但不能创建对象继承/实现关系一个类可以实现多个接口，接口可以继承多个接口一个类只能继承一个抽象类

抽象类体现模板思想：更利于做父类，实现代码的复用性。 接口更适合做功能的解耦合：解耦合性更强，更灵活。

（二）设计目的 接口：强调 “can - do” 关系，即类具有某些行为能力。接口主要用于定义一组行为规范，不同的类可以实现同一个接口，从而具有相同的行为能力。抽象类：强调 “is - a” 关系，即子类是父类的一种特殊类型。抽象类主要用于表示一组具有共同特征和行为的类的抽象，为子类提供通用的属性和方法。 （三）使用场景 接口：当需要为不同的类定义一组统一的行为规范，并且这些类之间没有明显的继承关系时，使用接口更合适。例如，不同的交通工具（汽车、飞机、轮船等）都可以实现 Moveable 接口，具有移动的行为能力。抽象类：当多个子类有一些共同的属性和行为，并且需要提供一些默认的实现时，使用抽象类比较合适。例如，不同的动物（猫、狗、鸟等）可以继承 Animal 抽象类，具有一些共同的属性（如年龄、体重等）和方法（如进食、睡觉等）。 六、接口在 Java 框架中的应用 （一）Java 集合框架中的接口

Java 集合框架中广泛使用了接口，如 List、Set、Map 等接口。这些接口定义了集合的基本操作，不同的实现类（如 ArrayList、HashSet、HashMap 等）实现了这些接口，提供了不同的存储和访问方式。

import java.util.ArrayList; import java.util.List; public class CollectionExample { public static void main(String[] args) { List<String> list = new ArrayList<>(); list.add("apple"); list.add("banana"); for (String fruit : list) { System.out.println(fruit); } } }

在上述示例中，List 是一个接口，ArrayList 是实现该接口的类。通过 List 接口的引用变量可以操作 ArrayList 对象，提高了代码的灵活性和可维护性。

（二）Java 多线程中的接口

Java 多线程编程中使用了 Runnable 接口和 Callable 接口。Runnable 接口定义了一个 run() 方法，实现该接口的类可以作为线程的任务来执行。Callable 接口定义了一个 call() 方法，该方法可以有返回值，用于执行有返回结果的任务。

import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; class MyRunnable implements Runnable { @Override public void run() { System.out.println("线程正在执行"); } } class MyCallable implements Callable<Integer> { @Override public Integer call() throws Exception { return 1 + 2; } } public class ThreadExample { public static void main(String[] args) { // 使用 Runnable 接口 Thread thread = new Thread(new MyRunnable()); thread.start(); // 使用 Callable 接口 MyCallable callable = new MyCallable(); FutureTask<Integer> futureTask = new FutureTask<>(callable); Thread callableThread = new Thread(futureTask); callableThread.start(); try { Integer result = futureTask.get(); System.out.println("计算结果：" + result); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } } }

在上述示例中，MyRunnable 类实现了 Runnable 接口，MyCallable 类实现了 Callable 接口。通过创建 Thread 对象和 FutureTask 对象，可以分别执行 Runnable 任务和 Callable 任务。

（三）Spring 框架中的接口

Spring 框架中大量使用了接口，如 ApplicationContext 接口、BeanFactory 接口等。这些接口定义了 Spring 容器的基本功能，不同的实现类（如 ClassPathXmlApplicationContext、XmlBeanFactory 等）实现了这些接口，提供了不同的容器实现方式。

import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; class MyService { public void doSomething() { System.out.println("执行服务操作"); } } public class SpringExample { public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); MyService myService = context.getBean(MyService.class); myService.doSomething(); } }

在上述示例中，ApplicationContext 是一个接口，ClassPathXmlApplicationContext 是实现该接口的类。通过创建 ClassPathXmlApplicationContext 对象，可以加载 Spring 配置文件，获取 Spring 容器中的 Bean 对象。

七、接口的注意事项 （一）方法重写规则

实现接口的类在重写接口的抽象方法时，方法的访问修饰符必须是 public，因为接口中的方法默认是 public 修饰的。

interface MyInterface { void method(); } class MyClass implements MyInterface { // 错误，访问修饰符不能比接口中的方法更严格 // private void method() { } // 正确，使用 public 修饰 @Override public void method() { System.out.println("实现接口方法"); } } （二）默认方法和静态方法的使用 默认方法：实现接口的类可以选择是否重写默认方法。如果多个接口中定义了相同签名的默认方法，实现类必须重写该方法，以解决冲突。

一个接口继承多个接口，如果多个接口中存在方法签名冲突，则此时不支持多继承，也不支持多实现

interface A { default void method() { System.out.println("接口 A 的默认方法"); } } interface B { default void method() { System.out.println("接口 B 的默认方法"); } } class C implements A, B { @Override public void method() { // 重写方法以解决冲突 A.super.method(); } } 静态方法：接口中的静态方法只能通过接口名调用，不能通过实现类的实例调用。 interface MyInterface { static void staticMethod() { System.out.println("接口的静态方法"); } } public class Main { public static void main(String[] args) { // 正确，通过接口名调用静态方法 MyInterface.staticMethod(); // 错误，不能通过实现类实例调用静态方法 // MyClass obj = new MyClass(); // obj.staticMethod(); } } （三）接口的常量使用

接口中的常量是 public static final 修饰的，因此可以直接通过接口名访问常量。

interface Constants { int MAX_VALUE = 100; } public class Main { public static void main(String[] args) { System.out.println(Constants.MAX_VALUE); } } 八、总结 （一）核心要点回顾 基本定义：使用 interface 关键字 定义，包含常量和抽象方法，Java 8 及以后支持默认方法、静态方法，Java 9 支持私有方法。特性： 常量默认 public static final，方法默认 public abstract。支持多继承，一个类可实现多个接口。实现类需重写抽象方法，可选择重写默认方法。 使用场景： 实现多态，通过接口引用调用不同实现类方法。定义回调机制，处理事件响应。实现插件化架构，方便扩展功能。 与抽象类比较： 语法上，接口更简洁，抽象类更灵活。设计目的上，接口强调行为能力，抽象类强调继承关系。使用场景根据类间关系和是否需默认实现选择。 框架应用：在 Java 集合框架、多线程编程、Spring 框架等中广泛应用，提供统一规范和扩展能力。注意事项： 重写方法访问修饰符为 public。处理默认方法冲突，静态方法通过接口名调用。常量通过接口名访问。一个类继承了父类，又同时实现类接口，如果父类中和接口中有同名的方法，实现类会优先用父类的 （二）重要性与应用价值

Java 接口是 Java 编程中不可或缺的一部分，它为代码的设计和实现提供了强大的支持。通过使用接口，可以实现代码的解耦、提高代码的可维护性和可扩展性，同时也方便了不同模块之间的协作和交互。