什么是接口？

接口是面向对象编程中的一种抽象机制，用来定义对象之间的一种契约或规范。

• 定义：在 Java 中，接口（interface）是一个包含方法声明（而非实现）和常量的集合。它是纯抽象的，没有任何具体实现。

• 语法：

  复制
  1public interface MyInterface {
  2    void method1();
  3    void method2();
  4}

• 实现：类通过 implements 关键字来实现接口，并提供具体的方法实现。

  复制
  1public class MyClass implements MyInterface {
  2    @Override
  3    public void method1() { 
  4        System.out.println("Method1 implemented");
  5    }
  6    @Override
  7    public void method2() {
  8        System.out.println("Method2 implemented");
  9    }
  10}

• 特性：

  1. 抽象性：接口中的方法默认是 public abstract，实现类必须实现这些方法。
  2. 多继承：类不能多继承，但接口可以多继承。
  3. 默认方法：从 Java 8 开始，接口可以包含默认方法（default）和静态方法。

---

为什么要使用接口？

1. 解耦性和扩展性

   • 使用接口可以实现代码的松散耦合，使得系统模块之间的依赖降低。
   • 当需要扩展功能时，可以新增实现类，而不需要修改现有代码（符合 开闭原则）。

   例子：

   复制
   1interface Payment {
   2    void processPayment();
   3}
   4
   5class CreditCardPayment implements Payment {
   6    @Override
   7    public void processPayment() {
   8        System.out.println("Processing credit card payment");
   9    }
   10}
   11
   12class PayPalPayment implements Payment {
   13    @Override
   14    public void processPayment() {
   15        System.out.println("Processing PayPal payment");
   16    }
   17}

   客户端代码只依赖于接口 Payment，因此可以很方便地替换不同的支付实现。

---

2. 支持多态

   • 接口允许多态行为，通过接口引用调用具体实现类的方法。
   • 这样可以实现同一操作的多种行为，增强系统的灵活性。

   例子：

   复制
   1Payment payment = new CreditCardPayment();
   2payment.processPayment(); // 调用的是 CreditCardPayment 的实现
   3
   4payment = new PayPalPayment();
   5payment.processPayment(); // 调用的是 PayPalPayment 的实现

---

3. 实现多继承

   • Java 中类只能单继承，但接口支持多继承。
   • 通过实现多个接口，一个类可以复用多个接口定义的行为。

   例子：

   复制
   1interface A { void methodA(); }
   2interface B { void methodB(); }
   3
   4class MyClass implements A, B {
   5    @Override
   6    public void methodA() { System.out.println("Method A"); }
   7    @Override
   8    public void methodB() { System.out.println("Method B"); }
   9}

---

4. 提升代码的规范性和可维护性
   • 接口定义了类的行为规范，不同的实现类遵循相同的行为约定。
   • 这有助于团队协作和代码维护，开发者只需关注接口而无需关心具体实现。

---

5. 支持依赖注入

   • 使用接口可以轻松实现依赖注入，增强代码的可测试性。
   • 接口允许在运行时动态地替换实现类，方便调试和测试。

   例子：

   复制
   1class OrderProcessor {
   2    private Payment payment;
   3    public OrderProcessor(Payment payment) {
   4        this.payment = payment;
   5    }
   6    public void processOrder() {
   7        payment.processPayment();
   8    }
   9}
   10
   11// 测试环境中使用 Mock 实现
   12class MockPayment implements Payment {
   13    @Override
   14    public void processPayment() {
   15        System.out.println("Mock payment processing");
   16    }
   17}

---

6. 支持接口回调

   • 接口经常用于事件驱动的程序设计，通过回调机制实现灵活的交互。

   例子：

   复制
   1interface OnClickListener {
   2    void onClick();
   3}
   4
   5class Button {
   6    private OnClickListener listener;
   7    public void setOnClickListener(OnClickListener listener) {
   8        this.listener = listener;
   9    }
   10    public void click() {
   11        if (listener != null) listener.onClick();
   12    }
   13}
   14
   15class MyApp implements OnClickListener {
   16    @Override
   17    public void onClick() {
   18        System.out.println("Button clicked!");
   19    }
   20}

---

为什么不用直接使用具体类？

1. 耦合度高：直接使用具体类会使代码耦合度增加，修改实现类会影响到调用它的代码。
2. 不利于扩展：新增功能需要修改已有代码，不符合 开闭原则。
3. 多态性受限：无法利用接口提供的多态特性。
4. 降低可测试性：直接使用具体类，测试时难以替换实现，无法模拟不同的行为。