Java接口全面教程：从入门到醒目

目次
接口的基本概念
接口的特性
1. 访问修饰符
2. 接口中的常量
3. 接口中的方法
3.1 抽象方法（传统用法）
3.2 默认方法（Java 8 引入）
3.3 静态方法（Java 8 引入）
3.4 私有方法（Java 9 引入）
接口的实现
接口继承
函数式接口与 Lambda 表达式
一、函数式接口
二、Lambda 表达式
三、Lambda 简化格式
四、Lambda 表达式的限制
五、简朴示例
接口的演进历史
接口 vs 抽象类
接口的常见应用
1. 策略模式
2. 回调机制
接口设计最佳实践
接口在实际开辟中的注意事项
总结

---

接口的基本概念

接口是一种特殊的抽象类型，它只定义规范而不提供实现。通过关键字 interface 声明：

1. // 最简单的接口定义
2. public interface MyInterface {
3.     // 接口内容
4. }

复制代码

接口本质上是一种 "契约"，定义了实现该接口的类必须提供的举动，但不规定这些举动怎样实现。它解决了 Java 单继承限制的问题，使一个类可以 "实现" 多个接口，从而获得雷同多重继承的能力。
接口的特性

1. 访问修饰符

问题：接口的访问修饰符是不是只能是 public？
解答：接口自己可以是 public 或默认 (包级) 访问级别，但接口中声明的方法隐式地是 public 的。

1. // 正确 - public接口
2. public interface PublicInterface {
3.     void method();  // 隐式public abstract
4. }
6. // 正确 - 默认访问级别接口(包级)
7. interface PackageLevelInterface {
8.     void method();  // 隐式public abstract
9. }

复制代码

关于接口方法修饰符的说明：
在接口中定义方法时，可以有以下写法：

1. // 以下三种写法在接口中是等价的
2. void method1();                  // 隐式public abstract
3. public void method2();           // 显式public，隐式abstract
4. abstract void method3();         // 显式abstract，隐式public
5. public abstract void method4();  // 完全显式

复制代码

这四种写法都是正确的，因为接口中的方法默认就是 public abstract 的。通常为了简洁，我们会使用第一种写法，省略修饰符。
注意： 接口中的方法不能使用 protected 修饰符，这在所有 Java 版本中都是不允许的。Java 9 只引入了 private 方法支持，但没有引入 protected 方法支持。
2. 接口中的常量

接口中声明的变量默认是 public static final 的常量：

1. public interface GameConstants {
2.     // 常量声明（隐式public static final）
3.     int MAX_PLAYERS = 4;
4.     String GAME_NAME = "我的世界";
5. }

复制代码

这意味着：

• public：可以被任何类访问
  
• static：属于接口自己，而非实现类的实例
  
• final：一旦赋值，不能被修改
  

使用示例：

1. // 直接通过接口名访问常量
2. System.out.println("最大玩家数: " + GameConstants.MAX_PLAYERS);
3. System.out.println("游戏名称: " + GameConstants.GAME_NAME);

复制代码

为什么接口中的变量要是 final？

• 确保接口定义的标准值不被实现类修改
  
• 提供统一的常量引用点
  
• 保持接口作为 "契约" 的纯粹性
  

3. 接口中的方法

3.1 抽象方法（传统用法）

接口中最基本的方法类型是抽象方法：

1. public interface Animal {
2.     // 抽象方法（隐式public abstract）
3.     void eat();
4.     void sleep();
5. }

复制代码

抽象方法特点：

• 没有方法体，只有声明
  
• 实现类必须提供具体实现
  
• 隐式 public abstract
  

实现示例：

1. public class Cat implements Animal {
2.     // 必须实现所有抽象方法
3.     @Override
4.     public void eat() {
5.         System.out.println("猫在吃鱼");
6.     }
7.    
8.     @Override
9.     public void sleep() {
10.         System.out.println("猫在睡觉");
11.     }
12. }

复制代码

3.2 默认方法（Java 8 引入）

什么是默认方法？
默认方法是 Java 8 引入的一种特性，允许接口中包含有具体实现的方法。这些方法使用 default 关键字标志，并提供一个默认实现。

1. public interface Pet {
2.     // 抽象方法 - 必须由实现类提供实现
3.     void feed();
4.    
5.     // 默认方法 - 已经有实现，实现类可以直接使用
6.     default void play() {
7.         System.out.println("宠物在玩耍");
8.     }
9. }

复制代码

默认方法解决了一个重要问题：怎样在不粉碎现有代码的情况下向接口添加新方法。
通俗明白：
想象接口是一份工作合同，内里规定了员工必须完成的任务

• 抽象方法就是 "你必须完成这项工作"
  
• 默认方法就是 "如果你不知道怎么做，可以按照这个方法做"
  

默认方法怎样使用？

1. // 实现类可以直接使用默认方法
2. public class Dog implements Pet {
3.     @Override
4.     public void feed() {
5.         System.out.println("给狗喂食");
6.     }
7.    
8.     // 不必重写默认方法，但也可以选择重写
9.     @Override
10.     public void play() {
11.         System.out.println("狗在玩飞盘");
12.     }
13. }
15. // 使用时
16. Pet myPet = new Dog();
17. myPet.feed();  // 输出"给狗喂食"
18. myPet.play();  // 如果没重写，输出"宠物在玩耍"；如果重写了，输出"狗在玩飞盘"

复制代码

默认方法的执行优先级
当有多个接口都定义了雷同的默认方法时：

1. interface Father {
2.     default void greeting() {
3.         System.out.println("父亲的问候");
4.     }
5. }
7. interface Mother {
8.     default void greeting() {
9.         System.out.println("母亲的问候");
10.     }
11. }
13. // 实现多个接口时，如果默认方法冲突，必须手动解决冲突
14. class Child implements Father, Mother {
15.     @Override
16.     public void greeting() {
17.         // 指定使用父亲接口的默认方法
18.         Father.super.greeting();
19.         
20.         // 或者使用母亲接口的默认方法
21.         // Mother.super.greeting();
22.         
23.         // 或者完全自定义
24.         // System.out.println("孩子的问候");
25.     }
26. }

复制代码

什么是菱形继承问题？
菱形继承问题可以通过一个简朴的例子来明白：

1.     祖父母
2.     /    \
3.   父亲   母亲
4.     \    /
5.      孩子

复制代码

在这个结构中，如果 "祖父母" 定义了一个方法，而 "父亲" 和 "母亲" 都提供了差异的实现，那么 "孩子" 应该继承哪个版本的方法呢？这就是菱形继承问题。
Java 通过接口的默认方法优先级规则解决了这个问题：

• 类的方法优先于接口的默认方法
  
• 子接口的默认方法优先于父接口的默认方法
  
• 如果还有辩论，必须显式指定使用哪个接口的方法
  

3.3 静态方法（Java 8 引入）

什么是接口静态方法？
接口静态方法就是属于接口自己的方法，不必要通过实现类调用。

1. public interface Calculator {
2.     // 静态方法 - 直接通过接口名调用
3.     static int add(int a, int b) {
4.         return a + b;
5.     }
6.    
7.     static int subtract(int a, int b) {
8.         return a - b;
9.     }
10. }

复制代码

静态方法的使用很简朴：

1. // 直接通过接口名调用
2. int result = Calculator.add(5, 3);  // result = 8

复制代码

静态方法的作用：

• 提供与接口相关的工具方法
  
• 不必要创建对象就能使用
  
• 组织相关功能在一起
  

3.4 私有方法（Java 9 引入）

什么是接口私有方法？为什么必要它？
初学者常有疑问：接口的方法不是要被实现吗？私有方法不能被实现类访问，那有什么用？
答案是：私有方法不是给实现类用的，而是给接口自己的默认方法和静态方法用的。
下面是一个简朴的例子，展示私有方法怎样帮助减少代码重复：

1. public interface SimpleLogger {
2.     // 默认方法1
3.     default void logInfo(String message) {
4.         // 使用私有方法处理共同逻辑
5.         log("INFO", message);
6.     }
7.    
8.     // 默认方法2
9.     default void logError(String message) {
10.         // 复用相同的日志逻辑
11.         log("ERROR", message);
12.     }
13.    
14.     // 私有辅助方法 - 只在接口内部使用
15.     private void log(String level, String message) {
16.         System.out.println(level + ": " + message);
17.     }
18. }

复制代码

通俗明白：

• 私有方法就像接口的 "内部工具"
  
• 它们只供接口自己的默认方法和静态方法使用
  
• 实现类根本看不到这些私有方法，也不必要关心它们
  

有两种类型的私有方法：

• 私有实例方法：只能被接口的默认方法调用
  
• 私有静态方法：可以被接口的默认方法和静态方法调用
  

1. public interface FileProcessor {
2.     // 默认方法调用私有实例方法
3.     default byte[] readFile(String path) {
4.         validatePath(path);  // 调用私有实例方法
5.         return new byte[0]; // 简化示例
6.     }
7.    
8.     // 静态方法调用私有静态方法
9.     static String getFileExtension(String filename) {
10.         return extractExtension(filename);  // 调用私有静态方法
11.     }
12.    
13.     // 私有实例方法
14.     private void validatePath(String path) {
15.         if (path == null) {
16.             throw new IllegalArgumentException("Path cannot be null");
17.         }
18.     }
19.    
20.     // 私有静态方法
21.     private static String extractExtension(String filename) {
22.         int dotPos = filename.lastIndexOf('.');
23.         return dotPos > 0 ? filename.substring(dotPos + 1) : "";
24.     }
25. }

复制代码

接口的实现

类通过 implements 关键字实现一个或多个接口：

1. // 实现单个接口
2. public class Rectangle implements Drawable {
3.     @Override
4.     public void draw() {
5.         System.out.println("绘制长方形");
6.     }
7. }
9. // 实现多个接口
10. public class Smartphone implements Phone, Camera, WebBrowser {
11.     @Override
12.     public void makeCall(String number) {
13.         System.out.println("正在拨打: " + number);
14.     }
15.    
16.     @Override
17.     public void takePhoto() {
18.         System.out.println("正在拍照");
19.     }
20.    
21.     @Override
22.     public void browseWeb(String url) {
23.         System.out.println("正在浏览: " + url);
24.     }
25. }

复制代码

实现类必须遵照以下规则：

• 必须实现接口的所有抽象方法
  
• 可以选择性地覆盖接口的默认方法
  
• 不能覆盖接口的静态方法
  
• 必须将抽象方法实现为 public
  

接口继承

接口可以通过 extends 关键字继承一个或多个其他接口：

1. // 基础接口
2. interface Animal {
3.     void eat();
4. }
6. // 扩展接口
7. interface FlyingAnimal extends Animal {
8.     void fly();
9. }
11. // 实现扩展接口的类必须实现所有方法
12. class Bird implements FlyingAnimal {
13.     @Override
14.     public void eat() {
15.         System.out.println("鸟在吃虫子");
16.     }
17.    
18.     @Override
19.     public void fly() {
20.         System.out.println("鸟在天空飞翔");
21.     }
22. }

复制代码

接口继承的特点：

• 子接口继承父接口的所有方法和常量
  
• 子接口可以添加新的方法和常量
  
• 子接口可以覆盖父接口的默认方法
  
• 子接口不能移除父接口的方法
  

函数式接口与 Lambda 表达式

一、函数式接口

函数式接口是 仅包含一个抽象方法 的接口，它是 Lambda 表达式的 “宿主”，通过 Lambda 可简洁实现接口中的抽象方法。

• 注解规范：保举用 @FunctionalInterface 注解标志（非逼迫），用于在编译期检查接口是否符合函数式接口规范（确保只有一个抽象方法）。 java
  
  1. @FunctionalInterface  
  2. interface MyComparator {  
  3.     int compare(int a, int b); // 唯一抽象方法  
  4. }  

  复制代码

二、Lambda 表达式

• 概念：Java 8 引入的特性，允许将 “举动”（一段代码）作为参数传递，直接表现函数式接口的实现，避免编写冗长的匿名内部类。
  
• 核心作用：大幅简化代码，提升可读性，拥抱函数式编程风格，让代码更简洁、灵活。
  

三、Lambda 简化格式

• 参数类型省略
  小括号中的参数数据类型可省略。
  1. // 完整形式：(int a, int b) -> a - b  
  2. MyComparator comp = (a, b) -> a - b;  

  复制代码
• 单参数时省略小括号
  若参数只有一个，小括号可省略。
  1. interface Square {  
  2.     int calculate(int num);  
  3. }  
  4. Square s = num -> num * num; // 单参数，省略小括号  

  复制代码
• 单行方法体省略大括号
  若方法体只有一行，可省略 return、分号和大括号。
  1. MyComparator comp = (a, b) -> a - b; // 隐含 return，省略大括号  

  复制代码

四、Lambda 表达式的限制

• 仅适配函数式接口：必须对应一个抽象方法的函数式接口，否则编译报错。
  
• 变量作用域限制：Lambda 内不能定义与外部同名的新变量，但可访问 final 或 “等效 final”（未被修改）的局部变量。
  
• 类型依赖上下文：Lambda 表达式的类型由所在的函数式接口决定，不能独立存在。
  

五、简朴示例

1. import java.util.Arrays;  
3. @FunctionalInterface  
4. interface MyComparator {  
5.     int compare(int a, int b);  
6. }  
8. public class LambdaDemo {  
9.     public static void main(String[] args) {  
10.         // 使用 Lambda 实现函数式接口  
11.         MyComparator comp = (a, b) -> a - b;  
12.         int result = comp.compare(10, 5);  
13.         System.out.println("比较结果：" + result); // 输出：5  
15.         // 简单数组排序示例  
16.         Integer[] nums = {5, 3, 8};  
17.         Arrays.sort(nums, (x, y) -> x - y); // 升序排列  
18.         System.out.println("排序后数组：" + Arrays.toString(nums)); // 输出：[3, 5, 8]  
19.     }  
20. }  

复制代码

通过上述规则，Lambda 表达式在函数式接口的支持下，以极简方式实现举动定义，成为 Java 函数式编程的核心工具，让代码在简洁中迸发强大的表现力。
接口的演进历史

Java 版本新增特性具体说明Java 1.0基本接口功能只支持常量和抽象方法Java 8 (2014)默认方法、静态方法允许接口包含方法实现，支持 API 演化Java 9 (2017)私有方法 (实例和静态)加强接口内部代码复用能力 接口 vs 抽象类

特性接口抽象类多重继承支持（一个类可以实现多个接口）不支持（一个类只能继承一个抽象类）构造器不允许允许（但不能直接实例化）方法实现仅默认 / 静态 / 私有方法可有实现可以有抽象和非抽象方法成员变量仅常量 (public static final)任何类型的字段访问修饰符方法默认 public可以使用任何访问修饰符状态不能包含状态（除了常量）可以包含状态（实例变量）目标定义类型和举动契约提供共同基类和部分实现 接口的常见应用

1. 策略模式

通过接口定义差异的算法：

1. // 策略接口
2. interface SortStrategy {
3.     void sort(int[] array);
4. }
6. // 具体策略实现
7. class QuickSort implements SortStrategy {
8.     @Override
9.     public void sort(int[] array) {
10.         System.out.println("使用快速排序");
11.         // 排序实现...
12.     }
13. }
15. class BubbleSort implements SortStrategy {
16.     @Override
17.     public void sort(int[] array) {
18.         System.out.println("使用冒泡排序");
19.         // 排序实现...
20.     }
21. }
23. // 使用
24. class ArrayProcessor {
25.     private SortStrategy strategy;
26.    
27.     public void setStrategy(SortStrategy strategy) {
28.         this.strategy = strategy;
29.     }
30.    
31.     public void sortArray(int[] array) {
32.         strategy.sort(array);
33.     }
34. }

复制代码

2. 回调机制

使用接口实现回调：

1. // 回调接口
2. interface ClickListener {
3.     void onClick(String buttonName);
4. }
6. // 使用回调
7. class Button {
8.     private String name;
9.     private ClickListener listener;
10.    
11.     public Button(String name) {
12.         this.name = name;
13.     }
14.    
15.     public void setListener(ClickListener listener) {
16.         this.listener = listener;
17.     }
18.    
19.     public void click() {
20.         // 触发回调
21.         if (listener != null) {
22.             listener.onClick(name);
23.         }
24.     }
25. }
27. // 使用Lambda实现回调
28. Button submitButton = new Button("Submit");
29. submitButton.setListener(buttonName -> System.out.println(buttonName + " 被点击了"));
30. submitButton.click();  // 输出：Submit 被点击了

复制代码

接口设计最佳实践

• 保持接口小而精确：一个接口应该只关注一个功能点
  
• 明确接口的责任：接口名应该能清晰表达其用途
  

1. // 好的接口命名
2. interface Printable { void print(); }
3. interface Comparable<T> { int compareTo(T other); }

复制代码

• 使用默认方法扩展：添加新功能时考虑使用默认方法
  

1. interface List<E> {
2.     // 原有方法
3.     void add(E element);
4.    
5.     // 通过默认方法扩展功能
6.     default void addAll(E... elements) {
7.         for (E e : elements) {
8.             add(e);
9.         }
10.     }
11. }

复制代码

• 避免过度使用接口：不要为每个类都创建接口，只在真正必要抽象时使用
  

接口在实际开辟中的注意事项

• 接口变更：尽量避免在已发布的接口中添加非默认方法
  
• 文档美满：为接口方法提供清晰的文档，说明预期举动
  

1. /**
2. * 表示可以发送消息的功能。
3. */
4. interface MessageSender {
5.     /**
6.      * 发送文本消息到指定接收者。
7.      *
8.      * @param recipient 消息接收者ID
9.      * @param content 消息内容，不能为null
10.      * @return 是否发送成功
11.      * @throws MessageException 如果发送过程中出错
12.      */
13.     boolean send(String recipient, String content) throws MessageException;
14. }

复制代码

• 公道使用默认实现：默认方法应提供公道的通用实现，不应依赖具体实现细节
  

总结

Java 接口是一种强大的抽象机制，随着 Java 语言的发展不绝加强其功能：

• 基础特性：
  
  
  
  • 定义抽象方法（必须由实现类实现）
    
  • 声明常量（隐式 public static final）
    
  • 实现多重继承机制
    
  
  
• Java 8 加强：
  
  
  
  • 默认方法（带实现的接口方法）
    
  • 静态方法（属于接口自己的方法）
    
  • 函数式接口（支持 Lambda 表达式）
    
  
  
• Java 9 加强：
  
  
  
  • 私有方法（加强接口内部代码复用）
    
  
  

关键上风：

• 定义类型而非实现
  
• 支持多重继承
  
• 促进疏松耦合
  
• 简化系统演化
  

明白接口的这些特性和最佳实践，将帮助你写出更灵活、更易维护的 Java 代码。无论是初学者照旧有履历的开辟者，把握接口都是提高 Java 编程能力的关键步骤。

---

参考资料:

• Oracle Java 接口文档
  
• Java 9 接口加强
  
• Effective Java (Joshua Bloch)
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。