一、接口（Interface）的基本概念

接口 是Java中一种完全抽象的类型，用于定义一组方法的规范。它通过 interface 关键字声明，并可以被类通过 implements 关键字实现。
接口的核心作用：

• 定义行为规范：规定类必须实现哪些方法，但不关心具体实现细节。
• 实现多继承：Java类只能单继承，但可以通过实现多个接口间接实现多继承。
• 解耦代码：分离方法的定义与实现，提高代码的模块化和可扩展性。

二、接口的定义与语法

1. 基本语法

public interface 接口名 {
    // 抽象方法（默认 public abstract）
    void method1();

    // 默认方法（Java 8+）
    default void method2() {
        System.out.println("默认方法");
    }

    // 静态方法（Java 8+）
    static void method3() {
        System.out.println("静态方法");
    }

    // 常量（默认 public static final）
    String CONSTANT = "常量";
}

2. 接口中的成员特性

• 方法：
  • 抽象方法（无方法体，必须由实现类重写）。
  • 默认方法（default 修饰，有方法体，可被实现类选择是否重写）。
  • 静态方法（static 修饰，直接通过接口名调用）。
• 变量：
  • 只能是 public static final 常量，必须初始化。

三、接口的实现

1. 类实现接口

类通过 implements 关键字实现接口，必须重写所有抽象方法，否则需声明为抽象类。

public class MyClass implements 接口名 {
    @Override
    public void method1() {
        System.out.println("实现抽象方法");
    }
}

2. 实现多个接口

Java支持一个类实现多个接口，解决单继承限制。

public class MyClass implements InterfaceA, InterfaceB {
    // 必须实现所有接口的抽象方法
}

四、接口的进阶特性（Java 8+）

1. 默认方法（Default Method）

• 作用：允许在接口中提供默认实现，避免修改已有实现类。

• 示例：

  interface Animal {
    void eat();  // 抽象方法
  
    default void breathe() {
        System.out.println("动物呼吸"); // 默认方法
    }
  }
  
  class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    // 可选择不重写breathe()
  }

2. 静态方法（Static Method）

• 作用：提供接口级别的工具方法，直接通过接口名调用。

• 示例：

  interface MathUtils {
    static int add(int a, int b) {
        return a + b;
    }
  }
  
  // 调用
  int result = MathUtils.add(3, 5);

3. 私有方法（Java 9+）

• 作用：在接口内部复用代码，分为 private 和 private static。

• 示例：

  interface Logger {
    default void logInfo(String message) {
        log("INFO: " + message);
    }
  
    private void log(String message) {
        System.out.println(message);
    }
  }

五、接口与抽象类的区别

六、接口的实际应用场景

1. 定义通用行为

例如，定义“可飞行”接口，让不同类（如飞机、鸟）实现：

interface Flyable {
    void fly();
}

class Airplane implements Flyable {
    @Override
    public void fly() {
        System.out.println("飞机用引擎飞行");
    }
}

class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("鸟用翅膀飞行");
    }
}

2. 回调机制（Callback）

通过接口实现事件监听：

interface OnClickListener {
    void onClick();
}

class Button {
    private OnClickListener listener;

    public void setListener(OnClickListener listener) {
        this.listener = listener;
    }

    public void click() {
        if (listener != null) {
            listener.onClick();
        }
    }
}

// 使用
Button button = new Button();
button.setListener(() -> System.out.println("按钮被点击了！"));
button.click();

3. 策略模式（设计模式）

通过接口定义算法族，动态切换策略：

interface PaymentStrategy {
    void pay(int amount);
}

class Alipay implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("支付宝支付：" + amount);
    }
}

class WechatPay implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("微信支付：" + amount);
    }
}

class ShoppingCart {
    private PaymentStrategy strategy;

    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

    public void checkout(int amount) {
        strategy.pay(amount);
    }
}

七、注意事项

1. 接口命名规范：通常以 -able 结尾（如 Runnable, Comparable）。
2. 避免过度设计：不要为了使用接口而增加不必要的抽象。
3. 默认方法的冲突：
   • 如果多个接口有相同的默认方法，实现类必须重写该方法。
   • 通过 接口名.super.方法名() 调用指定接口的默认方法。

     interface A { default void foo() { System.out.println("A"); } }
     interface B { default void foo() { System.out.println("B"); } }
     class C implements A, B {
     @Override
     public void foo() {
        A.super.foo(); // 明确调用A的默认方法
     }
     }

八、总结

• 接口核心作用：定义规范、解耦代码、支持多继承。
• 适用场景：需要定义通用行为、实现回调、动态策略切换等。
• 与抽象类的选择：优先使用接口定义行为，抽象类用于共享代码。

通过合理使用接口，可以显著提升代码的灵活性和可维护性。