[JavaSE]接口

接口是实现抽象、解耦、多态的核心机制，也是面向接口编程思想的载体。

一、接口的概念

我们先从生活场景理解：比如生活中的「充电接口」，不管你是Type-C、Lightning，只要符合统一的接口规范，就能给设备充电——接口本身不提供充电功能，它只规定「必须提供输出5V电压的充电能力」，具体怎么实现这个输出，由不同的接口厂商自己决定。

对应到Java中：

接口是一种抽象类型，是方法的集合，它只定义方法的规范（方法名、参数、返回值），不提供具体的实现逻辑；
具体类实现接口，就必须按照规范实现接口中定义的所有方法，保证对外行为统一。

官方定义

Java中的接口（Interface）是一种引用类型，用interface关键字声明，它本质是方法声明的集合，是对行为的抽象规范。一个类可以实现多个接口，从而实现类Java的"多继承"效果。

解释：
接口确实是抽象类型，只不过是隐式抽象的，也就是非必须显式加abstract；
在Java中，所有的接口默认是抽象类型，就算手动给接口加上abstract也不会报错（冗余写法）

二、基础语法

以现在主流的JDK 8+为例整理所有规则

1. 核心语法规则

补充：default默认方法  default关键字必须添加在方法的返回值类型之前、修饰符范围之后

2. 基础语法示例

我们用开头"充电"的例子写基础代码，对应所有规则

// 1. 接口声明：定义充电规范
public interface Chargeable {
// 2. 成员变量：默认public static final，必须赋值
int STANDARD_VOLTAGE = 5;

// 3. 抽象方法：默认public abstract，可以省略修饰符
// 规范要求：所有实现充电接口的设备，必须提供输出电流的方法
int outputCurrent();

// 4. 默认方法：JDK8新增，有完整实现，子类可以直接用，也可以重写
// 默认实现：检查电压是否符合标准
default boolean checkVoltage() {
return getCurrentVoltage() == STANDARD_VOLTAGE;
}

// 5. 静态方法：属于接口本身，不能被继承，只能通过接口名调用
static void showStandard() {
System.out.println("统一充电标准电压：" + STANDARD_VOLTAGE + "V");
}

// JDK9+私有方法：供接口内部默认方法调用，这里简化写法用private
private int getCurrentVoltage() {
return STANDARD_VOLTAGE;
}
}

接下来写不同的实现类，分别实现Chargeable接口：

// Type-C充电实现类
public class TypeCCharge implements Chargeable {
// 非抽象类必须重写接口所有抽象方法
@Override
public int outputCurrent() {
return 2; // Type-C输出2A电流
}

// 默认方法可以选择重写，也可以不重写直接用
}

// Lightning充电实现类
public class LightningCharge implements Chargeable {
@Override
public int outputCurrent() {
return 1; // Lightning输出1A电流
}
}

最后测试验证接口特性：

public class InterfaceTest {
public static void main(String[] args) {
// 错误写法：接口不能实例化，编译报错
// Chargeable chargeable = new Chargeable();

// 正确写法：向上转型，接口引用指向实现类对象，触发多态
Chargeable typeC = new TypeCCharge();
Chargeable lightning = new LightningCharge();

// 调用接口静态方法：只能通过接口名调用
Chargeable.showStandard();

// 输出成员变量：接口成员是静态常量，直接接口名访问
System.out.println("标准电压：" + Chargeable.STANDARD_VOLTAGE + "V");

// 调用默认方法：实现类继承默认方法，可以直接调用
System.out.println("电压检查结果：" + typeC.checkVoltage());

// 调用重写后的抽象方法，触发多态
System.out.println("Type-C输出电流：" + typeC.outputCurrent() + "A");
System.out.println("Lightning输出电流：" + lightning.outputCurrent() + "A");
}
}

统一充电标准电压：5V
标准电压：5V
电压检查结果：true
Type-C输出电流：2A
Lightning输出电流：1A

三、核心特性

1. 接口为什么没有构造方法？

接口是纯规范（除了默认/静态方法），本身不实例化，也没有成员变量需要初始化——所有成员变量都是静态常量，已经在定义时完成初始化，所以不需要构造方法。

2. JDK8为什么要新增默认方法？

（1）默认方法是为了解决接口升级兼容问题：如果一个接口已经被很多类实现了，这时候要给接口加新方法，所有实现类都必须重写新方法，会导致所有实现类都要修改代码。
（2）加了默认方法之后，新方法直接在接口里给出默认实现，原有实现类不需要修改代码就能直接用，兼容了旧版本，这也是Java集合框架在JDK8新增Stream方法不破坏兼容性的原因。

示例：假设原来我们的Chargeable只有outputCurrent方法，所有实现类都写完了，现在需要新增quickCharge快充方法，如果不是默认方法，所有旧实现类都必须重写这个方法；用默认方法给一个普通充电的默认实现，旧代码完全不需要改：

public interface Chargeable {
int STANDARD_VOLTAGE = 5;
int outputCurrent();
// 新增默认方法，旧实现类不用改
default boolean supportQuickCharge() {
return false; // 默认不支持快充
}
}

3. 默认方法冲突怎么解决？

如果一个类实现了两个接口，两个接口有同名同参数的默认方法，这时候编译器会报错，需要类自己重写这个方法，解决冲突：

// 接口A有同名默认方法
interface A {
default void sayHi() {
System.out.println("Hi from A");
}
}
// 接口B有同名默认方法
interface B {
default void sayHi() {
System.out.println("Hi from B");
}
}
// 实现类同时实现两个接口，必须重写解决冲突
class C implements A, B {
@Override
public void sayHi() {
// 可以指定调用其中一个接口的默认方法
A.super.sayHi();
}
}

4. 接口可以继承多个接口吗？

和类的单继承不同，接口支持多继承：一个接口可以继承多个其他接口，因为接口本身只是规范，多继承不会像类多继承那样带来方法体冲突问题。

interface BaseA {
void methodA();
}
interface BaseB {
void methodB();
}
// 接口多继承：同时继承两个父接口
interface Combine extends BaseA, BaseB {
void methodC();
}
// 实现类必须实现所有父接口和当前接口的抽象方法
class CombineImpl implements Combine {
@Override
public void methodA() {}
@Override
public void methodB() {}
@Override
public void methodC() {}
}

四、实战场景：接口最常用在哪里？

接口的核心价值是解耦，把"定义规范"和"具体实现"分开，让代码更容易扩展和维护，最常见的使用场景有下面几种：

1. 定义行为规范，跨继承体系复用

接口是can-do（能做什么）的抽象，不要求继承同一个父类，任何类都可以实现接口，定义统一的行为。
比如我们有不同的类：Apple（水果）、Battery（电池）、PowerBank（充电宝），它们本来不在同一个继承体系，但都可以充电，所以只需要让它们都实现Chargeable接口，就可以统一处理：

// 水果实现充电接口：现在很多水果做了NFC充电标签
public class Apple extends Fruit implements Chargeable {
@Override
public int outputCurrent() {
return 0; // 只是标签，不输出电流
}
}

// 充电宝实现充电接口
public class PowerBank implements Chargeable {
@Override
public int outputCurrent() {
return 3; // 支持3A快充
}
}

// 统一处理：所有实现Chargeable的对象，都可以调用充电方法
public class ChargeManager {
public void charge(Chargeable device) {
// 不管是什么类型的对象，只要实现了Chargeable，就能按照规范处理
// 不需要知道具体是什么类，只需要遵守规范
if(device.checkVoltage()) {
System.out.println("开始充电，输出电流：" + device.outputCurrent() + "A");
}
}
}

这种写法的好处：未来新增任何设备，只需要实现Chargeable接口，不需要修改ChargeManager的代码，完全符合开闭原则。

2. 面向接口编程，实现解耦

这是框架开发中最常用的方式：业务逻辑只依赖接口，不依赖具体实现，切换实现类的时候完全不用改业务代码。
举一个最常见的DAO层例子：我们的业务需要操作数据库，可能用MySQL，也可能换Oracle，我们只需要定义DAO接口，业务层调用接口，不用管具体实现：

// 1. 定义用户Dao接口：只规定规范，不关心用什么数据库
public interface UserDao {
User queryById(int id);
}

// 2. 具体实现：MySQL版本
public class UserDaoMysqlImpl implements UserDao {
@Override
public User queryById(int id) {
System.out.println("从MySQL查询用户id：" + id);
return new User(id, "张三");
}
}

// 具体实现：Oracle版本
public class UserDaoOracleImpl implements UserDao {
@Override
public User queryById(int id) {
System.out.println("从Oracle查询用户id：" + id);
return new User(id, "张三");
}
}

// 3. 业务层：只依赖接口，不依赖具体实现
public class UserService {
// 依赖注入接口，不new具体实现
private UserDao userDao;

// 构造方法注入，切换实现只需要传不同对象，不用改Service代码
public UserService(UserDao userDao) {
this.userDao = userDao;
}

public User getUserInfo(int id) {
// 业务逻辑只调用接口方法，不用关心底层实现
return userDao.queryById(id);
}
}

// 测试
public class Demo {
public static void main(String[] args) {
// 用MySQL：传Mysql实现
UserService mysqlService = new UserService(new UserDaoMysqlImpl());
mysqlService.getUserInfo(1);

// 换Oracle：只需要改这里，Service完全不用动
UserService oracleService = new UserService(new UserDaoOracleImpl());
oracleService.getUserInfo(1);
}}

从MySQL查询用户id：1
从Oracle查询用户id：1

这就是面向接口编程的核心优势：调用者只需要知道接口定义的规范，不需要知道具体实现，修改实现不影响调用方，极大降低了代码耦合度，这也是SpringIOC依赖注入的基础。

3. 作为回调函数的载体

在异步编程、事件处理中，接口常用来作为回调规范，比如Android的点击事件、Java的线程任务：

/ 定义点击回调接口
public interface OnClickListener {
void onClick(View view);
}

// 按钮持有回调引用
public class Button {
private OnClickListener listener;

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

// 点击触发时调用回调
public void click() {
if(listener != null) {
listener.onClick(this);
}
}
}

// 外部使用：只需要实现接口回调方法，不用关心按钮内部逻辑
public class Activity {
public void initView() {
Button button = new Button();
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View view) {
System.out.println("按钮被点击了，处理点击逻辑");
}
});
}
}

五、常见误区&和抽象类的对比

1. 误区

误区1：接口里所有方法都是抽象的 → 不对，JDK8以后可以有默认方法和静态方法，都有方法体；
误区2：接口不能有静态方法 → 不对，JDK8以后允许接口有静态方法；
误区3：一个类只能实现一个接口 → 不对，Java中一个类可以实现多个接口，这是接口弥补类单继承不足的优势；
误区4：默认方法可以被子类作为普通方法继承，静态方法也能继承 → 不对，接口的静态方法属于接口本身，不能被实现类或子接口继承，只能通过接口名调用；
误区5：接口的成员变量可以修改 → 不对，所有接口成员变量默认是public static final，都是常量，定义后不能修改。

2. 抽象类 vs 接口

六、总结

接口是Java面向对象思想中最重要的抽象机制，核心价值就是解耦，分离规范与实现，支撑面向接口编程，让代码更容易扩展和维护。

核心要点再回顾一遍：

1.接口用interface声明，没有构造方法，不能实例化，JDK8+支持抽象方法、默认方法、静态方法；
2.一个类可以实现多个接口，非抽象实现类必须重写所有抽象方法，默认方法可以继承也可以重写；
3.接口支持多继承，解决了类单继承的不足；默认方法是为了兼容接口升级，解决旧实现类的兼容问题；
4.接口核心应用场景是定义行为规范、面向接口编程解耦、作为回调载体；
5.抽象类侧重is-a关系和代码复用，接口侧重can-do规范和解耦，选型分场景使用。