陕西省网站建设_网站建设公司_在线商城_seo优化

接口 (Interface)

一、接口的基本概念

1. 定义与性质

• 定义：接口是 Java 中的一种引用数据类型，用于定义一组行为规范或规则。

• 关键字：interface

• 格式：

  java

  public interface 接口名 { // 接口内容 }

• 核心性质：

  • 接口不能被实例化（不能new接口）。

  • 接口主要用来定义类必须遵循的规则（方法声明）。

  • 它是一种纯粹的“是什么能做什么”的契约。

2. 实现关系

• 关键字：implements

• 格式：

  java

  public class 类名 implements 接口名 { // 类的内容 }

  实现了接口的类称为该接口的“实现类”。

3. 实现类的规则

当一个普通类实现一个接口时：

1. 必须重写接口中的所有抽象方法（推荐，成为具体类）

2. 或者将自己声明为抽象类（如果不重写所有抽象方法）

java

// 定义接口 public interface Animal { void eat(); // 抽象方法（默认 public abstract） void sleep(); } // 实现方式1：重写所有方法 public class Dog implements Animal { @Override public void eat() { System.out.println("狗吃骨头"); } @Override public void sleep() { System.out.println("狗在睡觉"); } } // 实现方式2：成为抽象类 public abstract class Cat implements Animal { @Override public void eat() { System.out.println("猫吃鱼"); } // 没有重写 sleep() 方法，所以 Cat 必须是抽象类 }

二、接口与类的关系

1. 实现关系的特点

• 单实现：一个类实现一个接口

• 多实现：一个类可以实现多个接口

• 继承与实现共存：一个类可以继承一个父类的同时实现多个接口

java

// 多实现示例 public interface Swimmable { void swim(); } public interface Flyable { void fly(); } // 一个类实现多个接口 public class Duck implements Swimmable, Flyable { @Override public void swim() { System.out.println("鸭子在游泳"); } @Override public void fly() { System.out.println("鸭子在飞"); } } // 继承与实现共存 public class Animal { public void breathe() { System.out.println("呼吸"); } } public class SuperDuck extends Animal implements Swimmable, Flyable { @Override public void swim() { System.out.println("超级鸭游泳"); } @Override public void fly() { System.out.println("超级鸭飞翔"); } }

2. 类、接口之间的各种关系总结

接口多继承示例：

java

public interface A { void methodA(); } public interface B { void methodB(); } // 接口C继承接口A和B public interface C extends A, B { void methodC(); } // 实现类需要实现所有抽象方法 public class MyClass implements C { @Override public void methodA() { /* 实现 */ } @Override public void methodB() { /* 实现 */ } @Override public void methodC() { /* 实现 */ } }

三、接口的成员特点（JDK 7 及以前）

在 JDK 8 之前，接口中只能包含以下内容：

示例：

java

public interface MyInterface { // 常量（public static final 可以省略） public static final int MAX = 100; String NAME = "接口"; // 等价于 public static final String NAME = "接口"; // 抽象方法（public abstract 可以省略） public abstract void show(); void doWork(); // 等价于 public abstract void doWork(); // 不能有构造方法 // public MyInterface() {} // 编译错误！ // 不能有普通方法 // public void normalMethod() { } // 编译错误！ }

四、JDK 8 及以后接口的新特性

1. 默认方法（Default Method）

• 目的：解决接口升级问题。当接口需要添加新方法时，如果直接添加抽象方法，会导致所有实现类都要修改。默认方法提供了默认实现，不会破坏现有代码。

• 格式：

  java

  public default 返回值类型 方法名(参数列表) { // 方法体 }

• 特点：

  • 使用default关键字修饰

  • 不是抽象方法，所以不强制重写

  • public可以省略，但default不能省略

  • 可以被实现类直接继承使用，也可以被重写

java

public interface USB { // 抽象方法 void connect(); // 默认方法（解决接口升级问题） default void transferData() { System.out.println("默认的数据传输方式"); } // JDK 8 也可以有静态方法 static void showVersion() { System.out.println("USB 3.0"); } } public class Mouse implements USB { @Override public void connect() { System.out.println("鼠标已连接"); } // 可以不重写 transferData()，使用默认实现 } public class Keyboard implements USB { @Override public void connect() { System.out.println("键盘已连接"); } // 也可以重写默认方法 @Override public void transferData() { System.out.println("键盘使用特殊方式传输数据"); } }

2. 默认方法的冲突规则

当实现类实现了多个接口，且这些接口有同名的默认方法时：

java

public interface A { default void show() { System.out.println("A的show方法"); } } public interface B { default void show() { System.out.println("B的show方法"); } } // 编译错误：必须重写show方法解决冲突 public class C implements A, B { @Override public void show() { // 可以选择调用某一个接口的默认方法 A.super.show(); // 调用A接口的show方法 // 或者提供自己的实现 System.out.println("C重写的show方法"); } }

3. 静态方法（JDK 8）

• 格式：public static 返回值类型 方法名(参数列表) { }

• 特点：

  • 属于接口本身，通过接口名.方法名()调用

  • 不能被子类继承或重写

  • 常用于工具方法

java

public interface MathUtils { static int max(int a, int b) { return a > b ? a : b; } } // 使用 int result = MathUtils.max(10, 20);

4. 私有方法（JDK 9）

• 目的：为默认方法或静态方法提供内部辅助方法，抽取公共代码，提高代码复用性。

• 格式：

  java

  // 普通私有方法：为默认方法服务 private 返回值类型 方法名(参数列表) { } // 静态私有方法：为静态方法服务 private static 返回值类型 方法名(参数列表) { }

• 特点：只能在接口内部使用

java

public interface DataProcessor { default void processData(String data) { String cleaned = cleanData(data); // 调用私有方法 System.out.println("处理数据: " + cleaned); } static void validate(String data) { if (isValid(data)) { // 调用私有静态方法 System.out.println("数据有效"); } } // 私有方法（JDK 9+） private String cleanData(String data) { return data.trim().toLowerCase(); } // 私有静态方法（JDK 9+） private static boolean isValid(String data) { return data != null && !data.isEmpty(); } }

五、接口总结对比

六、适配器设计模式

1. 问题场景

当一个接口中有大量抽象方法，但实现类只需要使用其中一部分时，如果直接实现接口，就需要重写所有方法（即使大部分方法体为空）。这会导致代码冗余。

2. 解决方案：适配器模式

• 核心思想：创建一个中间适配器类，对接口中的所有方法进行空实现。

• 实现步骤：

  1. 定义中间类XXXAdapter，用abstract修饰，防止被实例化。

  2. 空实现接口中的所有抽象方法（方法体为空{}）。

  3. 真正的实现类继承适配器类，只重写需要的方法。

3. 完整示例

java

// 1. 定义接口（有很多方法） public interface WindowListener { void windowOpened(); void windowClosing(); void windowClosed(); void windowIconified(); void windowDeiconified(); void windowActivated(); void windowDeactivated(); } // 2. 创建适配器类（中间类） public abstract class WindowAdapter implements WindowListener { // 空实现所有方法 @Override public void windowOpened() {} @Override public void windowClosing() {} @Override public void windowClosed() {} @Override public void windowIconified() {} @Override public void windowDeiconified() {} @Override public void windowActivated() {} @Override public void windowDeactivated() {} } // 3. 真正的实现类 public class MyWindow extends WindowAdapter { // 只需要重写关心的方法 @Override public void windowClosing() { System.out.println("窗口正在关闭，执行清理操作..."); System.exit(0); } @Override public void windowOpened() { System.out.println("窗口已打开"); } // 其他方法使用适配器中的空实现，无需重写 } // 4. 使用 public class Test { public static void main(String[] args) { MyWindow window = new MyWindow(); // 只会执行重写的方法 window.windowOpened(); // 输出：窗口已打开 window.windowClosing(); // 输出：窗口正在关闭，执行清理操作... window.windowClosed(); // 无输出（使用空实现） } }

七、接口的应用场景

1. 定义标准/规范：如 JDBC 接口、Servlet 接口

2. 解耦：面向接口编程，降低模块间耦合度

3. 扩展性：通过实现不同接口，为类添加不同能力

4. 替代多继承：Java 不支持类的多继承，但支持接口的多实现

设计原则：面向接口编程，而不是面向实现编程。这样可以提高代码的灵活性、可扩展性和可维护性。