什么是接口？

Java 中的接口（Interface）是一种抽象类型，是行为的规范，用来规定实现类需要提供的行为。接口中只有方法的声明（从 Java 8 开始可以包含一些方法的实现）。它是一种比抽象类更加彻底的抽象形式，适合在设计应用程序框架或多态调用时使用。

---

一、接口的基本概念

1. 定义接口：
   • 使用 interface 关键字定义。
   • 方法默认是 public abstract 的（即公共且抽象的）。
   • 成员变量默认是 public static final 的（即公共的静态常量）。

public interface Vehicle {
    // 静态常量
    int MAX_SPEED = 120; // 等同于 public static final int MAX_SPEED = 120;

    // 抽象方法
    void start(); // 等同于 public abstract void start();

    void stop();
}

2. 接口不能包含的内容：
   • 不能有普通实例变量（只能是 public static final 常量）。
   • 不能有普通方法（只能是抽象方法或 Java 8 之后的默认方法和静态方法）。
   • 不能有构造器（因为接口不能被实例化）。
3. 实现接口：
   • 使用 implements 关键字实现接口。
   • 实现类必须实现接口中的所有抽象方法，否则该类必须声明为 abstract。

public class Car implements Vehicle {
    @Override
    public void start() {
        System.out.println("Car is starting");
    }

    @Override
    public void stop() {
        System.out.println("Car is stopping");
    }
}

4. 接口引用：
   • 可以使用接口类型的引用变量指向实现类对象。
   • 接口引用只能调用接口中定义的方法。

public class Main {
    public static void main(String[] args) {
        Vehicle car = new Car(); // 接口引用
        car.start();
        car.stop();
    }
}

---

二、接口的成员

1. 成员变量：
   • 接口中定义的变量默认为 public static final，即常量。
   • 必须在声明时初始化，不能更改其值。

public interface Constants {
    int MAX = 100; // 等同于 public static final int MAX = 100;
}

2. 抽象方法：
   • 接口中的方法默认是 public abstract。
   • 实现类必须实现所有抽象方法。

public interface Example {
    void doSomething(); // 等同于 public abstract void doSomething();
}

3. 默认方法（Java 8 引入）：
   • 使用 default 关键字，允许接口提供方法的默认实现。
   • 实现类可以选择是否重写默认方法。

public interface DefaultMethodExample {
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }
}

实现类可以直接使用默认方法：

public class DefaultMethodImpl implements DefaultMethodExample {
    // 可以选择不重写 defaultMethod
}

4. 静态方法（Java 8 引入）：
   • 使用 static 关键字，可以通过接口名直接调用。

public interface StaticMethodExample {
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

调用：

StaticMethodExample.staticMethod();

5. 私有方法（Java 9 引入）：
   • 用于在接口中提供辅助功能，供默认方法或静态方法调用。
   • 私有方法不能被实现类访问。

public interface PrivateMethodExample {
    private void helperMethod() {
        System.out.println("This is a private method.");
    }

    default void usePrivateMethod() {
        helperMethod(); // 默认方法调用私有方法
    }
}

---

三、接口的多继承

Java 中的接口可以继承多个接口，这样可以组合多个接口的功能，避免了类的多继承问题。

public interface A {
    void methodA();
}

public interface B {
    void methodB();
}

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

实现类可以实现接口 C，同时需要实现 A 和 B 的方法：

public class MultiInheritanceImpl implements C {
    @Override
    public void methodA() {
        System.out.println("Method A");
    }

    @Override
    public void methodB() {
        System.out.println("Method B");
    }

    @Override
    public void methodC() {
        System.out.println("Method C");
    }
}

---

四、接口的多实现

一个类可以实现多个接口，这是 Java 提供的多重继承机制的变体形式。

public interface Flyable {
    void fly();
}

public interface Swimmable {
    void swim();
}

public class Bird implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Bird can fly");
    }

    @Override
    public void swim() {
        System.out.println("Bird can swim");
    }
}

---

五、接口与抽象类的对比

特性	接口	抽象类
实现方式	使用 implements	使用 extends
多继承	支持类实现多个接口	只能单继承
是否包含成员变量	只能定义 public static final 常量	可包含实例变量
是否包含方法	只能定义抽象方法、默认方法和静态方法	可包含抽象方法和具体方法
构造方法	没有构造方法	有构造方法
适用场景	定义行为规范（如多态、多实现）	定义基本行为和方法重用

---

六、示例：面向接口编程的完整案例

以下是一个电子支付系统的案例，展示如何使用接口实现灵活的设计。

定义支付接口：

public interface Payment {
    void pay(double amount);
}

实现不同的支付方式：

public class CreditCardPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Paid " + amount + " using Credit Card.");
    }
}

public class PayPalPayment implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Paid " + amount + " using PayPal.");
    }
}

使用支付处理器调用：

public class PaymentProcessor {
    private Payment payment;

    public PaymentProcessor(Payment payment) {
        this.payment = payment;
    }

    public void processPayment(double amount) {
        payment.pay(amount);
    }
}

测试代码：

public class Main {
    public static void main(String[] args) {
        Payment creditCard = new CreditCardPayment();
        Payment paypal = new PayPalPayment();

        PaymentProcessor processor = new PaymentProcessor(creditCard);
        processor.processPayment(100.0);

        processor = new PaymentProcessor(paypal);
        processor.processPayment(200.0);
    }
}

输出结果：

Paid 100.0 using Credit Card.
Paid 200.0 using PayPal.

---

七、接口的优点与限制

优点：

1. 提供多继承能力。
2. 定义类的行为规范，提升代码的灵活性。
3. 解耦程序，支持模块化设计。
4. 支持多态和面向接口编程。

限制：

1. 无法保存状态（没有实例变量）。
2. 实现类必须实现所有方法，可能导致重复代码。
3. 不支持构造方法，无法直接实例化。